This is the mail archive of the
gcc-patches@gcc.gnu.org
mailing list for the GCC project.
[PATCH] Update ENABLE_CHECKING to make it usable in "if" conditions
- From: Mikhail Maltsev <maltsevm at gmail dot com>
- To: gcc-patches <gcc-patches at gnu dot org>, Jeff Law <law at redhat dot com>, Richard Biener <richard dot guenther at gmail dot com>, Trevor Saunders <tbsaunde at tbsaunde dot org>
- Date: Mon, 31 Aug 2015 08:49:10 +0300
- Subject: [PATCH] Update ENABLE_CHECKING to make it usable in "if" conditions
- Authentication-results: sourceware.org; auth=none
Hi, all!
This patch removes some conditional compilation from GCC. In this patch I define
a macro CHECKING_P, which is equal to 1 when ENABLE_CHECKING is defined and 0
otherwise. The reason for using a new name is the following: currently in GCC
there are many places where ENABLE_CHECKING is checked using #ifdef, and it is a
common way to do such checks (though #if would also work and is used in several
places). If we change it in such way that it is always defined, accidentally
using "#ifdef" instead of "#if" will lead to subtle errors: some expensive
checks intended only for development stage will be enabled in release build and
cause performance degradation.
This patch removes all uses of ENABLE_CHECKING (I also tried poisoning this
identifier in system.h, and the build succeeded, but I don't know how will this
affect, e.g. merging feature branches, so I think such decisions should be made
by maintainers).
As for conditional compilation, I tried to remove it and replace #ifdef-s with
if-s where possible, but, of course, avoided changing data structures layout. I
also avoided reindenting large blocks of code. I changed some functions (and a
couple of global variables) that were only used in "checking" build so that now
they are always defined/compiled and have a DEBUG_FUNCTION (i.e. "used")
attribute. I'll try to handle them in a more clean way: move CHECKING_P check
inside their definitions - that will slightly reduce "visual noise" from
conditions like
if (CHECKING_P)
{
verify_insn_chain ();
verify_flow_info ();
}
in their callers. But I think it is better to do this change as a separate patch.
While working on this patch I noticed some issues worth mentioning. In
sese.h:bb_in_region we have a check (enabled only in "checking" build):
/* Check that there are no edges coming in the region: all the
predecessors of EXIT are dominated by ENTRY. */
FOR_EACH_EDGE (e, ei, exit->preds)
dominated_by_p (CDI_DOMINATORS, e->src, entry);
IIUC, dominated_by_p has no side effects, so it's useless. Changing it to
"gcc_assert (dominated_by_p (...));" causes regressions. I disabled it in the
patch and added a comment.
In lra.c we have:
#ifdef ENABLE_CHECKING
/* Function checks RTL for correctness. If FINAL_P is true, it is
done at the end of LRA and the check is more rigorous. */
static void
check_rtl (bool final_p)
...
#ifdef ENABLED_CHECKING
extract_constrain_insn (insn);
#endif
...
#endif /* #ifdef ENABLE_CHECKING */
The comment for extract_constrain_insn says:
/* Do uncached extract_insn, constrain_operands and complain about failures.
This should be used when extracting a pre-existing constrained instruction
if the caller wants to know which alternative was chosen. */
So, as I understand, this additional check can be useful. This patch removes
"#ifdef ENABLED_CHECKING" (without regressions).
The third issue is that some gcc_checking_assert-s were guarded by #ifdef like:
#ifdef ENABLE_CHECKING
gcc_checking_assert (!is_deleted (*slot));
#endif
(is_deleted is defined unconditionally).
Probably that is because it is not obvious from the "release" definition
#define gcc_checking_assert(EXPR) ((void)(0 && (EXPR)))
that EXPR is not evaluated.
At least, I first decided to change it to something like
"do { if (0) (void)(EXPR); } while(0)"
and only then realized that the effect of "0 &&" is exactly the same. I added a
comment to make it more obvious.
I tested the patch on x86_64-pc-linux-gnu with --enable-checking=yes and
"release". Likewise, built config-list.mk in both configurations. There we some
minor changes since that check, but I'll need to rebase the patch anyway, so I
will repeat the full check.
Please review the patch.
--
Regards,
Mikhail Maltsev
libcpp/ChangeLog:
2015-08-24 Mikhail Maltsev <maltsevm@gmail.com>
* include/line-map.h: Change #ifdef to #if.
* init.c: Likewise.
* macro.c (struct macro_arg_token_iter): Likewise.
(set_arg_token): Remove conditional compilation.
(macro_arg_token_iter_init, macro_arg_token_iter_forward,
macro_arg_token_iter_get_token,
macro_arg_token_iter_get_location): Change #ifdef to #if.
(alloc_expanded_arg_mem, _cpp_backup_tokens): Remove conditional
compilation.
* system.h: Define CHECKING_P macro.
gcc/lto/ChangeLog:
2015-08-24 Mikhail Maltsev <maltsevm@gmail.com>
* lto.c (unify_scc): Remove conditional compilation.
(lto_fixup_state, do_whole_program_analysis): Likewise.
gcc/fortran/ChangeLog:
2015-08-24 Mikhail Maltsev <maltsevm@gmail.com>
* trans-common.c (create_common): Remove conditional compilation.
* trans.c (gfc_add_modify_loc): Likewise.
gcc/cp/ChangeLog:
2015-08-24 Mikhail Maltsev <maltsevm@gmail.com>
* call.c: Change #ifdef to #if.
* constexpr.c (maybe_constant_value): Remove conditional compilation.
(fold_non_dependent_expr): Likewise.
* cp-tree.h: Change #ifdef to #if.
* decl2.c (cxx_post_compilation_parsing_cleanups): Remove conditional
compilation.
* mangle.c (add_substitution): Likewise.
* method.c (maybe_explain_implicit_delete): Likewise.
* parser.c (cp_parser_template_argument_list): Likewise.
* pt.c (check_unstripped_args): Change #ifdef to #if.
(template_parm_to_arg, template_parms_to_args,
coerce_template_parameter_pack, coerce_template_parms, tsubst_copy,
type_unification_real, build_non_dependent_expr): Remove conditional
compilation.
* tree.c (build_target_expr): Likewise.
* typeck.c (comptypes): Likewise.
* typeck2.c (digest_init_r): Likewise.
gcc/ada/ChangeLog:
2015-08-24 Mikhail Maltsev <maltsevm@gmail.com>
* gcc-interface/decl.c (gnat_to_gnu_entity): Use gcc_checking_assert.
* gcc-interface/trans.c (assoc_to_constructor): Remove conditional
compilation.
* gcc-interface/utils.c (relate_alias_sets): Likewise.
* gcc-interface/utils2.c (build_binary_op, build_unary_op): Use
gcc_checking_assert.
gcc/java/ChangeLog:
2015-08-24 Mikhail Maltsev <maltsevm@gmail.com>
* decl.c (java_mark_decl_local): Remove conditional compilation.
gcc/ChangeLog:
2015-08-24 Mikhail Maltsev <maltsevm@gmail.com>
* alloc-pool.h (pool_allocator::initialize, allocate, remove): Remove
conditional compilation.
* attribs.c (init_attributes): Change #ifdef to #if.
* cfgcleanup.c (try_optimize_cfg): Remove conditional compilation.
* cfgexpand.c (expand_goto, expand_debug_expr,
pass_expand::execute): Likewise.
* cfgrtl.c (commit_edge_insertions): Likewise.
(fixup_reorder_chain, cfg_layout_finalize, rtl_flow_call_edges_add):
Likewise.
* cgraph.c (symbol_table::create_edge,
cgraph_edge::redirect_call_stmt_to_callee): Likewise.
* cgraph.h (cgraph_node::get): Likewise.
* cgraphclones.c (symbol_table::materialize_all_clones): Likewise
* cgraphunit.c (mark_functions_to_output, cgraph_node::expand_thunk,
symbol_table::compile): Likewise.
* config/alpha/alpha.c (alpha_function_arg): Use gcc_checking_assert.
* config/arm/arm.c (arm_unwind_emit_sequence): Change #ifdef to #if.
* config/bfin/bfin.c (hwloop_optimize): Remove conditional compilation.
* config/i386/i386.c (ix86_print_operand_address): Change #ifdef to #if.
(output_387_binary_op): Remove conditional compilation.
* config/ia64/ia64.c (ia64_sched_init): Likewise.
(bundling): Change #ifdef to #if.
* config/m68k/m68k.c (m68k_sched_md_init_global): Likewise.
* config/rs6000/rs6000.c (htm_expand_builtin): Likewise.
(rs6000_emit_prologue): Likewise.
* config/rs6000/rs6000.h REGNO_REG_CLASS[CHECKING_P]: Likewise
* config/visium/visium.c (visium_setup_incoming_varargs): Likewise.
* ddg.c (add_cross_iteration_register_deps): Likewise.
(create_ddg_all_sccs): Likewise.
* df-core.c (df_finish_pass): Remove some conditional compilation.
(df_analyze): Likewise.
* diagnostic-core.h: Use CHECKING_P
* diagnostic.c (diagnostic_report_diagnostic): Remove conditional
compilation.
* dominance.c (calculate_dominance_info): Likewise.
* dwarf2out.c (add_AT_die_ref, const_ok_for_output_1,
mem_loc_descriptor, loc_list_from_tree, gen_lexical_block_die,
gen_type_die_with_usage, gen_type_die, dwarf2out_decl): Likewise.
* emit-rtl.c (verify_rtx_sharing, reorder_insns_nobb): Likewise.
* et-forest.c: Fix comment.
* except.c (duplicate_eh_regions): Remove conditional compilation.
* fwprop.c (register_active_defs, update_df_init, update_uses,
fwprop_init, fwprop_done): Likewise.
* genautomata.c: Fix #if condition.
* genconditions.c: Redefine CHECKING_P in generated code.
* genextract.c: Replace #ifdef with #if.
* gengtype.c (main): Remove conditional compilation.
* gengtype.h: Replace #ifdef with #if.
* ggc-page.c (ggc_grow): Remove conditional compilation.
* gimplify.c (gimplify_body, gimplify_hasher::equal): Likewise.
* graphite-isl-ast-to-gimple.c (graphite_verify): Likewise.
* graphite-scop-detection.c (create_sese_edges, build_graphite_scops,
canonicalize_loop_closed_ssa_form): Likewise.
* graphite-sese-to-poly.c (rewrite_reductions_out_of_ssa,
rewrite_cross_bb_scalar_deps_out_of_ssa,
rewrite_commutative_reductions_out_of_ssa): Likewise.
* hash-table.h (hash_table::find_empty_slot_for_expand): Likewise.
* ifcvt.c (if_convert): Likewise.
* ipa-cp.c (ipcp_propagate_stage): Likewise.
* ipa-devirt.c (type_in_anonymous_namespace_p, odr_type_p,
odr_types_equivalent_p, add_type_duplicate, get_odr_type): Likewise.
* ipa-icf.c (sem_item_optimizer::verify_classes,
sem_item_optimizer::traverse_congruence_split,
sem_item_optimizer::do_congruence_step_for_index): Likewise.
* ipa-inline-analysis.c (compute_inline_parameters): Likewise.
* ipa-inline-transform.c (save_inline_function_body): Likewise.
* ipa-inline.c (inline_small_functions, early_inliner): Likewise.
* ipa-inline.h (estimate_edge_growth): Likewise.
* ipa-visibility.c (function_and_variable_visibility): Likewise.
* ipa.c (symbol_table::remove_unreachable_nodes,
ipa_single_use): Likewise.
* ira-int.h: Replace #ifdef with #if.
* ira.c (ira): Remove conditional compilation.
* loop-doloop.c (doloop_optimize_loops): Likewise.
* loop-init.c (loop_optimizer_init, fix_loop_structure): Likewise.
* loop-invariant.c (move_loop_invariants): Likewise.
* lra-assigns.c (lra_assign): Likewise.
* lra-constraints.c (lra_constraints): Likewise.
* lra-eliminations.c (lra_eliminate): Likewise.
* lra-int.h (struct lra_reg): Replace #ifdef with #if.
* lra-lives.c (check_pseudos_live_through_calls,
lra_create_live_ranges_1): Likewise.
* lra-remat.c (create_remat_bb_data): Remove conditional compilation.
* lra.c (lra_update_insn_recog_data, restore_scratches): Likewise.
(check_rtl): Remove incorrect nested #ifdef.
(lra): Replace #ifdef with #if.
* lto-cgraph.c (input_cgraph_1): Remove conditional compilation.
* lto-streamer-out.c (DFS::DFS): Likewise.
(lto_output): Replace #ifdef with #if.
* lto-streamer.c (lto_streamer_init): Remove conditional compilation.
* omp-low.c (scan_omp_target, expand_omp_taskreg, expand_omp_target,
execute_expand_omp): Likewise.
(lower_omp_target): Replace #ifdef with #if.
* passes.c (execute_function_todo, execute_todo,
execute_one_pass): Remove conditional compilation.
* predict.c (tree_estimate_probability, propagate_freq): Likewise.
* pretty-print.c (pp_format): Likewise.
* real.c (real_to_decimal_for_mode): Likewise.
* recog.c (split_all_insns): Likewise.
* regcprop.c (kill_value_one_regno): Replace #ifdef with #if.
(copy_value): Remove conditional compilation.
* reload.c: Fix comment.
* sched-deps.c (CHECK): Remove unused macro definition.
(check_dep): Remove conditional compilation.
(add_or_update_dep_1): Likewise.
(sd_add_dep): Likewise.
* sel-sched-ir.c (free_regset_pool, tidy_control_flow): Likewise.
* sel-sched.c (struct moveop_static_params,
find_best_reg_for_expr): Replace #ifdef with #if.
(move_cond_jump): Remove conditional compilation.
(move_op_orig_expr_not_found, code_motion_process_successors,
move_op): Replace #ifdef with #if.
* sese.h (bb_in_region): Add comment, guard code with #if 0.
* ssa-iterators.h (first_readonly_imm_use,
next_readonly_imm_use): Remove conditional compilation.
* store-motion.c (compute_store_table): Likewise.
* symbol-summary.h: Likewise.
* system.h (CHECKING_P): Define.
* target.h (get_cumulative_args, pack_cumulative_args): Replace #ifdef
with #if.
* timevar.c (timer::print): Remove conditional compilation.
* trans-mem.c (ipa_tm_execute): Likewise.
* tree-cfg.c (move_stmt_op): Likewise.
(move_sese_region_to_fn, gimple_flow_call_edges_add): Likewise.
* tree-cfgcleanup.c (cleanup_tree_cfg_noloop,
repair_loop_structures): Likewise.
* tree-eh.c (remove_unreachable_handlers): Likewise.
* tree-if-conv.c (pass_if_conversion::execute): Likewise.
* tree-inline.c (expand_call_inline, optimize_inline_calls): Likewise.
* tree-into-ssa.c (update_ssa): Replace #ifdef with #if.
* tree-loop-distribution.c: Remove conditional compilation.
* tree-outof-ssa.c (eliminate_useless_phis): Replace #ifdef with #if.
(rewrite_trees): Remove conditional compilation.
* tree-parloops.c (pass_parallelize_loops::execute): Likewise.
* tree-predcom.c (suitable_component_p): Likewise.
* tree-profile.c (gimple_gen_const_delta_profiler): Likewise.
* tree-ssa-alias.c (refs_may_alias_p_1): Likewise.
* tree-ssa-live.c (calculate_live_ranges): Replace #ifdef with #if.
* tree-ssa-live.h (register_ssa_partition): Likewise.
* tree-ssa-loop-ivcanon.c (tree_unroll_loops_completely): Remove
conditional compilation.
* tree-ssa-loop-manip.c (add_exit_phi,
tree_transform_and_unroll_loop): Likewise.
* tree-ssa-math-opts.c (pass_cse_reciprocals::execute): Likewise.
* tree-ssa-operands.c (get_expr_operands): Likewise.
* tree-ssa-propagate.c (replace_exp_1): Likewise.
* tree-ssa-structalias.c (rewrite_constraints): Likewise.
* tree-ssa-ter.c (free_temp_expr_table): Replace #ifdef with #if.
* tree-ssa-threadupdate.c (duplicate_thread_path): Remove conditional
compilation.
* tree-ssanames.c (release_ssa_name_fn): Likewise.
* tree-stdarg.c (expand_ifn_va_arg): Likewise.
* tree-vect-loop-manip.c (slpeel_tree_duplicate_loop_to_edge_cfg,
vect_do_peeling_for_loop_bound,
vect_do_peeling_for_alignment): Likewise.
* tree-vrp.c (supports_overflow_infinity, set_value_range): Likewise.
* tree.c (free_lang_data_in_cgraph): Likewise.
* value-prof.c (gimple_remove_histogram_value, free_hist): Likewise.
* var-tracking.c (VAR_PART_OFFSET): Replace #ifdef with #if.
(canonicalize_values_star): Remove conditional compilation.
(compute_bb_dataflow): Replace #ifdef with #if.
(vt_find_locations, vt_emit_notes): Likewise.
diff --git a/gcc/ada/gcc-interface/decl.c b/gcc/ada/gcc-interface/decl.c
index 971c066..60d05e1 100644
--- a/gcc/ada/gcc-interface/decl.c
+++ b/gcc/ada/gcc-interface/decl.c
@@ -2710,10 +2710,8 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, int definition)
TYPE_HAS_ACTUAL_BOUNDS_P (gnu_inner) = 1;
-#ifdef ENABLE_CHECKING
/* Check for other cases of overloading. */
- gcc_assert (!TYPE_ACTUAL_BOUNDS (gnu_inner));
-#endif
+ gcc_checking_assert (!TYPE_ACTUAL_BOUNDS (gnu_inner));
}
for (gnat_index = First_Index (gnat_entity);
diff --git a/gcc/ada/gcc-interface/trans.c b/gcc/ada/gcc-interface/trans.c
index 413550a..6bddaa7 100644
--- a/gcc/ada/gcc-interface/trans.c
+++ b/gcc/ada/gcc-interface/trans.c
@@ -9325,11 +9325,12 @@ assoc_to_constructor (Entity_Id gnat_entity, Node_Id gnat_assoc, tree gnu_type)
gnu_result = extract_values (gnu_list, gnu_type);
-#ifdef ENABLE_CHECKING
- /* Verify that every entry in GNU_LIST was used. */
- for (; gnu_list; gnu_list = TREE_CHAIN (gnu_list))
- gcc_assert (TREE_ADDRESSABLE (gnu_list));
-#endif
+ if (CHECKING_P)
+ {
+ /* Verify that every entry in GNU_LIST was used. */
+ for (; gnu_list; gnu_list = TREE_CHAIN (gnu_list))
+ gcc_assert (TREE_ADDRESSABLE (gnu_list));
+ }
return gnu_result;
}
diff --git a/gcc/ada/gcc-interface/utils.c b/gcc/ada/gcc-interface/utils.c
index 0032839..e0b734b 100644
--- a/gcc/ada/gcc-interface/utils.c
+++ b/gcc/ada/gcc-interface/utils.c
@@ -1499,9 +1499,7 @@ relate_alias_sets (tree gnu_new_type, tree gnu_old_type, enum alias_set_op op)
/* The alias set shouldn't be copied between array types with different
aliasing settings because this can break the aliasing relationship
between the array type and its element type. */
-#ifndef ENABLE_CHECKING
- if (flag_strict_aliasing)
-#endif
+ if (CHECKING_P || flag_strict_aliasing)
gcc_assert (!(TREE_CODE (gnu_new_type) == ARRAY_TYPE
&& TREE_CODE (gnu_old_type) == ARRAY_TYPE
&& TYPE_NONALIASED_COMPONENT (gnu_new_type)
diff --git a/gcc/ada/gcc-interface/utils2.c b/gcc/ada/gcc-interface/utils2.c
index 6a998d3..bde9183 100644
--- a/gcc/ada/gcc-interface/utils2.c
+++ b/gcc/ada/gcc-interface/utils2.c
@@ -854,9 +854,8 @@ build_binary_op (enum tree_code op_code, tree result_type,
{
case INIT_EXPR:
case MODIFY_EXPR:
-#ifdef ENABLE_CHECKING
- gcc_assert (result_type == NULL_TREE);
-#endif
+ gcc_checking_assert (result_type == NULL_TREE);
+
/* If there were integral or pointer conversions on the LHS, remove
them; we'll be putting them back below if needed. Likewise for
conversions between array and record types, except for justified
@@ -1039,9 +1038,8 @@ build_binary_op (enum tree_code op_code, tree result_type,
case TRUTH_AND_EXPR:
case TRUTH_OR_EXPR:
case TRUTH_XOR_EXPR:
-#ifdef ENABLE_CHECKING
- gcc_assert (TREE_CODE (get_base_type (result_type)) == BOOLEAN_TYPE);
-#endif
+ gcc_checking_assert (TREE_CODE (
+ get_base_type (result_type)) == BOOLEAN_TYPE);
operation_type = left_base_type;
left_operand = convert (operation_type, left_operand);
right_operand = convert (operation_type, right_operand);
@@ -1053,9 +1051,8 @@ build_binary_op (enum tree_code op_code, tree result_type,
case LT_EXPR:
case EQ_EXPR:
case NE_EXPR:
-#ifdef ENABLE_CHECKING
- gcc_assert (TREE_CODE (get_base_type (result_type)) == BOOLEAN_TYPE);
-#endif
+ gcc_checking_assert (TREE_CODE (
+ get_base_type (result_type)) == BOOLEAN_TYPE);
/* If either operand is a NULL_EXPR, just return a new one. */
if (TREE_CODE (left_operand) == NULL_EXPR)
return build2 (op_code, result_type,
@@ -1335,9 +1332,8 @@ build_unary_op (enum tree_code op_code, tree result_type, tree operand)
break;
case TRUTH_NOT_EXPR:
-#ifdef ENABLE_CHECKING
- gcc_assert (TREE_CODE (get_base_type (result_type)) == BOOLEAN_TYPE);
-#endif
+ gcc_checking_assert (TREE_CODE (
+ get_base_type (result_type)) == BOOLEAN_TYPE);
result = invert_truthvalue_loc (EXPR_LOCATION (operand), operand);
/* When not optimizing, fold the result as invert_truthvalue_loc
doesn't fold the result of comparisons. This is intended to undo
diff --git a/gcc/alloc-pool.h b/gcc/alloc-pool.h
index 03bde63..e78271c 100644
--- a/gcc/alloc-pool.h
+++ b/gcc/alloc-pool.h
@@ -243,15 +243,16 @@ pool_allocator::initialize ()
m_block_size = (size * m_elts_per_block) + header_size;
-#ifdef ENABLE_CHECKING
- /* Increase the last used ID and use it for this pool.
- ID == 0 is used for free elements of pool so skip it. */
- last_id++;
- if (last_id == 0)
- last_id++;
-
- m_id = last_id;
-#endif
+ if (CHECKING_P)
+ {
+ /* Increase the last used ID and use it for this pool.
+ ID == 0 is used for free elements of pool so skip it. */
+ last_id++;
+ if (last_id == 0)
+ last_id++;
+
+ m_id = last_id;
+ }
}
/* Free all memory allocated for the given memory pool. */
@@ -351,10 +352,9 @@ pool_allocator::allocate ()
block = m_virgin_free_list;
header = (allocation_pool_list*) allocation_object::get_data (block);
header->next = NULL;
-#ifdef ENABLE_CHECKING
- /* Mark the element to be free. */
- ((allocation_object*) block)->id = 0;
-#endif
+ if (CHECKING_P)
+ /* Mark the element to be free. */
+ ((allocation_object*) block)->id = 0;
VALGRIND_DISCARD (VALGRIND_MAKE_MEM_NOACCESS (header,size));
m_returned_free_list = header;
m_virgin_free_list += m_elt_size;
@@ -368,10 +368,9 @@ pool_allocator::allocate ()
m_returned_free_list = header->next;
m_elts_free--;
-#ifdef ENABLE_CHECKING
/* Set the ID for element. */
- allocation_object::get_instance (header)->id = m_id;
-#endif
+ if (CHECKING_P)
+ allocation_object::get_instance (header)->id = m_id;
VALGRIND_DISCARD (VALGRIND_MAKE_MEM_UNDEFINED (header, size));
return (void *)(header);
@@ -387,18 +386,18 @@ pool_allocator::remove (void *object)
int size ATTRIBUTE_UNUSED;
size = m_elt_size - offsetof (allocation_object, u.data);
-#ifdef ENABLE_CHECKING
- gcc_assert (object
+ gcc_checking_assert (object
/* Check if we free more than we allocated, which is Bad (TM). */
&& m_elts_free < m_elts_allocated
/* Check whether the PTR was allocated from POOL. */
&& m_id == allocation_object::get_instance (object)->id);
- memset (object, 0xaf, size);
-
- /* Mark the element to be free. */
- allocation_object::get_instance (object)->id = 0;
-#endif
+ if (CHECKING_P)
+ {
+ memset (object, 0xaf, size);
+ /* Mark the element to be free. */
+ allocation_object::get_instance (object)->id = 0;
+ }
header = (allocation_pool_list*) object;
header->next = m_returned_free_list;
diff --git a/gcc/attribs.c b/gcc/attribs.c
index 6cbe011..e776228 100644
--- a/gcc/attribs.c
+++ b/gcc/attribs.c
@@ -195,7 +195,7 @@ init_attributes (void)
if (attribute_tables[i] == NULL)
attribute_tables[i] = empty_attribute_table;
-#ifdef ENABLE_CHECKING
+#if CHECKING_P
/* Make some sanity checks on the attribute tables. */
for (i = 0; i < ARRAY_SIZE (attribute_tables); i++)
{
diff --git a/gcc/cfgcleanup.c b/gcc/cfgcleanup.c
index 7e576bc..8795eef 100644
--- a/gcc/cfgcleanup.c
+++ b/gcc/cfgcleanup.c
@@ -2875,9 +2875,8 @@ try_optimize_cfg (int mode)
which will be done in fixup_partitions. */
fixup_partitions ();
-#ifdef ENABLE_CHECKING
- verify_flow_info ();
-#endif
+ if (CHECKING_P)
+ verify_flow_info ();
}
changed_overall |= changed;
diff --git a/gcc/cfgexpand.c b/gcc/cfgexpand.c
index d567a87..89b08ff 100644
--- a/gcc/cfgexpand.c
+++ b/gcc/cfgexpand.c
@@ -3289,12 +3289,13 @@ expand_computed_goto (tree exp)
static void
expand_goto (tree label)
{
-#ifdef ENABLE_CHECKING
- /* Check for a nonlocal goto to a containing function. Should have
- gotten translated to __builtin_nonlocal_goto. */
- tree context = decl_function_context (label);
- gcc_assert (!context || context == current_function_decl);
-#endif
+ if (CHECKING_P)
+ {
+ /* Check for a nonlocal goto to a containing function. Should have
+ gotten translated to __builtin_nonlocal_goto. */
+ tree context = decl_function_context (label);
+ gcc_assert (!context || context == current_function_decl);
+ }
emit_jump (jump_target_rtx (label));
}
@@ -5073,12 +5074,12 @@ expand_debug_expr (tree exp)
default:
flag_unsupported:
-#ifdef ENABLE_CHECKING
- debug_tree (exp);
- gcc_unreachable ();
-#else
+ if (CHECKING_P)
+ {
+ debug_tree (exp);
+ gcc_unreachable ();
+ }
return NULL;
-#endif
}
}
@@ -6413,9 +6414,8 @@ pass_expand::execute (function *fun)
gcc.c-torture/execute/ipa-sra-2.c execution, -Os -m32 fails otherwise. */
cleanup_cfg (CLEANUP_NO_INSN_DEL);
-#ifdef ENABLE_CHECKING
- verify_flow_info ();
-#endif
+ if (CHECKING_P)
+ verify_flow_info ();
/* Initialize pseudos allocated for hard registers. */
emit_initial_value_sets ();
diff --git a/gcc/cfgrtl.c b/gcc/cfgrtl.c
index 15ce8a7..e7b7d85 100644
--- a/gcc/cfgrtl.c
+++ b/gcc/cfgrtl.c
@@ -2097,9 +2097,8 @@ commit_edge_insertions (void)
which will be done by fixup_partitions. */
fixup_partitions ();
-#ifdef ENABLE_CHECKING
- verify_flow_info ();
-#endif
+ if (CHECKING_P)
+ verify_flow_info ();
FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR_FOR_FN (cfun),
EXIT_BLOCK_PTR_FOR_FN (cfun), next_bb)
@@ -3723,9 +3722,8 @@ fixup_reorder_chain (void)
insn = NEXT_INSN (insn);
set_last_insn (insn);
-#ifdef ENABLE_CHECKING
- verify_insn_chain ();
-#endif
+ if (CHECKING_P)
+ verify_insn_chain ();
/* Now add jumps and labels as needed to match the blocks new
outgoing edges. */
@@ -4313,9 +4311,8 @@ break_superblocks (void)
void
cfg_layout_finalize (void)
{
-#ifdef ENABLE_CHECKING
- verify_flow_info ();
-#endif
+ if (CHECKING_P)
+ verify_flow_info ();
force_one_exit_fallthru ();
rtl_register_cfg_hooks ();
if (reload_completed && !targetm.have_epilogue ())
@@ -4325,10 +4322,11 @@ cfg_layout_finalize (void)
rebuild_jump_labels (get_insns ());
delete_dead_jumptables ();
-#ifdef ENABLE_CHECKING
- verify_insn_chain ();
- verify_flow_info ();
-#endif
+ if (CHECKING_P)
+ {
+ verify_insn_chain ();
+ verify_flow_info ();
+ }
}
@@ -4893,13 +4891,11 @@ rtl_flow_call_edges_add (sbitmap blocks)
block in CFG already. Calling make_edge in such case would
cause us to mark that edge as fake and remove it later. */
-#ifdef ENABLE_CHECKING
- if (split_at_insn == BB_END (bb))
+ if (CHECKING_P && split_at_insn == BB_END (bb))
{
e = find_edge (bb, EXIT_BLOCK_PTR_FOR_FN (cfun));
gcc_assert (e == NULL);
}
-#endif
/* Note that the following may create a new basic block
and renumber the existing basic blocks. */
diff --git a/gcc/cgraph.c b/gcc/cgraph.c
index 22a9852..55c8a5d 100644
--- a/gcc/cgraph.c
+++ b/gcc/cgraph.c
@@ -832,11 +832,9 @@ symbol_table::create_edge (cgraph_node *caller, cgraph_node *callee,
{
/* This is a rather expensive check possibly triggering
construction of call stmt hashtable. */
-#ifdef ENABLE_CHECKING
cgraph_edge *e;
gcc_checking_assert (
!(e = caller->get_edge (call_stmt)) || e->speculative);
-#endif
gcc_assert (is_gimple_call (call_stmt));
}
@@ -1282,9 +1280,6 @@ cgraph_edge::redirect_call_stmt_to_callee (void)
gcall *new_stmt;
gimple_stmt_iterator gsi;
bool skip_bounds = false;
-#ifdef ENABLE_CHECKING
- cgraph_node *node;
-#endif
if (e->speculative)
{
@@ -1402,13 +1397,11 @@ cgraph_edge::redirect_call_stmt_to_callee (void)
&& !skip_bounds))
return e->call_stmt;
-#ifdef ENABLE_CHECKING
- if (decl)
+ if (CHECKING_P && decl)
{
- node = cgraph_node::get (decl);
+ cgraph_node *node = cgraph_node::get (decl);
gcc_assert (!node || !node->clone.combined_args_to_skip);
}
-#endif
if (symtab->dump_file)
{
diff --git a/gcc/cgraph.h b/gcc/cgraph.h
index 6607b11..fec27b6 100644
--- a/gcc/cgraph.h
+++ b/gcc/cgraph.h
@@ -362,7 +362,6 @@ public:
and NULL otherwise. */
static inline symtab_node *get (const_tree decl)
{
-#ifdef ENABLE_CHECKING
/* Check that we are called for sane type of object - functions
and static or external variables. */
gcc_checking_assert (TREE_CODE (decl) == FUNCTION_DECL
@@ -374,7 +373,6 @@ public:
memcpy/memset on the tree nodes. */
gcc_checking_assert (!decl->decl_with_vis.symtab_node
|| decl->decl_with_vis.symtab_node->decl == decl);
-#endif
return decl->decl_with_vis.symtab_node;
}
diff --git a/gcc/cgraphclones.c b/gcc/cgraphclones.c
index 9e9f1a0..83b0e1f 100644
--- a/gcc/cgraphclones.c
+++ b/gcc/cgraphclones.c
@@ -1076,9 +1076,8 @@ symbol_table::materialize_all_clones (void)
if (symtab->dump_file)
fprintf (symtab->dump_file, "Materializing clones\n");
-#ifdef ENABLE_CHECKING
- cgraph_node::verify_cgraph_nodes ();
-#endif
+ if (CHECKING_P)
+ cgraph_node::verify_cgraph_nodes ();
/* We can also do topological order, but number of iterations should be
bounded by number of IPA passes since single IPA pass is probably not
@@ -1147,9 +1146,8 @@ symbol_table::materialize_all_clones (void)
node->clear_stmts_in_references ();
if (symtab->dump_file)
fprintf (symtab->dump_file, "Materialization Call site updates done.\n");
-#ifdef ENABLE_CHECKING
- cgraph_node::verify_cgraph_nodes ();
-#endif
+ if (CHECKING_P)
+ cgraph_node::verify_cgraph_nodes ();
symtab->remove_unreachable_nodes (symtab->dump_file);
}
diff --git a/gcc/cgraphunit.c b/gcc/cgraphunit.c
index a95ce9e..1e510e0 100644
--- a/gcc/cgraphunit.c
+++ b/gcc/cgraphunit.c
@@ -1262,13 +1262,12 @@ handle_alias_pairs (void)
static void
mark_functions_to_output (void)
{
- cgraph_node *node;
-#ifdef ENABLE_CHECKING
bool check_same_comdat_groups = false;
+ cgraph_node *node;
- FOR_EACH_FUNCTION (node)
- gcc_assert (!node->process);
-#endif
+ if (CHECKING_P)
+ FOR_EACH_FUNCTION (node)
+ gcc_assert (!node->process);
FOR_EACH_FUNCTION (node)
{
@@ -1302,15 +1301,14 @@ mark_functions_to_output (void)
}
else if (node->same_comdat_group)
{
-#ifdef ENABLE_CHECKING
- check_same_comdat_groups = true;
-#endif
+ if (CHECKING_P)
+ check_same_comdat_groups = true;
}
else
{
/* We should've reclaimed all functions that are not needed. */
-#ifdef ENABLE_CHECKING
- if (!node->global.inlined_to
+ if (CHECKING_P
+ && !node->global.inlined_to
&& gimple_has_body_p (decl)
/* FIXME: in ltrans unit when offline copy is outside partition but inline copies
are inside partition, we can end up not removing the body since we no longer
@@ -1323,7 +1321,6 @@ mark_functions_to_output (void)
node->debug ();
internal_error ("failed to reclaim unneeded function");
}
-#endif
gcc_assert (node->global.inlined_to
|| !gimple_has_body_p (decl)
|| node->in_other_partition
@@ -1334,8 +1331,7 @@ mark_functions_to_output (void)
}
}
-#ifdef ENABLE_CHECKING
- if (check_same_comdat_groups)
+ if (CHECKING_P && check_same_comdat_groups)
FOR_EACH_FUNCTION (node)
if (node->same_comdat_group && !node->process)
{
@@ -1355,7 +1351,6 @@ mark_functions_to_output (void)
"comdat group");
}
}
-#endif
}
/* DECL is FUNCTION_DECL. Initialize datastructures so DECL is a function
@@ -1824,9 +1819,8 @@ cgraph_node::expand_thunk (bool output_asm_thunks, bool force_gimple_thunk)
TREE_ASM_WRITTEN (thunk_fndecl) = false;
delete_unreachable_blocks ();
update_ssa (TODO_update_ssa);
-#ifdef ENABLE_CHECKING
- verify_flow_info ();
-#endif
+ if (CHECKING_P)
+ verify_flow_info ();
free_dominance_info (CDI_DOMINATORS);
/* Since we want to emit the thunk, we explicitly mark its name as
@@ -2310,9 +2304,8 @@ symbol_table::compile (void)
if (seen_error ())
return;
-#ifdef ENABLE_CHECKING
- symtab_node::verify_symtab_nodes ();
-#endif
+ if (CHECKING_P)
+ symtab_node::verify_symtab_nodes ();
timevar_push (TV_CGRAPHOPT);
if (pre_ipa_mem_report)
@@ -2361,9 +2354,8 @@ symbol_table::compile (void)
(*debug_hooks->assembly_start) ();
if (!quiet_flag)
fprintf (stderr, "Assembling functions:\n");
-#ifdef ENABLE_CHECKING
- symtab_node::verify_symtab_nodes ();
-#endif
+ if (CHECKING_P)
+ symtab_node::verify_symtab_nodes ();
materialize_all_clones ();
bitmap_obstack_initialize (NULL);
@@ -2419,7 +2411,8 @@ symbol_table::compile (void)
fprintf (dump_file, "\nFinal ");
symtab_node::dump_table (dump_file);
}
-#ifdef ENABLE_CHECKING
+ if (!CHECKING_P)
+ return;
symtab_node::verify_symtab_nodes ();
/* Double check that all inline clones are gone and that all
function bodies have been released from memory. */
@@ -2438,7 +2431,6 @@ symbol_table::compile (void)
if (error_found)
internal_error ("nodes with unreleased memory found");
}
-#endif
}
diff --git a/gcc/config/alpha/alpha.c b/gcc/config/alpha/alpha.c
index ca07cc7..2a745aa 100644
--- a/gcc/config/alpha/alpha.c
+++ b/gcc/config/alpha/alpha.c
@@ -5574,11 +5574,9 @@ alpha_function_arg (cumulative_args_t cum_v, machine_mode mode,
basereg = 16;
else
{
-#ifdef ENABLE_CHECKING
/* With alpha_split_complex_arg, we shouldn't see any raw complex
values here. */
- gcc_assert (!COMPLEX_MODE_P (mode));
-#endif
+ gcc_checking_assert (!COMPLEX_MODE_P (mode));
/* Set up defaults for FP operands passed in FP registers, and
integral operands passed in integer registers. */
diff --git a/gcc/config/arm/arm.c b/gcc/config/arm/arm.c
index c2095a3..04e8ebf 100644
--- a/gcc/config/arm/arm.c
+++ b/gcc/config/arm/arm.c
@@ -26543,7 +26543,7 @@ arm_unwind_emit_sequence (FILE * asm_out_file, rtx p)
else
asm_fprintf (asm_out_file, "%r", reg);
-#ifdef ENABLE_CHECKING
+#if CHECKING_P
/* Check that the addresses are consecutive. */
e = XEXP (SET_DEST (e), 0);
if (GET_CODE (e) == PLUS)
diff --git a/gcc/config/bfin/bfin.c b/gcc/config/bfin/bfin.c
index a131053..e53fe6d 100644
--- a/gcc/config/bfin/bfin.c
+++ b/gcc/config/bfin/bfin.c
@@ -3811,8 +3811,7 @@ hwloop_optimize (hwloop_info loop)
edge e;
edge_iterator ei;
-#ifdef ENABLE_CHECKING
- if (loop->head != loop->incoming_dest)
+ if (CHECKING_P && loop->head != loop->incoming_dest)
{
/* We aren't entering the loop at the top. Since we've established
that the loop is entered only at one point, this means there
@@ -3822,7 +3821,6 @@ hwloop_optimize (hwloop_info loop)
FOR_EACH_EDGE (e, ei, loop->head->preds)
gcc_assert (!(e->flags & EDGE_FALLTHRU));
}
-#endif
emit_insn_before (seq, BB_HEAD (loop->head));
seq = emit_label_before (gen_label_rtx (), seq);
diff --git a/gcc/config/i386/i386.c b/gcc/config/i386/i386.c
index 05fa5e1..94d5faf 100644
--- a/gcc/config/i386/i386.c
+++ b/gcc/config/i386/i386.c
@@ -16248,7 +16248,7 @@ ix86_print_operand_address (FILE *file, rtx addr)
/* Print SImode register names to force addr32 prefix. */
if (SImode_address_operand (addr, VOIDmode))
{
-#ifdef ENABLE_CHECKING
+#if CHECKING_P
gcc_assert (TARGET_64BIT);
switch (GET_CODE (addr))
{
@@ -16520,10 +16520,10 @@ output_387_binary_op (rtx insn, rtx *operands)
const char *ssep;
int is_sse = SSE_REG_P (operands[0]) || SSE_REG_P (operands[1]) || SSE_REG_P (operands[2]);
-#ifdef ENABLE_CHECKING
/* Even if we do not want to check the inputs, this documents input
constraints. Which helps in understanding the following code. */
- if (STACK_REG_P (operands[0])
+ if (CHECKING_P
+ && STACK_REG_P (operands[0])
&& ((REG_P (operands[1])
&& REGNO (operands[0]) == REGNO (operands[1])
&& (STACK_REG_P (operands[2]) || MEM_P (operands[2])))
@@ -16533,8 +16533,7 @@ output_387_binary_op (rtx insn, rtx *operands)
&& (STACK_TOP_P (operands[1]) || STACK_TOP_P (operands[2])))
; /* ok */
else
- gcc_assert (is_sse);
-#endif
+ gcc_checking_assert (is_sse);
switch (GET_CODE (operands[3]))
{
diff --git a/gcc/config/ia64/ia64.c b/gcc/config/ia64/ia64.c
index 779fc58..1f40ba2 100644
--- a/gcc/config/ia64/ia64.c
+++ b/gcc/config/ia64/ia64.c
@@ -6145,7 +6145,7 @@ struct reg_write_state
/* Cumulative info for the current instruction group. */
struct reg_write_state rws_sum[NUM_REGS];
-#ifdef ENABLE_CHECKING
+#if CHECKING_P
/* Bitmap whether a register has been written in the current insn. */
HARD_REG_ELT_TYPE rws_insn[(NUM_REGS + HOST_BITS_PER_WIDEST_FAST_INT - 1)
/ HOST_BITS_PER_WIDEST_FAST_INT];
@@ -7313,15 +7313,13 @@ ia64_sched_init (FILE *dump ATTRIBUTE_UNUSED,
int sched_verbose ATTRIBUTE_UNUSED,
int max_ready ATTRIBUTE_UNUSED)
{
-#ifdef ENABLE_CHECKING
- rtx_insn *insn;
-
- if (!sel_sched_p () && reload_completed)
- for (insn = NEXT_INSN (current_sched_info->prev_head);
- insn != current_sched_info->next_tail;
- insn = NEXT_INSN (insn))
- gcc_assert (!SCHED_GROUP_P (insn));
-#endif
+ if (CHECKING_P && !sel_sched_p () && reload_completed)
+ {
+ for (rtx_insn *insn = NEXT_INSN (current_sched_info->prev_head);
+ insn != current_sched_info->next_tail;
+ insn = NEXT_INSN (insn))
+ gcc_assert (!SCHED_GROUP_P (insn));
+ }
last_scheduled_insn = NULL;
init_insn_group_barriers ();
@@ -9319,7 +9317,7 @@ bundling (FILE *dump, int verbose, rtx_insn *prev_head_insn, rtx_insn *tail)
}
}
-#ifdef ENABLE_CHECKING
+#if CHECKING_P
{
/* Assert right calculation of middle_bundle_stops. */
int num = best_state->middle_bundle_stops;
diff --git a/gcc/config/m68k/m68k.c b/gcc/config/m68k/m68k.c
index c26f37b..35f5a20 100644
--- a/gcc/config/m68k/m68k.c
+++ b/gcc/config/m68k/m68k.c
@@ -6125,7 +6125,7 @@ m68k_sched_md_init_global (FILE *sched_dump ATTRIBUTE_UNUSED,
int sched_verbose ATTRIBUTE_UNUSED,
int n_insns ATTRIBUTE_UNUSED)
{
-#ifdef ENABLE_CHECKING
+#if CHECKING_P
/* Check that all instructions have DFA reservations and
that all instructions can be issued from a clean state. */
{
diff --git a/gcc/config/rs6000/rs6000.c b/gcc/config/rs6000/rs6000.c
index 2a96978..23fe72a 100644
--- a/gcc/config/rs6000/rs6000.c
+++ b/gcc/config/rs6000/rs6000.c
@@ -12838,15 +12838,13 @@ htm_expand_builtin (tree exp, rtx target, bool * expandedp)
case HTM_BUILTIN_TENDALL: /* Alias for: tend. 1 */
case HTM_BUILTIN_TRESUME: /* Alias for: tsr. 1 */
op[nopnds++] = GEN_INT (1);
-#ifdef ENABLE_CHECKING
- attr |= RS6000_BTC_UNARY;
-#endif
+ if (CHECKING_P)
+ attr |= RS6000_BTC_UNARY;
break;
case HTM_BUILTIN_TSUSPEND: /* Alias for: tsr. 0 */
op[nopnds++] = GEN_INT (0);
-#ifdef ENABLE_CHECKING
- attr |= RS6000_BTC_UNARY;
-#endif
+ if (CHECKING_P)
+ attr |= RS6000_BTC_UNARY;
break;
default:
break;
@@ -12867,7 +12865,7 @@ htm_expand_builtin (tree exp, rtx target, bool * expandedp)
op[nopnds++] = cr;
}
-#ifdef ENABLE_CHECKING
+#if CHECKING_P
int expected_nopnds = 0;
if ((attr & RS6000_BTC_TYPE_MASK) == RS6000_BTC_UNARY)
expected_nopnds = 1;
@@ -23862,7 +23860,7 @@ rs6000_emit_prologue (void)
prior to it, when r12 is not used here for other purposes. */
rtx_insn *sp_adjust = 0;
-#ifdef ENABLE_CHECKING
+#if CHECKING_P
/* Track and check usage of r0, r11, r12. */
int reg_inuse = using_static_chain_p ? 1 << 11 : 0;
#define START_USE(R) do \
diff --git a/gcc/config/rs6000/rs6000.h b/gcc/config/rs6000/rs6000.h
index e4f2937..437be0f 100644
--- a/gcc/config/rs6000/rs6000.h
+++ b/gcc/config/rs6000/rs6000.h
@@ -1471,7 +1471,7 @@ enum reg_class
extern enum reg_class rs6000_regno_regclass[FIRST_PSEUDO_REGISTER];
-#if ENABLE_CHECKING
+#if CHECKING_P
#define REGNO_REG_CLASS(REGNO) \
(gcc_assert (IN_RANGE ((REGNO), 0, FIRST_PSEUDO_REGISTER-1)), \
rs6000_regno_regclass[(REGNO)])
diff --git a/gcc/config/visium/visium.c b/gcc/config/visium/visium.c
index 41b7964..a8d1f22 100644
--- a/gcc/config/visium/visium.c
+++ b/gcc/config/visium/visium.c
@@ -1345,7 +1345,7 @@ visium_setup_incoming_varargs (cumulative_args_t pcum_v,
local_args_so_far.p = &local_copy;
locargs = get_cumulative_args (pcum_v);
-#ifdef ENABLE_CHECKING
+#if CHECKING_P
local_args_so_far.magic = CUMULATIVE_ARGS_MAGIC;
#endif
diff --git a/gcc/cp/call.c b/gcc/cp/call.c
index 8d4a9e2..c58a773 100644
--- a/gcc/cp/call.c
+++ b/gcc/cp/call.c
@@ -730,7 +730,7 @@ alloc_conversion (conversion_kind kind)
return c;
}
-#ifdef ENABLE_CHECKING
+#if CHECKING_P
/* Make sure that all memory on the conversion obstack has been
freed. */
@@ -743,7 +743,7 @@ validate_conversion_obstack (void)
== obstack_base (&conversion_obstack)));
}
-#endif /* ENABLE_CHECKING */
+#endif /* CHECKING_P */
/* Dynamically allocate an array of N conversions. */
diff --git a/gcc/cp/constexpr.c b/gcc/cp/constexpr.c
index 1eacb8b..9b11f7c 100644
--- a/gcc/cp/constexpr.c
+++ b/gcc/cp/constexpr.c
@@ -3850,13 +3850,11 @@ maybe_constant_value (tree t, tree decl)
}
r = cxx_eval_outermost_constant_expr (t, true, true, decl);
-#ifdef ENABLE_CHECKING
- gcc_assert (r == t
- || CONVERT_EXPR_P (t)
- || TREE_CODE (t) == VIEW_CONVERT_EXPR
- || (TREE_CONSTANT (t) && !TREE_CONSTANT (r))
- || !cp_tree_equal (r, t));
-#endif
+ gcc_checking_assert (r == t
+ || CONVERT_EXPR_P (t)
+ || TREE_CODE (t) == VIEW_CONVERT_EXPR
+ || (TREE_CONSTANT (t) && !TREE_CONSTANT (r))
+ || !cp_tree_equal (r, t));
return r;
}
@@ -3900,14 +3898,12 @@ fold_non_dependent_expr (tree t)
}
tree r = cxx_eval_outermost_constant_expr (t, true, true, NULL_TREE);
-#ifdef ENABLE_CHECKING
/* cp_tree_equal looks through NOPs, so allow them. */
- gcc_assert (r == t
- || CONVERT_EXPR_P (t)
- || TREE_CODE (t) == VIEW_CONVERT_EXPR
- || (TREE_CONSTANT (t) && !TREE_CONSTANT (r))
- || !cp_tree_equal (r, t));
-#endif
+ gcc_checking_assert (r == t
+ || CONVERT_EXPR_P (t)
+ || TREE_CODE (t) == VIEW_CONVERT_EXPR
+ || (TREE_CONSTANT (t) && !TREE_CONSTANT (r))
+ || !cp_tree_equal (r, t));
return r;
}
else if (TREE_OVERFLOW_P (t))
diff --git a/gcc/cp/cp-tree.h b/gcc/cp/cp-tree.h
index 4dee60c..740375a 100644
--- a/gcc/cp/cp-tree.h
+++ b/gcc/cp/cp-tree.h
@@ -3007,7 +3007,7 @@ extern void decl_shadowed_for_var_insert (tree, tree);
property. */
#define SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT(NODE, INT_VALUE) \
NON_DEFAULT_TEMPLATE_ARGS_COUNT(NODE) = build_int_cst (NULL_TREE, INT_VALUE)
-#ifdef ENABLE_CHECKING
+#if CHECKING_P
#define GET_NON_DEFAULT_TEMPLATE_ARGS_COUNT(NODE) \
int_cst_value (NON_DEFAULT_TEMPLATE_ARGS_COUNT (NODE))
#else
@@ -5470,9 +5470,7 @@ extern tree build_cxx_call (tree, int, tree *,
tsubst_flags_t);
extern bool is_std_init_list (tree);
extern bool is_list_ctor (tree);
-#ifdef ENABLE_CHECKING
extern void validate_conversion_obstack (void);
-#endif /* ENABLE_CHECKING */
extern void mark_versions_used (tree);
extern tree get_function_version_dispatcher (tree);
diff --git a/gcc/cp/decl2.c b/gcc/cp/decl2.c
index 74ba380..8ee1908 100644
--- a/gcc/cp/decl2.c
+++ b/gcc/cp/decl2.c
@@ -4875,9 +4875,8 @@ cxx_post_compilation_parsing_cleanups (void)
input_location = locus_at_end_of_parsing;
-#ifdef ENABLE_CHECKING
- validate_conversion_obstack ();
-#endif /* ENABLE_CHECKING */
+ if (CHECKING_P)
+ validate_conversion_obstack ();
timevar_stop (TV_PHASE_LATE_PARSING_CLEANUPS);
}
diff --git a/gcc/cp/mangle.c b/gcc/cp/mangle.c
index 342cb93..637295c 100644
--- a/gcc/cp/mangle.c
+++ b/gcc/cp/mangle.c
@@ -395,20 +395,19 @@ add_substitution (tree node)
get_tree_code_name (TREE_CODE (node)), (void *) node);
node = c;
-#if ENABLE_CHECKING
/* Make sure NODE isn't already a candidate. */
- {
- int i;
- tree candidate;
+ if (CHECKING_P)
+ {
+ int i;
+ tree candidate;
- FOR_EACH_VEC_SAFE_ELT (G.substitutions, i, candidate)
- {
- gcc_assert (!(DECL_P (node) && node == candidate));
- gcc_assert (!(TYPE_P (node) && TYPE_P (candidate)
+ FOR_EACH_VEC_SAFE_ELT (G.substitutions, i, candidate)
+ {
+ gcc_assert (!(DECL_P (node) && node == candidate));
+ gcc_assert (!(TYPE_P (node) && TYPE_P (candidate)
&& same_type_p (node, candidate)));
- }
- }
-#endif /* ENABLE_CHECKING */
+ }
+ }
/* Put the decl onto the varray of substitution candidates. */
vec_safe_push (G.substitutions, node);
diff --git a/gcc/cp/method.c b/gcc/cp/method.c
index b3e247c..78565da 100644
--- a/gcc/cp/method.c
+++ b/gcc/cp/method.c
@@ -1649,10 +1649,8 @@ maybe_explain_implicit_delete (tree decl)
"deleted because its exception-specification does not "
"match the implicit exception-specification %qX",
decl, raises);
-#ifdef ENABLE_CHECKING
- else
+ else if (CHECKING_P)
gcc_unreachable ();
-#endif
pop_scope (scope);
}
diff --git a/gcc/cp/parser.c b/gcc/cp/parser.c
index 67fbcda..036baca 100644
--- a/gcc/cp/parser.c
+++ b/gcc/cp/parser.c
@@ -14531,9 +14531,8 @@ cp_parser_template_argument_list (cp_parser* parser)
parser->non_integral_constant_expression_p = saved_non_ice_p;
parser->integral_constant_expression_p = saved_ice_p;
parser->in_template_argument_list_p = saved_in_template_argument_list_p;
-#ifdef ENABLE_CHECKING
- SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (vec, TREE_VEC_LENGTH (vec));
-#endif
+ if (CHECKING_P)
+ SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (vec, TREE_VEC_LENGTH (vec));
return vec;
}
diff --git a/gcc/cp/pt.c b/gcc/cp/pt.c
index eaafaef..ec9f758 100644
--- a/gcc/cp/pt.c
+++ b/gcc/cp/pt.c
@@ -1137,7 +1137,7 @@ optimize_specialization_lookup_p (tree tmpl)
static void
check_unstripped_args (tree args ATTRIBUTE_UNUSED)
{
-#ifdef ENABLE_CHECKING
+#if CHECKING_P
++processing_template_decl;
if (!any_dependent_template_arguments_p (args))
{
@@ -4202,10 +4202,9 @@ template_parm_to_arg (tree t)
/* Turn this argument into a TYPE_ARGUMENT_PACK
with a single element, which expands T. */
tree vec = make_tree_vec (1);
-#ifdef ENABLE_CHECKING
- SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT
- (vec, TREE_VEC_LENGTH (vec));
-#endif
+ if (CHECKING_P)
+ SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (vec, TREE_VEC_LENGTH (vec));
+
TREE_VEC_ELT (vec, 0) = make_pack_expansion (t);
t = cxx_make_type (TYPE_ARGUMENT_PACK);
@@ -4222,10 +4221,9 @@ template_parm_to_arg (tree t)
with a single element, which expands T. */
tree vec = make_tree_vec (1);
tree type = TREE_TYPE (TEMPLATE_PARM_DECL (t));
-#ifdef ENABLE_CHECKING
- SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT
- (vec, TREE_VEC_LENGTH (vec));
-#endif
+ if (CHECKING_P)
+ SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (vec, TREE_VEC_LENGTH (vec));
+
t = convert_from_reference (t);
TREE_VEC_ELT (vec, 0) = make_pack_expansion (t);
@@ -4266,9 +4264,8 @@ template_parms_to_args (tree parms)
for (i = TREE_VEC_LENGTH (a) - 1; i >= 0; --i)
TREE_VEC_ELT (a, i) = template_parm_to_arg (TREE_VEC_ELT (a, i));
-#ifdef ENABLE_CHECKING
- SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (a, TREE_VEC_LENGTH (a));
-#endif
+ if (CHECKING_P)
+ SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (a, TREE_VEC_LENGTH (a));
if (length > 1)
TREE_VEC_ELT (args, --l) = a;
@@ -7350,10 +7347,9 @@ coerce_template_parameter_pack (tree parms,
}
SET_ARGUMENT_PACK_ARGS (argument_pack, packed_args);
-#ifdef ENABLE_CHECKING
- SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (packed_args,
- TREE_VEC_LENGTH (packed_args));
-#endif
+ if (CHECKING_P)
+ SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (packed_args,
+ TREE_VEC_LENGTH (packed_args));
return argument_pack;
}
@@ -7660,11 +7656,9 @@ coerce_template_parms (tree parms,
if (lost)
return error_mark_node;
-#ifdef ENABLE_CHECKING
- if (!NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_inner_args))
+ if (CHECKING_P && !NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_inner_args))
SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (new_inner_args,
TREE_VEC_LENGTH (new_inner_args));
-#endif
return new_inner_args;
}
@@ -14038,7 +14032,7 @@ tsubst_copy (tree t, tree args, tsubst_flags_t complain, tree in_decl)
return t;
default:
- /* We shouldn't get here, but keep going if !ENABLE_CHECKING. */
+ /* We shouldn't get here, but keep going if !CHECKING_P. */
gcc_checking_assert (false);
return t;
}
@@ -17726,10 +17720,9 @@ type_unification_real (tree tparms,
if (saw_undeduced++ == 1)
goto again;
}
-#ifdef ENABLE_CHECKING
- if (!NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs))
+
+ if (CHECKING_P && !NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs))
SET_NON_DEFAULT_TEMPLATE_ARGS_COUNT (targs, TREE_VEC_LENGTH (targs));
-#endif
return unify_success (explain_p);
}
@@ -22753,12 +22746,10 @@ build_non_dependent_expr (tree expr)
{
tree inner_expr;
-#ifdef ENABLE_CHECKING
/* Try to get a constant value for all non-dependent expressions in
order to expose bugs in *_dependent_expression_p and constexpr. */
- if (cxx_dialect >= cxx11)
+ if (CHECKING_P && cxx_dialect >= cxx11)
fold_non_dependent_expr (expr);
-#endif
/* Preserve OVERLOADs; the functions must be available to resolve
types. */
diff --git a/gcc/cp/tree.c b/gcc/cp/tree.c
index 987ebe8..c41f8c8 100644
--- a/gcc/cp/tree.c
+++ b/gcc/cp/tree.c
@@ -324,15 +324,13 @@ build_target_expr (tree decl, tree value, tsubst_flags_t complain)
tree t;
tree type = TREE_TYPE (decl);
-#ifdef ENABLE_CHECKING
- gcc_assert (VOID_TYPE_P (TREE_TYPE (value))
- || TREE_TYPE (decl) == TREE_TYPE (value)
- /* On ARM ctors return 'this'. */
- || (TYPE_PTR_P (TREE_TYPE (value))
- && TREE_CODE (value) == CALL_EXPR)
- || useless_type_conversion_p (TREE_TYPE (decl),
- TREE_TYPE (value)));
-#endif
+ gcc_checking_assert (VOID_TYPE_P (TREE_TYPE (value))
+ || TREE_TYPE (decl) == TREE_TYPE (value)
+ /* On ARM ctors return 'this'. */
+ || (TYPE_PTR_P (TREE_TYPE (value))
+ && TREE_CODE (value) == CALL_EXPR)
+ || useless_type_conversion_p (TREE_TYPE (decl),
+ TREE_TYPE (value)));
t = cxx_maybe_build_cleanup (decl, complain);
if (t == error_mark_node)
diff --git a/gcc/cp/typeck.c b/gcc/cp/typeck.c
index 83fd34c..b6f3e34 100644
--- a/gcc/cp/typeck.c
+++ b/gcc/cp/typeck.c
@@ -1402,8 +1402,7 @@ comptypes (tree t1, tree t2, int strict)
perform a deep check. */
return structural_comptypes (t1, t2, strict);
-#ifdef ENABLE_CHECKING
- if (USE_CANONICAL_TYPES)
+ if (CHECKING_P && USE_CANONICAL_TYPES)
{
bool result = structural_comptypes (t1, t2, strict);
@@ -1424,10 +1423,8 @@ comptypes (tree t1, tree t2, int strict)
return result;
}
-#else
- if (USE_CANONICAL_TYPES)
+ if (!CHECKING_P && USE_CANONICAL_TYPES)
return TYPE_CANONICAL (t1) == TYPE_CANONICAL (t2);
-#endif
else
return structural_comptypes (t1, t2, strict);
}
diff --git a/gcc/cp/typeck2.c b/gcc/cp/typeck2.c
index 1d106c7..b437044 100644
--- a/gcc/cp/typeck2.c
+++ b/gcc/cp/typeck2.c
@@ -1087,11 +1087,11 @@ digest_init_r (tree type, tree init, bool nested, int flags,
|| TREE_CODE (type) == UNION_TYPE
|| TREE_CODE (type) == COMPLEX_TYPE);
-#ifdef ENABLE_CHECKING
/* "If T is a class type and the initializer list has a single
element of type cv U, where U is T or a class derived from T,
the object is initialized from that element." */
- if (cxx_dialect >= cxx11
+ if (CHECKING_P
+ && cxx_dialect >= cxx11
&& BRACE_ENCLOSED_INITIALIZER_P (init)
&& CONSTRUCTOR_NELTS (init) == 1
&& ((CLASS_TYPE_P (type) && !CLASSTYPE_NON_AGGREGATE (type))
@@ -1102,7 +1102,6 @@ digest_init_r (tree type, tree init, bool nested, int flags,
/* We should have fixed this in reshape_init. */
gcc_unreachable ();
}
-#endif
if (BRACE_ENCLOSED_INITIALIZER_P (init)
&& !TYPE_NON_AGGREGATE_CLASS (type))
diff --git a/gcc/ddg.c b/gcc/ddg.c
index ada4657..93a4918 100644
--- a/gcc/ddg.c
+++ b/gcc/ddg.c
@@ -300,7 +300,7 @@ add_cross_iteration_register_deps (ddg_ptr g, df_ref last_def)
rtx_insn *def_insn = DF_REF_INSN (last_def);
ddg_node_ptr last_def_node = get_node_of_insn (g, def_insn);
ddg_node_ptr use_node;
-#ifdef ENABLE_CHECKING
+#if CHECKING_P
struct df_rd_bb_info *bb_info = DF_RD_BB_INFO (g->bb);
#endif
df_ref first_def = df_bb_regno_first_def_find (g->bb, regno);
@@ -308,7 +308,7 @@ add_cross_iteration_register_deps (ddg_ptr g, df_ref last_def)
gcc_assert (last_def_node);
gcc_assert (first_def);
-#ifdef ENABLE_CHECKING
+#if CHECKING_P
if (DF_REF_ID (last_def) != DF_REF_ID (first_def))
gcc_assert (!bitmap_bit_p (&bb_info->gen,
DF_REF_ID (first_def)));
@@ -1013,7 +1013,7 @@ order_sccs (ddg_all_sccs_ptr g)
(int (*) (const void *, const void *)) compare_sccs);
}
-#ifdef ENABLE_CHECKING
+#if CHECKING_P
/* Check that every node in SCCS belongs to exactly one strongly connected
component and that no element of SCCS is empty. */
static void
@@ -1079,7 +1079,7 @@ create_ddg_all_sccs (ddg_ptr g)
sbitmap_free (from);
sbitmap_free (to);
sbitmap_free (scc_nodes);
-#ifdef ENABLE_CHECKING
+#if CHECKING_P
check_sccs (sccs, num_nodes);
#endif
return sccs;
diff --git a/gcc/df-core.c b/gcc/df-core.c
index 8d2d7a1..7930175 100644
--- a/gcc/df-core.c
+++ b/gcc/df-core.c
@@ -682,10 +682,8 @@ df_finish_pass (bool verify ATTRIBUTE_UNUSED)
#endif
#endif
-#ifdef ENABLE_CHECKING
- if (verify)
+ if (CHECKING_P && verify)
df->changeable_flags |= DF_VERIFY_SCHEDULED;
-#endif
}
@@ -1273,12 +1271,14 @@ df_analyze (void)
for (i = 0; i < df->n_blocks; i++)
bitmap_set_bit (current_all_blocks, df->postorder[i]);
-#ifdef ENABLE_CHECKING
- /* Verify that POSTORDER_INVERTED only contains blocks reachable from
- the ENTRY block. */
- for (i = 0; i < df->n_blocks_inverted; i++)
- gcc_assert (bitmap_bit_p (current_all_blocks, df->postorder_inverted[i]));
-#endif
+ if (CHECKING_P)
+ {
+ /* Verify that POSTORDER_INVERTED only contains blocks reachable from
+ the ENTRY block. */
+ for (i = 0; i < df->n_blocks_inverted; i++)
+ gcc_assert (bitmap_bit_p (current_all_blocks,
+ df->postorder_inverted[i]));
+ }
/* Make sure that we have pruned any unreachable blocks from these
sets. */
diff --git a/gcc/diagnostic-core.h b/gcc/diagnostic-core.h
index 66d2e42..6cc1e6b 100644
--- a/gcc/diagnostic-core.h
+++ b/gcc/diagnostic-core.h
@@ -48,7 +48,7 @@ extern const char *trim_filename (const char *);
/* None of these functions are suitable for ATTRIBUTE_PRINTF, because
each language front end can extend them with its own set of format
specifiers. We must use custom format checks. */
-#if (ENABLE_CHECKING && GCC_VERSION >= 4001) || GCC_VERSION == BUILDING_GCC_VERSION
+#if (CHECKING_P && GCC_VERSION >= 4001) || GCC_VERSION == BUILDING_GCC_VERSION
#define ATTRIBUTE_GCC_DIAG(m, n) __attribute__ ((__format__ (GCC_DIAG_STYLE, m, n))) ATTRIBUTE_NONNULL(m)
#else
#define ATTRIBUTE_GCC_DIAG(m, n) ATTRIBUTE_NONNULL(m)
diff --git a/gcc/diagnostic.c b/gcc/diagnostic.c
index 01a8e35..9f6a5b1 100644
--- a/gcc/diagnostic.c
+++ b/gcc/diagnostic.c
@@ -868,12 +868,12 @@ diagnostic_report_diagnostic (diagnostic_context *context,
if (diagnostic->kind == DK_ICE || diagnostic->kind == DK_ICE_NOBT)
{
-#ifndef ENABLE_CHECKING
/* When not checking, ICEs are converted to fatal errors when an
error has already occurred. This is counteracted by
abort_on_error. */
- if ((diagnostic_kind_count (context, DK_ERROR) > 0
- || diagnostic_kind_count (context, DK_SORRY) > 0)
+ if (!CHECKING_P
+ && (diagnostic_kind_count (context, DK_ERROR) > 0
+ || diagnostic_kind_count (context, DK_SORRY) > 0)
&& !context->abort_on_error)
{
expanded_location s
@@ -882,7 +882,6 @@ diagnostic_report_diagnostic (diagnostic_context *context,
s.file, s.line);
exit (ICE_EXIT_CODE);
}
-#endif
if (context->internal_error)
(*context->internal_error) (context,
diagnostic->message.format_spec,
diff --git a/gcc/dominance.c b/gcc/dominance.c
index d8d87ca..b6e2940 100644
--- a/gcc/dominance.c
+++ b/gcc/dominance.c
@@ -639,9 +639,8 @@ calculate_dominance_info (enum cdi_direction dir)
if (dom_computed[dir_index] == DOM_OK)
{
-#if ENABLE_CHECKING
- verify_dominators (dir);
-#endif
+ if (CHECKING_P)
+ verify_dominators (dir);
return;
}
@@ -673,9 +672,8 @@ calculate_dominance_info (enum cdi_direction dir)
}
else
{
-#if ENABLE_CHECKING
- verify_dominators (dir);
-#endif
+ if (CHECKING_P)
+ verify_dominators (dir);
}
compute_dom_fast_query (dir);
diff --git a/gcc/dwarf2out.c b/gcc/dwarf2out.c
index d9d3063..70008ca 100644
--- a/gcc/dwarf2out.c
+++ b/gcc/dwarf2out.c
@@ -4146,15 +4146,12 @@ static inline void
add_AT_die_ref (dw_die_ref die, enum dwarf_attribute attr_kind, dw_die_ref targ_die)
{
dw_attr_node attr;
+ gcc_checking_assert (targ_die != NULL);
-#ifdef ENABLE_CHECKING
- gcc_assert (targ_die != NULL);
-#else
/* With LTO we can end up trying to reference something we didn't create
a DIE for. Avoid crashing later on a NULL referenced DIE. */
if (targ_die == NULL)
return;
-#endif
attr.dw_attr = attr_kind;
attr.dw_attr_val.val_class = dw_val_class_die_ref;
@@ -5717,10 +5714,9 @@ debug_dwarf (void)
print_die (comp_unit_die (), stderr);
}
-#ifdef ENABLE_CHECKING
/* Sanity checks on DIEs. */
-static void
+DEBUG_FUNCTION static void
check_die (dw_die_ref die)
{
unsigned ix;
@@ -5780,7 +5776,7 @@ check_die (dw_die_ref die)
&& a->dw_attr != DW_AT_GNU_all_call_sites);
}
}
-#endif
+
/* Start a new compilation unit DIE for an include file. OLD_UNIT is the CU
for the enclosing include file, if any. BINCL_DIE is the DW_TAG_GNU_BINCL
@@ -11742,14 +11738,14 @@ const_ok_for_output_1 (rtx rtl)
{
/* If delegitimize_address couldn't do anything with the UNSPEC, assume
we can't express it in the debug info. */
-#ifdef ENABLE_CHECKING
/* Don't complain about TLS UNSPECs, those are just too hard to
delegitimize. Note this could be a non-decl SYMBOL_REF such as
one in a constant pool entry, so testing SYMBOL_REF_TLS_MODEL
rather than DECL_THREAD_LOCAL_P is not just an optimization. */
- if (XVECLEN (rtl, 0) == 0
- || GET_CODE (XVECEXP (rtl, 0, 0)) != SYMBOL_REF
- || SYMBOL_REF_TLS_MODEL (XVECEXP (rtl, 0, 0)) == TLS_MODEL_NONE)
+ if (CHECKING_P
+ && (XVECLEN (rtl, 0) == 0
+ || GET_CODE (XVECEXP (rtl, 0, 0)) != SYMBOL_REF
+ || SYMBOL_REF_TLS_MODEL (XVECEXP (rtl, 0, 0)) == TLS_MODEL_NONE))
inform (current_function_decl
? DECL_SOURCE_LOCATION (current_function_decl)
: UNKNOWN_LOCATION,
@@ -11762,7 +11758,6 @@ const_ok_for_output_1 (rtx rtl)
"non-delegitimized UNSPEC %d found in variable location",
XINT (rtl, 1));
#endif
-#endif
expansion_failed (NULL_TREE, rtl,
"UNSPEC hasn't been delegitimized.\n");
return false;
@@ -13549,12 +13544,12 @@ mem_loc_descriptor (rtx rtl, machine_mode mode,
goto symref;
default:
-#ifdef ENABLE_CHECKING
- print_rtl (stderr, rtl);
- gcc_unreachable ();
-#else
+ if (CHECKING_P)
+ {
+ print_rtl (stderr, rtl);
+ gcc_unreachable ();
+ }
break;
-#endif
}
if (mem_loc_result && initialized == VAR_INIT_STATUS_UNINITIALIZED)
@@ -15077,15 +15072,14 @@ loc_list_from_tree (tree loc, int want_address,
return 0;
}
-#ifdef ENABLE_CHECKING
/* Otherwise this is a generic code; we should just lists all of
these explicitly. We forgot one. */
- gcc_unreachable ();
-#else
+ if (CHECKING_P)
+ gcc_unreachable ();
+
/* In a release build, we want to degrade gracefully: better to
generate incomplete debugging information than to crash. */
return NULL;
-#endif
}
if (!ret && !list_ret)
@@ -19886,18 +19880,17 @@ gen_lexical_block_die (tree stmt, dw_die_ref context_die)
{
if (old_die)
{
-#ifdef ENABLE_CHECKING
- /* This must have been generated early and it won't even
- need location information since it's a DW_AT_inline
- function. */
- for (dw_die_ref c = context_die; c; c = c->die_parent)
- if (c->die_tag == DW_TAG_inlined_subroutine
- || c->die_tag == DW_TAG_subprogram)
- {
- gcc_assert (get_AT (c, DW_AT_inline));
- break;
- }
-#endif
+ if (CHECKING_P)
+ /* This must have been generated early and it won't even
+ need location information since it's a DW_AT_inline
+ function. */
+ for (dw_die_ref c = context_die; c; c = c->die_parent)
+ if (c->die_tag == DW_TAG_inlined_subroutine
+ || c->die_tag == DW_TAG_subprogram)
+ {
+ gcc_assert (get_AT (c, DW_AT_inline));
+ break;
+ }
return;
}
}
@@ -20716,10 +20709,8 @@ gen_type_die_with_usage (tree type, dw_die_ref context_die,
if (type == NULL_TREE || type == error_mark_node)
return;
-#ifdef ENABLE_CHECKING
- if (type)
+ if (CHECKING_P && type)
verify_type (type);
-#endif
if (TYPE_NAME (type) != NULL_TREE
&& TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
@@ -20913,11 +20904,12 @@ gen_type_die (tree type, dw_die_ref context_die)
if (type != error_mark_node)
{
gen_type_die_with_usage (type, context_die, DINFO_USAGE_DIR_USE);
-#ifdef ENABLE_CHECKING
- dw_die_ref die = lookup_type_die (type);
- if (die)
- check_die (die);
-#endif
+ if (CHECKING_P)
+ {
+ dw_die_ref die = lookup_type_die (type);
+ if (die)
+ check_die (die);
+ }
}
}
@@ -21950,11 +21942,12 @@ dwarf2out_decl (tree decl)
gen_decl_die (decl, NULL, context_die);
-#ifdef ENABLE_CHECKING
- dw_die_ref die = lookup_decl_die (decl);
- if (die)
- check_die (die);
-#endif
+ if (CHECKING_P)
+ {
+ dw_die_ref die = lookup_decl_die (decl);
+ if (die)
+ check_die (die);
+ }
}
/* Write the debugging output for DECL. */
diff --git a/gcc/emit-rtl.c b/gcc/emit-rtl.c
index a6ef154..c862762 100644
--- a/gcc/emit-rtl.c
+++ b/gcc/emit-rtl.c
@@ -2733,8 +2733,7 @@ verify_rtx_sharing (rtx orig, rtx insn)
/* This rtx may not be shared. If it has already been seen,
replace it with a copy of itself. */
-#ifdef ENABLE_CHECKING
- if (RTX_FLAG (x, used))
+ if (CHECKING_P && RTX_FLAG (x, used))
{
error ("invalid rtl sharing found in the insn");
debug_rtx (insn);
@@ -2742,7 +2741,6 @@ verify_rtx_sharing (rtx orig, rtx insn)
debug_rtx (x);
internal_error ("internal consistency failure");
}
-#endif
gcc_assert (!RTX_FLAG (x, used));
RTX_FLAG (x, used) = 1;
@@ -4259,12 +4257,12 @@ delete_insns_since (rtx_insn *from)
void
reorder_insns_nobb (rtx_insn *from, rtx_insn *to, rtx_insn *after)
{
-#ifdef ENABLE_CHECKING
- rtx_insn *x;
- for (x = from; x != to; x = NEXT_INSN (x))
- gcc_assert (after != x);
- gcc_assert (after != to);
-#endif
+ if (CHECKING_P)
+ {
+ for (rtx_insn *x = from; x != to; x = NEXT_INSN (x))
+ gcc_assert (after != x);
+ gcc_assert (after != to);
+ }
/* Splice this bunch out of where it is now. */
if (PREV_INSN (from))
diff --git a/gcc/et-forest.c b/gcc/et-forest.c
index 1931285..92e3dac 100644
--- a/gcc/et-forest.c
+++ b/gcc/et-forest.c
@@ -28,7 +28,7 @@ License along with libiberty; see the file COPYING3. If not see
#include "alloc-pool.h"
#include "et-forest.h"
-/* We do not enable this with ENABLE_CHECKING, since it is awfully slow. */
+/* We do not enable this with CHECKING_P, since it is awfully slow. */
#undef DEBUG_ET
#ifdef DEBUG_ET
diff --git a/gcc/except.c b/gcc/except.c
index d59c539..323102e 100644
--- a/gcc/except.c
+++ b/gcc/except.c
@@ -612,9 +612,8 @@ duplicate_eh_regions (struct function *ifun,
struct duplicate_eh_regions_data data;
eh_region outer_region;
-#ifdef ENABLE_CHECKING
- verify_eh_tree (ifun);
-#endif
+ if (CHECKING_P)
+ verify_eh_tree (ifun);
data.label_map = map;
data.label_map_data = map_data;
@@ -632,9 +631,8 @@ duplicate_eh_regions (struct function *ifun,
duplicate_eh_regions_1 (&data, r, outer_region);
}
-#ifdef ENABLE_CHECKING
- verify_eh_tree (cfun);
-#endif
+ if (CHECKING_P)
+ verify_eh_tree (cfun);
return data.eh_map;
}
diff --git a/gcc/fortran/trans-common.c b/gcc/fortran/trans-common.c
index 7f4bfe5..98c50ac 100644
--- a/gcc/fortran/trans-common.c
+++ b/gcc/fortran/trans-common.c
@@ -686,14 +686,13 @@ create_common (gfc_common_head *com, segment_info *head, bool saw_equiv)
TREE_STATIC (ctor) = 1;
DECL_INITIAL (decl) = ctor;
-#ifdef ENABLE_CHECKING
- {
- tree field, value;
- unsigned HOST_WIDE_INT idx;
- FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (ctor), idx, field, value)
- gcc_assert (TREE_CODE (field) == FIELD_DECL);
- }
-#endif
+ if (CHECKING_P)
+ {
+ tree field, value;
+ unsigned HOST_WIDE_INT idx;
+ FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (ctor), idx, field, value)
+ gcc_assert (TREE_CODE (field) == FIELD_DECL);
+ }
}
/* Build component reference for each variable. */
diff --git a/gcc/fortran/trans.c b/gcc/fortran/trans.c
index aece77a..701b119 100644
--- a/gcc/fortran/trans.c
+++ b/gcc/fortran/trans.c
@@ -151,7 +151,6 @@ gfc_add_modify_loc (location_t loc, stmtblock_t * pblock, tree lhs, tree rhs)
{
tree tmp;
-#ifdef ENABLE_CHECKING
tree t1, t2;
t1 = TREE_TYPE (rhs);
t2 = TREE_TYPE (lhs);
@@ -159,9 +158,8 @@ gfc_add_modify_loc (location_t loc, stmtblock_t * pblock, tree lhs, tree rhs)
for scalar assignments. We should probably have something
similar for aggregates, but right now removing that check just
breaks everything. */
- gcc_assert (t1 == t2
- || AGGREGATE_TYPE_P (TREE_TYPE (lhs)));
-#endif
+ gcc_checking_assert (t1 == t2
+ || AGGREGATE_TYPE_P (TREE_TYPE (lhs)));
tmp = fold_build2_loc (loc, MODIFY_EXPR, void_type_node, lhs,
rhs);
diff --git a/gcc/fwprop.c b/gcc/fwprop.c
index 16c7981..67808bc 100644
--- a/gcc/fwprop.c
+++ b/gcc/fwprop.c
@@ -843,9 +843,7 @@ all_uses_available_at (rtx_insn *def_insn, rtx_insn *target_insn)
static df_ref *active_defs;
-#ifdef ENABLE_CHECKING
static sparseset active_defs_check;
-#endif
/* Fill the ACTIVE_DEFS array with the use->def link for the registers
mentioned in USE_REC. Register the valid entries in ACTIVE_DEFS_CHECK
@@ -859,9 +857,8 @@ register_active_defs (df_ref use)
df_ref def = get_def_for_use (use);
int regno = DF_REF_REGNO (use);
-#ifdef ENABLE_CHECKING
- sparseset_set_bit (active_defs_check, regno);
-#endif
+ if (CHECKING_P)
+ sparseset_set_bit (active_defs_check, regno);
active_defs[regno] = def;
}
}
@@ -876,9 +873,8 @@ register_active_defs (df_ref use)
static void
update_df_init (rtx_insn *def_insn, rtx_insn *insn)
{
-#ifdef ENABLE_CHECKING
- sparseset_clear (active_defs_check);
-#endif
+ if (CHECKING_P)
+ sparseset_clear (active_defs_check);
register_active_defs (DF_INSN_USES (def_insn));
register_active_defs (DF_INSN_USES (insn));
register_active_defs (DF_INSN_EQ_USES (insn));
@@ -899,9 +895,7 @@ update_uses (df_ref use)
if (DF_REF_ID (use) >= (int) use_def_ref.length ())
use_def_ref.safe_grow_cleared (DF_REF_ID (use) + 1);
-#ifdef ENABLE_CHECKING
- gcc_assert (sparseset_bit_p (active_defs_check, regno));
-#endif
+ gcc_checking_assert (sparseset_bit_p (active_defs_check, regno));
use_def_ref[DF_REF_ID (use)] = active_defs[regno];
}
}
@@ -1407,9 +1401,8 @@ fwprop_init (void)
df_set_flags (DF_DEFER_INSN_RESCAN);
active_defs = XNEWVEC (df_ref, max_reg_num ());
-#ifdef ENABLE_CHECKING
- active_defs_check = sparseset_alloc (max_reg_num ());
-#endif
+ if (CHECKING_P)
+ active_defs_check = sparseset_alloc (max_reg_num ());
}
static void
@@ -1419,9 +1412,8 @@ fwprop_done (void)
use_def_ref.release ();
free (active_defs);
-#ifdef ENABLE_CHECKING
- sparseset_free (active_defs_check);
-#endif
+ if (CHECKING_P)
+ sparseset_free (active_defs_check);
free_dominance_info (CDI_DOMINATORS);
cleanup_cfg (0);
diff --git a/gcc/genautomata.c b/gcc/genautomata.c
index 5196d68..beae5ef 100644
--- a/gcc/genautomata.c
+++ b/gcc/genautomata.c
@@ -879,7 +879,7 @@ struct state_ainsn_table
/* Macros to access members of unions. Use only them for access to
union members of declarations and regexps. */
-#if defined ENABLE_CHECKING && (GCC_VERSION >= 2007)
+#if CHECKING_P && (GCC_VERSION >= 2007)
#define DECL_UNIT(d) __extension__ \
(({ __typeof (d) const _decl = (d); \
diff --git a/gcc/genconditions.c b/gcc/genconditions.c
index 001e58e..7481ab4 100644
--- a/gcc/genconditions.c
+++ b/gcc/genconditions.c
@@ -60,6 +60,8 @@ write_header (void)
\n\
/* Do not allow checking to confuse the issue. */\n\
#undef ENABLE_CHECKING\n\
+#undef CHECKING_P\n\
+#define CHECKING_P 0\n\
#undef ENABLE_TREE_CHECKING\n\
#undef ENABLE_RTL_CHECKING\n\
#undef ENABLE_RTL_FLAG_CHECKING\n\
diff --git a/gcc/genextract.c b/gcc/genextract.c
index fe97701..7f1879f 100644
--- a/gcc/genextract.c
+++ b/gcc/genextract.c
@@ -373,7 +373,7 @@ insn_extract (rtx_insn *insn)\n{\n\
rtx pat = PATTERN (insn);\n\
int i ATTRIBUTE_UNUSED; /* only for peepholes */\n\
\n\
-#ifdef ENABLE_CHECKING\n\
+#if CHECKING_P\n\
memset (ro, 0xab, sizeof (*ro) * MAX_RECOG_OPERANDS);\n\
memset (ro_loc, 0xab, sizeof (*ro_loc) * MAX_RECOG_OPERANDS);\n\
#endif\n");
diff --git a/gcc/gengtype.c b/gcc/gengtype.c
index 866d809..777b52f 100644
--- a/gcc/gengtype.c
+++ b/gcc/gengtype.c
@@ -160,7 +160,7 @@ static outf_p *base_files;
-#if ENABLE_CHECKING
+#if CHECKING_P
/* Utility debugging function, printing the various type counts within
a list of types. Called through the DBGPRINT_COUNT_TYPE macro. */
void
@@ -222,7 +222,7 @@ dbgprint_count_type_at (const char *fil, int lin, const char *msg, type_p t)
fprintf (stderr, "@@%%@@ %d undefined types\n", nb_undefined);
fprintf (stderr, "\n");
}
-#endif /* ENABLE_CHECKING */
+#endif /* CHECKING_P */
/* Scan the input file, LIST, and determine how much space we need to
store strings in. Also, count the number of language directories
@@ -5181,15 +5181,13 @@ main (int argc, char **argv)
parse_program_options (argc, argv);
-#if ENABLE_CHECKING
- if (do_debug)
+ if (CHECKING_P && do_debug)
{
time_t now = (time_t) 0;
time (&now);
DBGPRINTF ("gengtype started pid %d at %s",
(int) getpid (), ctime (&now));
}
-#endif /* ENABLE_CHECKING */
/* Parse the input list and the input files. */
DBGPRINTF ("inputlist %s", inputlist);
diff --git a/gcc/gengtype.h b/gcc/gengtype.h
index 83f3632..9c4eac3 100644
--- a/gcc/gengtype.h
+++ b/gcc/gengtype.h
@@ -492,7 +492,7 @@ extern int do_dump; /* (-d) program argument. */
gengtype source code). Only useful to debug gengtype itself. */
extern int do_debug; /* (-D) program argument. */
-#if ENABLE_CHECKING
+#if CHECKING_P
#define DBGPRINTF(Fmt,...) do {if (do_debug) \
fprintf (stderr, "%s:%d: " Fmt "\n", \
lbasename (__FILE__),__LINE__, ##__VA_ARGS__);} while (0)
@@ -502,7 +502,7 @@ void dbgprint_count_type_at (const char *, int, const char *, type_p);
#else
#define DBGPRINTF(Fmt,...) do {/*nodbgrintf*/} while (0)
#define DBGPRINT_COUNT_TYPE(Msg,Ty) do{/*nodbgprint_count_type*/}while (0)
-#endif /*ENABLE_CHECKING */
+#endif /* CHECKING_P */
#define FOR_ALL_INHERITED_FIELDS(TYPE, FIELD_VAR) \
for (type_p sub = (TYPE); sub; sub = sub->u.s.base_class) \
diff --git a/gcc/ggc-page.c b/gcc/ggc-page.c
index 58f19c0..6b51b17 100644
--- a/gcc/ggc-page.c
+++ b/gcc/ggc-page.c
@@ -2205,12 +2205,11 @@ ggc_collect (void)
void
ggc_grow (void)
{
-#ifndef ENABLE_CHECKING
- G.allocated_last_gc = MAX (G.allocated_last_gc,
- G.allocated);
-#else
- ggc_collect ();
-#endif
+ if (! CHECKING_P)
+ G.allocated_last_gc = MAX (G.allocated_last_gc,
+ G.allocated);
+ else
+ ggc_collect ();
if (!quiet_flag)
fprintf (stderr, " {GC start %luk} ", (unsigned long) G.allocated / 1024);
}
diff --git a/gcc/gimplify.c b/gcc/gimplify.c
index c8f2718..37cdebf 100644
--- a/gcc/gimplify.c
+++ b/gcc/gimplify.c
@@ -9267,10 +9267,8 @@ gimplify_body (tree fndecl, bool do_parms)
pop_gimplify_context (outer_bind);
gcc_assert (gimplify_ctxp == NULL);
-#ifdef ENABLE_CHECKING
- if (!seen_error ())
+ if (CHECKING_P && !seen_error ())
verify_gimple_in_seq (gimple_bind_body (outer_bind));
-#endif
timevar_pop (TV_TREE_GIMPLIFY);
input_location = saved_location;
@@ -9562,11 +9560,9 @@ gimplify_hasher::equal (const elt_t *p1, const elt_t *p2)
if (!operand_equal_p (t1, t2, 0))
return false;
-#ifdef ENABLE_CHECKING
/* Only allow them to compare equal if they also hash equal; otherwise
results are nondeterminate, and we fail bootstrap comparison. */
- gcc_assert (hash (p1) == hash (p2));
-#endif
+ gcc_checking_assert (hash (p1) == hash (p2));
return true;
}
diff --git a/gcc/graphite-isl-ast-to-gimple.c b/gcc/graphite-isl-ast-to-gimple.c
index dfb012f..6226425 100644
--- a/gcc/graphite-isl-ast-to-gimple.c
+++ b/gcc/graphite-isl-ast-to-gimple.c
@@ -104,10 +104,11 @@ gmp_cst_to_tree (tree type, mpz_t val)
static inline void
graphite_verify (void)
{
-#ifdef ENABLE_CHECKING
- verify_loop_structure ();
- verify_loop_closed_ssa (true);
-#endif
+ if (CHECKING_P)
+ {
+ verify_loop_structure ();
+ verify_loop_closed_ssa (true);
+ }
}
/* IVS_PARAMS maps ISL's scattering and parameter identifiers
diff --git a/gcc/graphite-scop-detection.c b/gcc/graphite-scop-detection.c
index b2a4aaf..5fbf4d0 100644
--- a/gcc/graphite-scop-detection.c
+++ b/gcc/graphite-scop-detection.c
@@ -1131,10 +1131,11 @@ create_sese_edges (vec<sd_region> regions)
calculate_dominance_info (CDI_DOMINATORS);
fix_loop_structure (NULL);
-#ifdef ENABLE_CHECKING
- verify_loop_structure ();
- verify_ssa (false, true);
-#endif
+ if (CHECKING_P)
+ {
+ verify_loop_structure ();
+ verify_ssa (false, true);
+ }
}
/* Create graphite SCoPs from an array of scop detection REGIONS. */
@@ -1159,7 +1160,7 @@ build_graphite_scops (vec<sd_region> regions,
scops->safe_push (scop);
/* Are there overlapping SCoPs? */
-#ifdef ENABLE_CHECKING
+ if (CHECKING_P)
{
int j;
sd_region *s2;
@@ -1168,7 +1169,6 @@ build_graphite_scops (vec<sd_region> regions,
if (s != s2)
gcc_assert (!bb_in_sd_region (s->entry, s2));
}
-#endif
}
}
@@ -1470,9 +1470,8 @@ canonicalize_loop_closed_ssa_form (void)
{
loop_p loop;
-#ifdef ENABLE_CHECKING
- verify_loop_closed_ssa (true);
-#endif
+ if (CHECKING_P)
+ verify_loop_closed_ssa (true);
FOR_EACH_LOOP (loop, 0)
canonicalize_loop_closed_ssa (loop);
@@ -1480,9 +1479,8 @@ canonicalize_loop_closed_ssa_form (void)
rewrite_into_loop_closed_ssa (NULL, TODO_update_ssa);
update_ssa (TODO_update_ssa);
-#ifdef ENABLE_CHECKING
- verify_loop_closed_ssa (true);
-#endif
+ if (CHECKING_P)
+ verify_loop_closed_ssa (true);
}
/* Find Static Control Parts (SCoP) in the current function and pushes
diff --git a/gcc/graphite-sese-to-poly.c b/gcc/graphite-sese-to-poly.c
index fdcc790..f12efb4 100644
--- a/gcc/graphite-sese-to-poly.c
+++ b/gcc/graphite-sese-to-poly.c
@@ -2317,9 +2317,8 @@ rewrite_reductions_out_of_ssa (scop_p scop)
}
update_ssa (TODO_update_ssa);
-#ifdef ENABLE_CHECKING
- verify_loop_closed_ssa (true);
-#endif
+ if (CHECKING_P)
+ verify_loop_closed_ssa (true);
}
/* Rewrite the scalar dependence of DEF used in USE_STMT with a memory
@@ -2496,9 +2495,8 @@ rewrite_cross_bb_scalar_deps_out_of_ssa (scop_p scop)
{
scev_reset_htab ();
update_ssa (TODO_update_ssa);
-#ifdef ENABLE_CHECKING
- verify_loop_closed_ssa (true);
-#endif
+ if (CHECKING_P)
+ verify_loop_closed_ssa (true);
}
}
@@ -3096,9 +3094,8 @@ rewrite_commutative_reductions_out_of_ssa (scop_p scop)
scev_reset_htab ();
gsi_commit_edge_inserts ();
update_ssa (TODO_update_ssa);
-#ifdef ENABLE_CHECKING
- verify_loop_closed_ssa (true);
-#endif
+ if (CHECKING_P)
+ verify_loop_closed_ssa (true);
}
}
diff --git a/gcc/hash-table.h b/gcc/hash-table.h
index 8e3c2ca..192be30 100644
--- a/gcc/hash-table.h
+++ b/gcc/hash-table.h
@@ -638,9 +638,7 @@ hash_table<Descriptor, Allocator>::find_empty_slot_for_expand (hashval_t hash)
if (is_empty (*slot))
return slot;
-#ifdef ENABLE_CHECKING
gcc_checking_assert (!is_deleted (*slot));
-#endif
hash2 = hash_table_mod2 (hash, m_size_prime_index);
for (;;)
@@ -652,9 +650,7 @@ hash_table<Descriptor, Allocator>::find_empty_slot_for_expand (hashval_t hash)
slot = m_entries + index;
if (is_empty (*slot))
return slot;
-#ifdef ENABLE_CHECKING
gcc_checking_assert (!is_deleted (*slot));
-#endif
}
}
diff --git a/gcc/ifcvt.c b/gcc/ifcvt.c
index a46efec..b3aea4b 100644
--- a/gcc/ifcvt.c
+++ b/gcc/ifcvt.c
@@ -4724,9 +4724,8 @@ if_convert (bool after_combine)
if (optimize == 1)
df_remove_problem (df_live);
-#ifdef ENABLE_CHECKING
- verify_flow_info ();
-#endif
+ if (CHECKING_P)
+ verify_flow_info ();
}
/* If-conversion and CFG cleanup. */
diff --git a/gcc/ipa-cp.c b/gcc/ipa-cp.c
index 8de7e56..b9a781c 100644
--- a/gcc/ipa-cp.c
+++ b/gcc/ipa-cp.c
@@ -2816,9 +2816,8 @@ ipcp_propagate_stage (struct ipa_topo_info *topo)
overall_size, max_new_size);
propagate_constants_topo (topo);
-#ifdef ENABLE_CHECKING
- ipcp_verify_propagated_values ();
-#endif
+ if (CHECKING_P)
+ ipcp_verify_propagated_values ();
topo->constants.propagate_effects ();
topo->contexts.propagate_effects ();
diff --git a/gcc/ipa-devirt.c b/gcc/ipa-devirt.c
index 3eb2456..cf531f1 100644
--- a/gcc/ipa-devirt.c
+++ b/gcc/ipa-devirt.c
@@ -272,11 +272,9 @@ type_in_anonymous_namespace_p (const_tree t)
{
/* C++ FE uses magic <anon> as assembler names of anonymous types.
verify that this match with type_in_anonymous_namespace_p. */
-#ifdef ENABLE_CHECKING
- if (in_lto_p)
+ if (CHECKING_P && in_lto_p)
gcc_assert (!strcmp ("<anon>",
IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (TYPE_NAME (t)))));
-#endif
return true;
}
return false;
@@ -300,15 +298,13 @@ odr_type_p (const_tree t)
if (TYPE_NAME (t) && TREE_CODE (TYPE_NAME (t)) == TYPE_DECL
&& (DECL_ASSEMBLER_NAME_SET_P (TYPE_NAME (t))))
{
-#ifdef ENABLE_CHECKING
/* C++ FE uses magic <anon> as assembler names of anonymous types.
verify that this match with type_in_anonymous_namespace_p. */
- gcc_assert (!type_with_linkage_p (t)
- || strcmp ("<anon>",
- IDENTIFIER_POINTER
- (DECL_ASSEMBLER_NAME (TYPE_NAME (t))))
- || type_in_anonymous_namespace_p (t));
-#endif
+ gcc_checking_assert (!type_with_linkage_p (t)
+ || strcmp ("<anon>",
+ IDENTIFIER_POINTER
+ (DECL_ASSEMBLER_NAME (TYPE_NAME (t))))
+ || type_in_anonymous_namespace_p (t));
return true;
}
return false;
@@ -1777,11 +1773,10 @@ odr_types_equivalent_p (tree t1, tree t2, bool warn, bool *warned,
bool
odr_types_equivalent_p (tree type1, tree type2)
{
- hash_set<type_pair> visited;
+ gcc_checking_assert (odr_or_derived_type_p (type1)
+ && odr_or_derived_type_p (type2));
-#ifdef ENABLE_CHECKING
- gcc_assert (odr_or_derived_type_p (type1) && odr_or_derived_type_p (type2));
-#endif
+ hash_set<type_pair> visited;
return odr_types_equivalent_p (type1, type2, false, NULL,
&visited, UNKNOWN_LOCATION, UNKNOWN_LOCATION);
}
@@ -2000,8 +1995,8 @@ add_type_duplicate (odr_type val, tree type)
}
gcc_assert (val->odr_violated || !odr_must_violate);
/* Sanity check that all bases will be build same way again. */
-#ifdef ENABLE_CHECKING
- if (COMPLETE_TYPE_P (type) && COMPLETE_TYPE_P (val->type)
+ if (CHECKING_P
+ && COMPLETE_TYPE_P (type) && COMPLETE_TYPE_P (val->type)
&& TREE_CODE (val->type) == RECORD_TYPE
&& TREE_CODE (type) == RECORD_TYPE
&& TYPE_BINFO (val->type) && TYPE_BINFO (type)
@@ -2030,7 +2025,6 @@ add_type_duplicate (odr_type val, tree type)
j++;
}
}
-#endif
/* Regularize things a little. During LTO same types may come with
@@ -2136,8 +2130,8 @@ get_odr_type (tree type, bool insert)
if (slot && *slot)
{
val = *slot;
-#ifdef ENABLE_CHECKING
- if (in_lto_p && can_be_vtable_hashed_p (type))
+ if (CHECKING_P
+ && in_lto_p && can_be_vtable_hashed_p (type))
{
hash = hash_odr_vtable (type);
vtable_slot = odr_vtable_hash->find_slot_with_hash (type, hash,
@@ -2145,7 +2139,6 @@ get_odr_type (tree type, bool insert)
gcc_assert (!vtable_slot || *vtable_slot == *slot);
vtable_slot = NULL;
}
-#endif
}
else if (*vtable_slot)
val = *vtable_slot;
diff --git a/gcc/ipa-icf.c b/gcc/ipa-icf.c
index 3597b3a1..5914c5e 100644
--- a/gcc/ipa-icf.c
+++ b/gcc/ipa-icf.c
@@ -2982,7 +2982,9 @@ sem_item_optimizer::subdivide_classes_by_sensitive_refs ()
void
sem_item_optimizer::verify_classes (void)
{
-#if ENABLE_CHECKING
+ if (!CHECKING_P)
+ return;
+
for (hash_table <congruence_class_group_hash>::iterator it = m_classes.begin ();
it != m_classes.end (); ++it)
{
@@ -3009,7 +3011,6 @@ sem_item_optimizer::verify_classes (void)
}
}
}
-#endif
}
/* Disposes split map traverse function. CLS_PTR is pointer to congruence
@@ -3054,10 +3055,11 @@ sem_item_optimizer::traverse_congruence_split (congruence_class * const &cls,
add_item_to_class (tc, cls->members[i]);
}
-#ifdef ENABLE_CHECKING
- for (unsigned int i = 0; i < 2; i++)
- gcc_checking_assert (newclasses[i]->members.length ());
-#endif
+ if (CHECKING_P)
+ {
+ for (unsigned int i = 0; i < 2; i++)
+ gcc_checking_assert (newclasses[i]->members.length ());
+ }
if (splitter_cls == cls)
optimizer->splitter_class_removed = true;
@@ -3152,11 +3154,9 @@ sem_item_optimizer::do_congruence_step_for_index (congruence_class *cls,
else
b = *slot;
-#if ENABLE_CHECKING
gcc_checking_assert (usage->item->cls);
gcc_checking_assert (usage->item->index_in_class <
usage->item->cls->members.length ());
-#endif
bitmap_set_bit (b, usage->item->index_in_class);
}
diff --git a/gcc/ipa-inline-analysis.c b/gcc/ipa-inline-analysis.c
index 3a8f0ec..d95933a 100644
--- a/gcc/ipa-inline-analysis.c
+++ b/gcc/ipa-inline-analysis.c
@@ -2956,10 +2956,12 @@ compute_inline_parameters (struct cgraph_node *node, bool early)
info->size = info->self_size;
info->stack_frame_offset = 0;
info->estimated_stack_size = info->estimated_self_stack_size;
-#ifdef ENABLE_CHECKING
- inline_update_overall_summary (node);
- gcc_assert (info->time == info->self_time && info->size == info->self_size);
-#endif
+ if (CHECKING_P)
+ {
+ inline_update_overall_summary (node);
+ gcc_assert (info->time == info->self_time
+ && info->size == info->self_size);
+ }
pop_cfun ();
}
diff --git a/gcc/ipa-inline-transform.c b/gcc/ipa-inline-transform.c
index 12f701a..49e17ea 100644
--- a/gcc/ipa-inline-transform.c
+++ b/gcc/ipa-inline-transform.c
@@ -491,10 +491,9 @@ save_inline_function_body (struct cgraph_node *node)
first_clone->remove_symbol_and_inline_clones ();
first_clone = NULL;
}
-#ifdef ENABLE_CHECKING
- else
+ else if (CHECKING_P)
first_clone->verify ();
-#endif
+
return first_clone;
}
diff --git a/gcc/ipa-inline.c b/gcc/ipa-inline.c
index f836df6..050529d 100644
--- a/gcc/ipa-inline.c
+++ b/gcc/ipa-inline.c
@@ -1878,7 +1878,7 @@ inline_small_functions (void)
if (!edge->inline_failed || !edge->callee->analyzed)
continue;
-#ifdef ENABLE_CHECKING
+#if CHECKING_P
/* Be sure that caches are maintained consistent. */
sreal cached_badness = edge_badness (edge, false);
@@ -2632,9 +2632,8 @@ early_inliner (function *fun)
if (ipa_node_params_sum)
return 0;
-#ifdef ENABLE_CHECKING
- node->verify ();
-#endif
+ if (CHECKING_P)
+ node->verify ();
node->remove_all_references ();
/* Rebuild this reference because it dosn't depend on
diff --git a/gcc/ipa-inline.h b/gcc/ipa-inline.h
index 85041f6..323d117 100644
--- a/gcc/ipa-inline.h
+++ b/gcc/ipa-inline.h
@@ -299,10 +299,8 @@ estimate_edge_size (struct cgraph_edge *edge)
static inline int
estimate_edge_growth (struct cgraph_edge *edge)
{
-#ifdef ENABLE_CHECKING
gcc_checking_assert (inline_edge_summary (edge)->call_stmt_size
|| !edge->callee->analyzed);
-#endif
return (estimate_edge_size (edge)
- inline_edge_summary (edge)->call_stmt_size);
}
diff --git a/gcc/ipa-visibility.c b/gcc/ipa-visibility.c
index 93073d8..6ca65f6 100644
--- a/gcc/ipa-visibility.c
+++ b/gcc/ipa-visibility.c
@@ -464,16 +464,15 @@ function_and_variable_visibility (bool whole_program)
what comdat group they are in when they won't be emitted in this TU. */
if (node->same_comdat_group && DECL_EXTERNAL (node->decl))
{
-#ifdef ENABLE_CHECKING
- symtab_node *n;
-
- for (n = node->same_comdat_group;
- n != node;
- n = n->same_comdat_group)
- /* If at least one of same comdat group functions is external,
- all of them have to be, otherwise it is a front-end bug. */
- gcc_assert (DECL_EXTERNAL (n->decl));
-#endif
+ if (CHECKING_P)
+ {
+ for (symtab_node *n = node->same_comdat_group;
+ n != node;
+ n = n->same_comdat_group)
+ /* If at least one of same comdat group functions is external,
+ all of them have to be, otherwise it is a front-end bug. */
+ gcc_assert (DECL_EXTERNAL (n->decl));
+ }
node->dissolve_same_comdat_group_list ();
}
gcc_assert ((!DECL_WEAK (node->decl)
diff --git a/gcc/ipa.c b/gcc/ipa.c
index 75e367f..5005a06 100644
--- a/gcc/ipa.c
+++ b/gcc/ipa.c
@@ -319,12 +319,13 @@ symbol_table::remove_unreachable_nodes (FILE *file)
build_type_inheritance_graph ();
if (file)
fprintf (file, "\nReclaiming functions:");
-#ifdef ENABLE_CHECKING
- FOR_EACH_FUNCTION (node)
- gcc_assert (!node->aux);
- FOR_EACH_VARIABLE (vnode)
- gcc_assert (!vnode->aux);
-#endif
+ if (CHECKING_P)
+ {
+ FOR_EACH_FUNCTION (node)
+ gcc_assert (!node->aux);
+ FOR_EACH_VARIABLE (vnode)
+ gcc_assert (!vnode->aux);
+ }
/* Mark functions whose bodies are obviously needed.
This is mostly when they can be referenced externally. Inline clones
are special since their declarations are shared with master clone and thus
@@ -678,9 +679,8 @@ symbol_table::remove_unreachable_nodes (FILE *file)
if (file)
fprintf (file, "\n");
-#ifdef ENABLE_CHECKING
- symtab_node::verify_symtab_nodes ();
-#endif
+ if (CHECKING_P)
+ symtab_node::verify_symtab_nodes ();
/* If we removed something, perhaps profile could be improved. */
if (changed && optimize && inline_edge_summary_vec.exists ())
@@ -1369,13 +1369,11 @@ ipa_single_use (void)
{
if (var->aux != BOTTOM)
{
-#ifdef ENABLE_CHECKING
/* Not having the single user known means that the VAR is
unreachable. Either someone forgot to remove unreachable
variables or the reachability here is wrong. */
-
- gcc_assert (single_user_map.get (var));
-#endif
+ if (CHECKING_P)
+ gcc_assert (single_user_map.get (var));
if (dump_file)
{
fprintf (dump_file, "Variable %s/%i is used by single function\n",
diff --git a/gcc/ira-int.h b/gcc/ira-int.h
index af6c92f..d4160d3 100644
--- a/gcc/ira-int.h
+++ b/gcc/ira-int.h
@@ -26,7 +26,7 @@ along with GCC; see the file COPYING3. If not see
/* To provide consistency in naming, all IRA external variables,
functions, common typedefs start with prefix ira_. */
-#ifdef ENABLE_CHECKING
+#if CHECKING_P
#define ENABLE_IRA_CHECKING
#endif
diff --git a/gcc/ira.c b/gcc/ira.c
index 79827eb..89cf2bd 100644
--- a/gcc/ira.c
+++ b/gcc/ira.c
@@ -5154,9 +5154,9 @@ ira (FILE *f)
df_remove_problem (df_live);
gcc_checking_assert (df_live == NULL);
-#ifdef ENABLE_CHECKING
- df->changeable_flags |= DF_VERIFY_SCHEDULED;
-#endif
+ if (CHECKING_P)
+ df->changeable_flags |= DF_VERIFY_SCHEDULED;
+
df_analyze ();
init_reg_equiv ();
diff --git a/gcc/java/decl.c b/gcc/java/decl.c
index c035fe0..aa731ef 100644
--- a/gcc/java/decl.c
+++ b/gcc/java/decl.c
@@ -1905,14 +1905,12 @@ java_mark_decl_local (tree decl)
{
DECL_EXTERNAL (decl) = 0;
-#ifdef ENABLE_CHECKING
/* Double check that we didn't pass the function to the callgraph early. */
- if (TREE_CODE (decl) == FUNCTION_DECL)
+ if (CHECKING_P && TREE_CODE (decl) == FUNCTION_DECL)
{
struct cgraph_node *node = cgraph_node::get (decl);
gcc_assert (!node || !node->definition);
}
-#endif
gcc_assert (!DECL_RTL_SET_P (decl));
}
diff --git a/gcc/loop-doloop.c b/gcc/loop-doloop.c
index 6554597..5ed4559 100644
--- a/gcc/loop-doloop.c
+++ b/gcc/loop-doloop.c
@@ -734,7 +734,6 @@ doloop_optimize_loops (void)
iv_analysis_done ();
-#ifdef ENABLE_CHECKING
- verify_loop_structure ();
-#endif
+ if (CHECKING_P)
+ verify_loop_structure ();
}
diff --git a/gcc/loop-init.c b/gcc/loop-init.c
index a9a3d6fa..11fd635 100644
--- a/gcc/loop-init.c
+++ b/gcc/loop-init.c
@@ -104,10 +104,8 @@ loop_optimizer_init (unsigned flags)
/* Ensure that the dominators are computed, like flow_loops_find does. */
calculate_dominance_info (CDI_DOMINATORS);
-#ifdef ENABLE_CHECKING
- if (!needs_fixup)
+ if (CHECKING_P && !needs_fixup)
verify_loop_structure ();
-#endif
/* Clear all flags. */
if (recorded_exits)
@@ -129,9 +127,8 @@ loop_optimizer_init (unsigned flags)
/* Dump loops. */
flow_loops_dump (dump_file, NULL, 1);
-#ifdef ENABLE_CHECKING
- verify_loop_structure ();
-#endif
+ if (CHECKING_P)
+ verify_loop_structure ();
timevar_pop (TV_LOOP_INIT);
}
@@ -325,9 +322,8 @@ fix_loop_structure (bitmap changed_bbs)
/* Apply flags to loops. */
apply_loop_flags (current_loops->state | record_exits);
-#ifdef ENABLE_CHECKING
- verify_loop_structure ();
-#endif
+ if (CHECKING_P)
+ verify_loop_structure ();
timevar_pop (TV_LOOP_INIT);
diff --git a/gcc/loop-invariant.c b/gcc/loop-invariant.c
index 52c8ae8..fd6d466 100644
--- a/gcc/loop-invariant.c
+++ b/gcc/loop-invariant.c
@@ -2096,7 +2096,6 @@ move_loop_invariants (void)
invariant_table = NULL;
invariant_table_size = 0;
-#ifdef ENABLE_CHECKING
- verify_flow_info ();
-#endif
+ if (CHECKING_P)
+ verify_flow_info ();
}
diff --git a/gcc/lra-assigns.c b/gcc/lra-assigns.c
index 2986f57..941a829 100644
--- a/gcc/lra-assigns.c
+++ b/gcc/lra-assigns.c
@@ -1591,7 +1591,7 @@ lra_assign (void)
bitmap_initialize (&all_spilled_pseudos, ®_obstack);
create_live_range_start_chains ();
setup_live_pseudos_and_spill_after_risky_transforms (&all_spilled_pseudos);
-#ifdef ENABLE_CHECKING
+#if CHECKING_P
if (!flag_ipa_ra)
for (i = FIRST_PSEUDO_REGISTER; i < max_regno; i++)
if (lra_reg_info[i].nrefs != 0 && reg_renumber[i] >= 0
diff --git a/gcc/lra-constraints.c b/gcc/lra-constraints.c
index ddb91dd..59e3b53 100644
--- a/gcc/lra-constraints.c
+++ b/gcc/lra-constraints.c
@@ -4434,8 +4434,7 @@ lra_constraints (bool first_p)
bitmap_clear (&equiv_insn_bitmap);
/* If we used a new hard regno, changed_p should be true because the
hard reg is assigned to a new pseudo. */
-#ifdef ENABLE_CHECKING
- if (! changed_p)
+ if (CHECKING_P && !changed_p)
{
for (i = FIRST_PSEUDO_REGISTER; i < new_regno_start; i++)
if (lra_reg_info[i].nrefs != 0
@@ -4447,7 +4446,6 @@ lra_constraints (bool first_p)
lra_assert (df_regs_ever_live_p (hard_regno + j));
}
}
-#endif
return changed_p;
}
diff --git a/gcc/lra-eliminations.c b/gcc/lra-eliminations.c
index fdf4179..8325c64 100644
--- a/gcc/lra-eliminations.c
+++ b/gcc/lra-eliminations.c
@@ -1436,11 +1436,11 @@ lra_eliminate (bool final_p, bool first_p)
bitmap_initialize (&insns_with_changed_offsets, ®_obstack);
if (final_p)
{
-#ifdef ENABLE_CHECKING
- update_reg_eliminate (&insns_with_changed_offsets);
- if (! bitmap_empty_p (&insns_with_changed_offsets))
- gcc_unreachable ();
-#endif
+ if (CHECKING_P)
+ {
+ update_reg_eliminate (&insns_with_changed_offsets);
+ gcc_assert (bitmap_empty_p (&insns_with_changed_offsets));
+ }
/* We change eliminable hard registers in insns so we should do
this for all insns containing any eliminable hard
register. */
diff --git a/gcc/lra-int.h b/gcc/lra-int.h
index 5e78604..570f210 100644
--- a/gcc/lra-int.h
+++ b/gcc/lra-int.h
@@ -91,7 +91,7 @@ struct lra_reg
/* True if the pseudo should not be assigned to a stack register. */
bool no_stack_p;
#endif
-#ifdef ENABLE_CHECKING
+#if CHECKING_P
/* True if the pseudo crosses a call. It is setup in lra-lives.c
and used to check that the pseudo crossing a call did not get a
call used hard register. */
diff --git a/gcc/lra-lives.c b/gcc/lra-lives.c
index e139846..c8f9dd5 100644
--- a/gcc/lra-lives.c
+++ b/gcc/lra-lives.c
@@ -591,7 +591,7 @@ check_pseudos_live_through_calls (int regno)
for (hr = 0; hr < FIRST_PSEUDO_REGISTER; hr++)
if (HARD_REGNO_CALL_PART_CLOBBERED (hr, PSEUDO_REGNO_MODE (regno)))
SET_HARD_REG_BIT (lra_reg_info[regno].conflict_hard_regs, hr);
-#ifdef ENABLE_CHECKING
+#if CHECKING_P
lra_reg_info[regno].call_p = true;
#endif
if (! sparseset_bit_p (pseudos_live_through_setjumps, regno))
@@ -1225,7 +1225,7 @@ lra_create_live_ranges_1 (bool all_p, bool dead_insn_p)
lra_reg_info[i].biggest_mode = GET_MODE (regno_reg_rtx[i]);
else
lra_reg_info[i].biggest_mode = VOIDmode;
-#ifdef ENABLE_CHECKING
+#if CHECKING_P
lra_reg_info[i].call_p = false;
#endif
if (i >= FIRST_PSEUDO_REGISTER
diff --git a/gcc/lra-remat.c b/gcc/lra-remat.c
index 66532b8..68ce502 100644
--- a/gcc/lra-remat.c
+++ b/gcc/lra-remat.c
@@ -578,10 +578,8 @@ create_remat_bb_data (void)
last_basic_block_for_fn (cfun));
FOR_ALL_BB_FN (bb, cfun)
{
-#ifdef ENABLE_CHECKING
- if (bb->index < 0 || bb->index >= last_basic_block_for_fn (cfun))
- abort ();
-#endif
+ gcc_checking_assert (bb->index >= 0
+ && bb->index < last_basic_block_for_fn (cfun));
bb_info = get_remat_bb_data (bb);
bb_info->bb = bb;
bitmap_initialize (&bb_info->changed_regs, ®_obstack);
diff --git a/gcc/lra.c b/gcc/lra.c
index a836cab..cca711e 100644
--- a/gcc/lra.c
+++ b/gcc/lra.c
@@ -1198,30 +1198,22 @@ lra_update_insn_recog_data (rtx_insn *insn)
decode_asm_operands (PATTERN (insn), NULL,
data->operand_loc,
constraints, operand_mode, NULL);
-#ifdef ENABLE_CHECKING
- {
- int i;
- for (i = 0; i < nop; i++)
+ if (CHECKING_P)
+ for (int i = 0; i < nop; i++)
lra_assert
(insn_static_data->operand[i].mode == operand_mode[i]
&& insn_static_data->operand[i].constraint == constraints[i]
&& ! insn_static_data->operand[i].is_operator);
- }
-#endif
}
-#ifdef ENABLE_CHECKING
- {
- int i;
- for (i = 0; i < insn_static_data->n_operands; i++)
+ if (CHECKING_P)
+ for (int i = 0; i < insn_static_data->n_operands; i++)
lra_assert
(insn_static_data->operand[i].type
== (insn_static_data->operand[i].constraint[0] == '=' ? OP_OUT
: insn_static_data->operand[i].constraint[0] == '+' ? OP_INOUT
: OP_IN));
- }
-#endif
}
else
{
@@ -2003,7 +1995,7 @@ restore_scratches (void)
-#ifdef ENABLE_CHECKING
+#if CHECKING_P
/* Function checks RTL for correctness. If FINAL_P is true, it is
done at the end of LRA and the check is more rigorous. */
@@ -2023,9 +2015,7 @@ check_rtl (bool final_p)
{
if (final_p)
{
-#ifdef ENABLED_CHECKING
extract_constrain_insn (insn);
-#endif
continue;
}
/* LRA code is based on assumption that all addresses can be
@@ -2038,7 +2028,7 @@ check_rtl (bool final_p)
fatal_insn_not_found (insn);
}
}
-#endif /* #ifdef ENABLE_CHECKING */
+#endif /* #if CHECKING_P */
/* Determine if the current function has an exception receiver block
that reaches the exit block via non-exceptional edges */
@@ -2232,7 +2222,7 @@ lra (FILE *f)
init_insn_recog_data ();
-#ifdef ENABLE_CHECKING
+#if CHECKING_P
/* Some quick check on RTL generated by previous passes. */
check_rtl (false);
#endif
@@ -2436,7 +2426,7 @@ lra (FILE *f)
by this, so unshare everything here. */
unshare_all_rtl_again (get_insns ());
-#ifdef ENABLE_CHECKING
+#if CHECKING_P
check_rtl (true);
#endif
diff --git a/gcc/lto-cgraph.c b/gcc/lto-cgraph.c
index d70537d..802919c 100644
--- a/gcc/lto-cgraph.c
+++ b/gcc/lto-cgraph.c
@@ -1575,10 +1575,11 @@ input_cgraph_1 (struct lto_file_decl_data *file_data,
lto_input_toplevel_asms (file_data, order_base);
/* AUX pointers should be all non-zero for function nodes read from the stream. */
-#ifdef ENABLE_CHECKING
- FOR_EACH_VEC_ELT (nodes, i, node)
- gcc_assert (node->aux || !is_a <cgraph_node *> (node));
-#endif
+ if (CHECKING_P)
+ {
+ FOR_EACH_VEC_ELT (nodes, i, node)
+ gcc_assert (node->aux || !is_a <cgraph_node *> (node));
+ }
FOR_EACH_VEC_ELT (nodes, i, node)
{
int ref;
diff --git a/gcc/lto-streamer-out.c b/gcc/lto-streamer-out.c
index 3ca8855..8b46696 100644
--- a/gcc/lto-streamer-out.c
+++ b/gcc/lto-streamer-out.c
@@ -602,17 +602,12 @@ DFS::DFS (struct output_block *ob, tree expr, bool ref_p, bool this_ref_p,
std::swap (sccstack[first + i],
sccstack[first + entry_start + i]);
- if (scc_entry_len == 1)
- ; /* We already sorted SCC deterministically in hash_scc. */
- else
- /* Check that we have only one SCC.
- Naturally we may have conflicts if hash function is not
- strong enough. Lets see how far this gets. */
- {
-#ifdef ENABLE_CHECKING
- gcc_unreachable ();
-#endif
- }
+ /* We already sorted SCC deterministically in hash_scc. */
+
+ /* Check that we have only one SCC.
+ Naturally we may have conflicts if hash function is not
+ strong enough. Lets see how far this gets. */
+ gcc_checking_assert (scc_entry_len == 1);
}
/* Write LTO_tree_scc. */
@@ -2272,7 +2267,7 @@ void
lto_output (void)
{
struct lto_out_decl_state *decl_state;
-#ifdef ENABLE_CHECKING
+#if CHECKING_P
bitmap output = lto_bitmap_alloc ();
#endif
int i, n_nodes;
@@ -2291,7 +2286,7 @@ lto_output (void)
if (lto_symtab_encoder_encode_body_p (encoder, node)
&& !node->alias)
{
-#ifdef ENABLE_CHECKING
+#if CHECKING_P
gcc_assert (!bitmap_bit_p (output, DECL_UID (node->decl)));
bitmap_set_bit (output, DECL_UID (node->decl));
#endif
@@ -2321,7 +2316,7 @@ lto_output (void)
&& !node->alias)
{
timevar_push (TV_IPA_LTO_CTORS_OUT);
-#ifdef ENABLE_CHECKING
+#if CHECKING_P
gcc_assert (!bitmap_bit_p (output, DECL_UID (node->decl)));
bitmap_set_bit (output, DECL_UID (node->decl));
#endif
@@ -2348,7 +2343,7 @@ lto_output (void)
output_offload_tables ();
-#ifdef ENABLE_CHECKING
+#if CHECKING_P
lto_bitmap_free (output);
#endif
}
diff --git a/gcc/lto-streamer.c b/gcc/lto-streamer.c
index b34ab8b..a45ee03 100644
--- a/gcc/lto-streamer.c
+++ b/gcc/lto-streamer.c
@@ -297,13 +297,12 @@ static hash_table<tree_hash_entry> *tree_htab;
void
lto_streamer_init (void)
{
-#ifdef ENABLE_CHECKING
/* Check that all the TS_* handled by the reader and writer routines
match exactly the structures defined in treestruct.def. When a
new TS_* astructure is added, the streamer should be updated to
handle it. */
- streamer_check_handled_ts_structures ();
-#endif
+ if (CHECKING_P)
+ streamer_check_handled_ts_structures ();
#ifdef LTO_STREAMER_DEBUG
tree_htab = new hash_table<tree_hash_entry> (31);
diff --git a/gcc/lto/lto.c b/gcc/lto/lto.c
index 7ec4c08..4ebcc90 100644
--- a/gcc/lto/lto.c
+++ b/gcc/lto/lto.c
@@ -1580,19 +1580,18 @@ unify_scc (struct data_in *data_in, unsigned from,
num_sccs_merged++;
total_scc_size_merged += len;
-#ifdef ENABLE_CHECKING
- for (unsigned i = 0; i < len; ++i)
- {
- tree t = map[2*i+1];
- enum tree_code code = TREE_CODE (t);
- /* IDENTIFIER_NODEs should be singletons and are merged by the
- streamer. The others should be singletons, too, and we
- should not merge them in any way. */
- gcc_assert (code != TRANSLATION_UNIT_DECL
- && code != IDENTIFIER_NODE
- && !streamer_handle_as_builtin_p (t));
- }
-#endif
+ if (CHECKING_P)
+ for (unsigned i = 0; i < len; ++i)
+ {
+ tree t = map[2*i+1];
+ enum tree_code code = TREE_CODE (t);
+ /* IDENTIFIER_NODEs should be singletons and are merged by the
+ streamer. The others should be singletons, too, and we
+ should not merge them in any way. */
+ gcc_assert (code != TRANSLATION_UNIT_DECL
+ && code != IDENTIFIER_NODE
+ && !streamer_handle_as_builtin_p (t));
+ }
/* Fixup the streamer cache with the prevailing nodes according
to the tree node mapping computed by compare_tree_sccs. */
@@ -2630,10 +2629,8 @@ lto_fixup_state (struct lto_in_decl_state *state)
for (i = 0; i < vec_safe_length (trees); i++)
{
tree t = (*trees)[i];
-#ifdef ENABLE_CHECKING
- if (TYPE_P (t))
+ if (CHECKING_P && TYPE_P (t))
verify_type (t);
-#endif
if (VAR_OR_FUNCTION_DECL_P (t)
&& (TREE_PUBLIC (t) || DECL_EXTERNAL (t)))
(*trees)[i] = lto_symtab_prevailing_decl (t);
@@ -3095,9 +3092,8 @@ do_whole_program_analysis (void)
fprintf (symtab->dump_file, "Optimized ");
symtab_node::dump_table (symtab->dump_file);
}
-#ifdef ENABLE_CHECKING
- symtab_node::verify_symtab_nodes ();
-#endif
+ if (CHECKING_P)
+ symtab_node::verify_symtab_nodes ();
bitmap_obstack_release (NULL);
/* We are about to launch the final LTRANS phase, stop the WPA timer. */
diff --git a/gcc/omp-low.c b/gcc/omp-low.c
index 7cf51b3..3c8c8f9 100644
--- a/gcc/omp-low.c
+++ b/gcc/omp-low.c
@@ -2682,14 +2682,14 @@ scan_omp_target (gomp_target *stmt, omp_context *outer_ctx)
{
TYPE_FIELDS (ctx->record_type)
= nreverse (TYPE_FIELDS (ctx->record_type));
-#ifdef ENABLE_CHECKING
- tree field;
- unsigned int align = DECL_ALIGN (TYPE_FIELDS (ctx->record_type));
- for (field = TYPE_FIELDS (ctx->record_type);
- field;
- field = DECL_CHAIN (field))
- gcc_assert (DECL_ALIGN (field) == align);
-#endif
+ if (CHECKING_P)
+ {
+ unsigned int align = DECL_ALIGN (TYPE_FIELDS (ctx->record_type));
+ for (tree field = TYPE_FIELDS (ctx->record_type);
+ field;
+ field = DECL_CHAIN (field))
+ gcc_assert (DECL_ALIGN (field) == align);
+ }
layout_type (ctx->record_type);
if (offloaded)
fixup_child_record_type (ctx);
@@ -5604,10 +5604,8 @@ expand_omp_taskreg (struct omp_region *region)
}
if (gimple_in_ssa_p (cfun))
update_ssa (TODO_update_ssa);
-#ifdef ENABLE_CHECKING
- if (!loops_state_satisfies_p (LOOPS_NEED_FIXUP))
+ if (CHECKING_P && !loops_state_satisfies_p (LOOPS_NEED_FIXUP))
verify_loop_structure ();
-#endif
pop_cfun ();
}
@@ -9004,10 +9002,8 @@ expand_omp_target (struct omp_region *region)
if (changed)
cleanup_tree_cfg ();
}
-#ifdef ENABLE_CHECKING
- if (!loops_state_satisfies_p (LOOPS_NEED_FIXUP))
+ if (CHECKING_P && !loops_state_satisfies_p (LOOPS_NEED_FIXUP))
verify_loop_structure ();
-#endif
pop_cfun ();
}
@@ -9516,10 +9512,8 @@ execute_expand_omp (void)
expand_omp (root_omp_region);
-#ifdef ENABLE_CHECKING
- if (!loops_state_satisfies_p (LOOPS_NEED_FIXUP))
+ if (CHECKING_P && !loops_state_satisfies_p (LOOPS_NEED_FIXUP))
verify_loop_structure ();
-#endif
cleanup_tree_cfg ();
free_omp_regions ();
@@ -11279,7 +11273,7 @@ lower_omp_target (gimple_stmt_iterator *gsi_p, omp_context *ctx)
default:
break;
case OMP_CLAUSE_MAP:
-#ifdef ENABLE_CHECKING
+#if CHECKING_P
/* First check what we're prepared to handle in the following. */
switch (OMP_CLAUSE_MAP_KIND (c))
{
diff --git a/gcc/passes.c b/gcc/passes.c
index d8e9271..0983daf 100644
--- a/gcc/passes.c
+++ b/gcc/passes.c
@@ -1932,9 +1932,8 @@ execute_function_todo (function *fn, void *data)
gcc_assert (dom_info_state (fn, CDI_POST_DOMINATORS) == DOM_NONE);
/* If we've seen errors do not bother running any verifiers. */
- if (!seen_error ())
+ if (CHECKING_P && !seen_error ())
{
-#if defined ENABLE_CHECKING
dom_state pre_verify_state = dom_info_state (fn, CDI_DOMINATORS);
dom_state pre_verify_pstate = dom_info_state (fn, CDI_POST_DOMINATORS);
@@ -1968,7 +1967,6 @@ execute_function_todo (function *fn, void *data)
/* Make sure verifiers don't change dominator state. */
gcc_assert (dom_info_state (fn, CDI_DOMINATORS) == pre_verify_state);
gcc_assert (dom_info_state (fn, CDI_POST_DOMINATORS) == pre_verify_pstate);
-#endif
}
fn->last_verified = flags & TODO_verify_all;
@@ -1988,11 +1986,10 @@ execute_function_todo (function *fn, void *data)
static void
execute_todo (unsigned int flags)
{
-#if defined ENABLE_CHECKING
- if (cfun
+ if (CHECKING_P
+ && cfun
&& need_ssa_update_p (cfun))
gcc_assert (flags & TODO_update_ssa_any);
-#endif
timevar_push (TV_TODO);
@@ -2051,14 +2048,12 @@ clear_last_verified (function *fn, void *data ATTRIBUTE_UNUSED)
/* Helper function. Verify that the properties has been turn into the
properties expected by the pass. */
-#ifdef ENABLE_CHECKING
-static void
+static void DEBUG_FUNCTION
verify_curr_properties (function *fn, void *data)
{
unsigned int props = (size_t)data;
gcc_assert ((fn->curr_properties & props) == props);
}
-#endif
/* Initialize pass dump file. */
/* This is non-static so that the plugins can use it. */
@@ -2306,10 +2301,9 @@ execute_one_pass (opt_pass *pass)
/* Run pre-pass verification. */
execute_todo (pass->todo_flags_start);
-#ifdef ENABLE_CHECKING
- do_per_function (verify_curr_properties,
- (void *)(size_t)pass->properties_required);
-#endif
+ if (CHECKING_P)
+ do_per_function (verify_curr_properties,
+ (void *)(size_t)pass->properties_required);
/* If a timevar is present, start it. */
if (pass->tv_id != TV_NONE)
diff --git a/gcc/predict.c b/gcc/predict.c
index 965d7cb..1f44ee4 100644
--- a/gcc/predict.c
+++ b/gcc/predict.c
@@ -2205,19 +2205,16 @@ tree_bb_level_predictions (void)
}
}
-#ifdef ENABLE_CHECKING
-
/* Callback for hash_map::traverse, asserts that the pointer map is
empty. */
-bool
+bool DEBUG_FUNCTION
assert_is_empty (const_basic_block const &, edge_prediction *const &value,
void *)
{
gcc_assert (!value);
return false;
}
-#endif
/* Predict branch probabilities and estimate profile for basic block BB. */
@@ -2352,9 +2349,9 @@ tree_estimate_probability (void)
FOR_EACH_BB_FN (bb, cfun)
combine_predictions_for_bb (bb);
-#ifdef ENABLE_CHECKING
- bb_predictions->traverse<void *, assert_is_empty> (NULL);
-#endif
+ if (CHECKING_P)
+ bb_predictions->traverse<void *, assert_is_empty> (NULL);
+
delete bb_predictions;
bb_predictions = NULL;
@@ -2545,11 +2542,12 @@ propagate_freq (basic_block head, bitmap tovisit)
/* Compute frequency of basic block. */
if (bb != head)
{
-#ifdef ENABLE_CHECKING
- FOR_EACH_EDGE (e, ei, bb->preds)
- gcc_assert (!bitmap_bit_p (tovisit, e->src->index)
- || (e->flags & EDGE_DFS_BACK));
-#endif
+ if (CHECKING_P)
+ {
+ FOR_EACH_EDGE (e, ei, bb->preds)
+ gcc_assert (!bitmap_bit_p (tovisit, e->src->index)
+ || (e->flags & EDGE_DFS_BACK));
+ }
FOR_EACH_EDGE (e, ei, bb->preds)
if (EDGE_INFO (e)->back_edge)
diff --git a/gcc/pretty-print.c b/gcc/pretty-print.c
index fdc7b4d..da93b32 100644
--- a/gcc/pretty-print.c
+++ b/gcc/pretty-print.c
@@ -625,10 +625,11 @@ pp_format (pretty_printer *pp, text_info *text)
*formatters[argno] = XOBFINISH (&buffer->chunk_obstack, const char *);
}
-#ifdef ENABLE_CHECKING
- for (; argno < PP_NL_ARGMAX; argno++)
- gcc_assert (!formatters[argno]);
-#endif
+ if (CHECKING_P)
+ {
+ for (; argno < PP_NL_ARGMAX; argno++)
+ gcc_assert (!formatters[argno]);
+ }
/* Revert to normal obstack and wrapping mode. */
buffer->obstack = &buffer->formatted_obstack;
diff --git a/gcc/real.c b/gcc/real.c
index c1ff78d..80a0c83 100644
--- a/gcc/real.c
+++ b/gcc/real.c
@@ -1792,15 +1792,13 @@ real_to_decimal_for_mode (char *str, const REAL_VALUE_TYPE *r_orig,
/* Append the exponent. */
sprintf (last, "e%+d", dec_exp);
-#ifdef ENABLE_CHECKING
/* Verify that we can read the original value back in. */
- if (mode != VOIDmode)
+ if (CHECKING_P && mode != VOIDmode)
{
real_from_string (&r, str);
real_convert (&r, mode, &r);
gcc_assert (real_identical (&r, r_orig));
}
-#endif
}
/* Likewise, except always uses round-to-nearest. */
diff --git a/gcc/recog.c b/gcc/recog.c
index c032424..faa4220 100644
--- a/gcc/recog.c
+++ b/gcc/recog.c
@@ -2975,9 +2975,8 @@ split_all_insns (void)
if (changed)
find_many_sub_basic_blocks (blocks);
-#ifdef ENABLE_CHECKING
- verify_flow_info ();
-#endif
+ if (CHECKING_P)
+ verify_flow_info ();
sbitmap_free (blocks);
}
diff --git a/gcc/regcprop.c b/gcc/regcprop.c
index 97433f0..eca5af4 100644
--- a/gcc/regcprop.c
+++ b/gcc/regcprop.c
@@ -100,8 +100,10 @@ static bool replace_oldest_value_addr (rtx *, enum reg_class,
static bool replace_oldest_value_mem (rtx, rtx_insn *, struct value_data *);
static bool copyprop_hardreg_forward_1 (basic_block, struct value_data *);
extern void debug_value_data (struct value_data *);
-#ifdef ENABLE_CHECKING
+#if CHECKING_P
static void validate_value_data (struct value_data *);
+#else
+# define validate_value_data(v) ((void)(v))
#endif
/* Free all queued updates for DEBUG_INSNs that change some reg to
@@ -150,9 +152,7 @@ kill_value_one_regno (unsigned int regno, struct value_data *vd)
if (vd->e[regno].debug_insn_changes)
free_debug_insn_changes (vd, regno);
-#ifdef ENABLE_CHECKING
validate_value_data (vd);
-#endif
}
/* Kill the value in register REGNO for NREGS, and any other registers
@@ -365,9 +365,7 @@ copy_value (rtx dest, rtx src, struct value_data *vd)
continue;
vd->e[i].next_regno = dr;
-#ifdef ENABLE_CHECKING
validate_value_data (vd);
-#endif
}
/* Return true if a mode change from ORIG to NEW is allowed for REGNO. */
@@ -1141,7 +1139,7 @@ copyprop_hardreg_forward_bb_without_debug_insn (basic_block bb)
skip_debug_insn_p = false;
}
-#ifdef ENABLE_CHECKING
+#if CHECKING_P
static void
validate_value_data (struct value_data *vd)
{
diff --git a/gcc/reload.c b/gcc/reload.c
index cc61d77..32eec02 100644
--- a/gcc/reload.c
+++ b/gcc/reload.c
@@ -85,7 +85,7 @@ a register with any other reload. */
#define REG_OK_STRICT
-/* We do not enable this with ENABLE_CHECKING, since it is awfully slow. */
+/* We do not enable this with CHECKING_P, since it is awfully slow. */
#undef DEBUG_RELOAD
#include "config.h"
diff --git a/gcc/sched-deps.c b/gcc/sched-deps.c
index 8a40eea..58ba1bd 100644
--- a/gcc/sched-deps.c
+++ b/gcc/sched-deps.c
@@ -47,12 +47,6 @@ along with GCC; see the file COPYING3. If not see
#ifdef INSN_SCHEDULING
-#ifdef ENABLE_CHECKING
-#define CHECK (true)
-#else
-#define CHECK (false)
-#endif
-
/* Holds current parameters for the dependency analyzer. */
struct sched_deps_info_def *sched_deps_info;
@@ -505,9 +499,7 @@ static enum DEPS_ADJUST_RESULT maybe_add_or_update_dep_1 (dep_t, bool,
rtx, rtx);
static enum DEPS_ADJUST_RESULT add_or_update_dep_1 (dep_t, bool, rtx, rtx);
-#ifdef ENABLE_CHECKING
static void check_dep (dep_t, bool);
-#endif
/* Return nonzero if a load of the memory reference MEM can cause a trap. */
@@ -1228,9 +1220,8 @@ add_or_update_dep_1 (dep_t new_dep, bool resolved_p,
gcc_assert (INSN_P (DEP_PRO (new_dep)) && INSN_P (DEP_CON (new_dep))
&& DEP_PRO (new_dep) != DEP_CON (new_dep));
-#ifdef ENABLE_CHECKING
- check_dep (new_dep, mem1 != NULL);
-#endif
+ if (CHECKING_P)
+ check_dep (new_dep, mem1 != NULL);
if (true_dependency_cache != NULL)
{
@@ -1348,9 +1339,8 @@ sd_add_dep (dep_t dep, bool resolved_p)
add_to_deps_list (DEP_NODE_BACK (n), con_back_deps);
-#ifdef ENABLE_CHECKING
- check_dep (dep, false);
-#endif
+ if (CHECKING_P)
+ check_dep (dep, false);
add_to_deps_list (DEP_NODE_FORW (n), pro_forw_deps);
@@ -4519,10 +4509,9 @@ debug_ds (ds_t s)
fprintf (stderr, "\n");
}
-#ifdef ENABLE_CHECKING
/* Verify that dependence type and status are consistent.
If RELAXED_P is true, then skip dep_weakness checks. */
-static void
+static void DEBUG_FUNCTION
check_dep (dep_t dep, bool relaxed_p)
{
enum reg_note dt = DEP_TYPE (dep);
@@ -4604,7 +4593,6 @@ check_dep (dep_t dep, bool relaxed_p)
gcc_assert (ds & BEGIN_CONTROL);
}
}
-#endif /* ENABLE_CHECKING */
/* The following code discovers opportunities to switch a memory reference
and an increment by modifying the address. We ensure that this is done
diff --git a/gcc/sel-sched-ir.c b/gcc/sel-sched-ir.c
index 9988285..d8d64d3 100644
--- a/gcc/sel-sched-ir.c
+++ b/gcc/sel-sched-ir.c
@@ -954,10 +954,9 @@ return_regset_to_pool (regset rs)
regset_pool.v[regset_pool.n++] = rs;
}
-#ifdef ENABLE_CHECKING
/* This is used as a qsort callback for sorting regset pool stacks.
X and XX are addresses of two regsets. They are never equal. */
-static int
+DEBUG_FUNCTION static int
cmp_v_in_regset_pool (const void *x, const void *xx)
{
uintptr_t r1 = (uintptr_t) *((const regset *) x);
@@ -968,13 +967,12 @@ cmp_v_in_regset_pool (const void *x, const void *xx)
return -1;
gcc_unreachable ();
}
-#endif
/* Free the regset pool possibly checking for memory leaks. */
void
free_regset_pool (void)
{
-#ifdef ENABLE_CHECKING
+#if CHECKING_P
{
regset *v = regset_pool.v;
int i = 0;
@@ -3623,10 +3621,9 @@ insn_is_the_only_one_in_bb_p (insn_t insn)
return sel_bb_head_p (insn) && sel_bb_end_p (insn);
}
-#ifdef ENABLE_CHECKING
/* Check that the region we're scheduling still has at most one
backedge. */
-static void
+DEBUG_FUNCTION static void
verify_backedges (void)
{
if (pipelining_p)
@@ -3644,7 +3641,6 @@ verify_backedges (void)
gcc_assert (n <= 1);
}
}
-#endif
/* Functions to work with control flow. */
@@ -3889,10 +3885,11 @@ tidy_control_flow (basic_block xbb, bool full_tidying)
sel_recompute_toporder ();
}
-#ifdef ENABLE_CHECKING
- verify_backedges ();
- verify_dominators (CDI_DOMINATORS);
-#endif
+ if (CHECKING_P)
+ {
+ verify_backedges ();
+ verify_dominators (CDI_DOMINATORS);
+ }
return changed;
}
diff --git a/gcc/sel-sched.c b/gcc/sel-sched.c
index 721013f..fcf9ba8 100644
--- a/gcc/sel-sched.c
+++ b/gcc/sel-sched.c
@@ -378,7 +378,7 @@ struct moveop_static_params
they are to be removed. */
int uid;
-#ifdef ENABLE_CHECKING
+#if CHECKING_P
/* This is initialized to the insn on which the driver stopped its traversal. */
insn_t failed_insn;
#endif
@@ -1655,7 +1655,7 @@ find_best_reg_for_expr (expr_t expr, blist_t bnds, bool *is_orig_reg_p)
collect_unavailable_regs_from_bnds (expr, bnds, used_regs, ®_rename_data,
&original_insns);
-#ifdef ENABLE_CHECKING
+#if CHECKING_P
/* If after reload, make sure we're working with hard regs here. */
if (reload_completed)
{
@@ -3593,7 +3593,7 @@ vinsn_vec_has_expr_p (vinsn_vec_t vinsn_vec, expr_t expr)
return false;
}
-#ifdef ENABLE_CHECKING
+#if CHECKING_P
/* Return true if either of expressions from ORIG_OPS can be blocked
by previously created bookkeeping code. STATIC_PARAMS points to static
parameters of move_op. */
@@ -4889,11 +4889,10 @@ move_cond_jump (rtx_insn *insn, bnd_t bnd)
block_bnd = BLOCK_FOR_INSN (BND_TO (bnd));
prev = BND_TO (bnd);
-#ifdef ENABLE_CHECKING
/* Moving of jump should not cross any other jumps or beginnings of new
basic blocks. The only exception is when we move a jump through
mutually exclusive insns along fallthru edges. */
- if (block_from != block_bnd)
+ if (CHECKING_P && block_from != block_bnd)
{
bb = block_from;
for (link = PREV_INSN (insn); link != PREV_INSN (prev);
@@ -4908,7 +4907,6 @@ move_cond_jump (rtx_insn *insn, bnd_t bnd)
}
}
}
-#endif
/* Jump is moved to the boundary. */
next = PREV_INSN (insn);
@@ -6205,7 +6203,7 @@ move_op_orig_expr_not_found (insn_t insn, av_set_t orig_ops ATTRIBUTE_UNUSED,
{
moveop_static_params_p sparams = (moveop_static_params_p) static_params;
-#ifdef ENABLE_CHECKING
+#if CHECKING_P
sparams->failed_insn = insn;
#endif
@@ -6380,7 +6378,6 @@ code_motion_process_successors (insn_t insn, av_set_t orig_ops,
}
}
-#ifdef ENABLE_CHECKING
/* Here, RES==1 if original expr was found at least for one of the
successors. After the loop, RES may happen to have zero value
only if at some point the expr searched is present in av_set, but is
@@ -6388,6 +6385,7 @@ code_motion_process_successors (insn_t insn, av_set_t orig_ops,
The exception is when the original operation is blocked by
bookkeeping generated for another fence or for another path in current
move_op. */
+#if CHECKING_P
gcc_assert (res == 1
|| (res == 0
&& av_set_could_be_blocked_by_bookkeeping_p (orig_ops,
@@ -6695,7 +6693,7 @@ move_op (insn_t insn, av_set_t orig_ops, expr_t expr_vliw,
sparams.dest = dest;
sparams.c_expr = c_expr;
sparams.uid = INSN_UID (EXPR_INSN_RTX (expr_vliw));
-#ifdef ENABLE_CHECKING
+#if CHECKING_P
sparams.failed_insn = NULL;
#endif
sparams.was_renamed = false;
diff --git a/gcc/sese.h b/gcc/sese.h
index 52aa868..a4ae509 100644
--- a/gcc/sese.h
+++ b/gcc/sese.h
@@ -82,16 +82,20 @@ sese_nb_params (sese region)
static inline bool
bb_in_region (basic_block bb, basic_block entry, basic_block exit)
{
-#ifdef ENABLE_CHECKING
- {
- edge e;
- edge_iterator ei;
-
- /* Check that there are no edges coming in the region: all the
- predecessors of EXIT are dominated by ENTRY. */
- FOR_EACH_EDGE (e, ei, exit->preds)
- dominated_by_p (CDI_DOMINATORS, e->src, entry);
- }
+/* FIXME: this stuff does not work: dominated_by_p has no effect,
+ but changing it to gcc_assert (dominated_by_p (...)) causes
+ lots of regressions, e.g. gcc.dg/graphite/block-1.c. */
+#if 0
+ if (CHECKING_P)
+ {
+ edge e;
+ edge_iterator ei;
+
+ /* Check that there are no edges coming in the region: all the
+ predecessors of EXIT are dominated by ENTRY. */
+ FOR_EACH_EDGE (e, ei, exit->preds)
+ dominated_by_p (CDI_DOMINATORS, e->src, entry);
+ }
#endif
return dominated_by_p (CDI_DOMINATORS, bb, entry)
diff --git a/gcc/ssa-iterators.h b/gcc/ssa-iterators.h
index a9bf699..ecd84fd 100644
--- a/gcc/ssa-iterators.h
+++ b/gcc/ssa-iterators.h
@@ -344,9 +344,8 @@ first_readonly_imm_use (imm_use_iterator *imm, tree var)
{
imm->end_p = &(SSA_NAME_IMM_USE_NODE (var));
imm->imm_use = imm->end_p->next;
-#ifdef ENABLE_CHECKING
- imm->iter_node.next = imm->imm_use->next;
-#endif
+ if (CHECKING_P)
+ imm->iter_node.next = imm->imm_use->next;
if (end_readonly_imm_use_p (imm))
return NULL_USE_OPERAND_P;
return imm->imm_use;
@@ -358,14 +357,15 @@ next_readonly_imm_use (imm_use_iterator *imm)
{
use_operand_p old = imm->imm_use;
-#ifdef ENABLE_CHECKING
/* If this assertion fails, it indicates the 'next' pointer has changed
since the last bump. This indicates that the list is being modified
via stmt changes, or SET_USE, or somesuch thing, and you need to be
using the SAFE version of the iterator. */
- gcc_assert (imm->iter_node.next == old->next);
- imm->iter_node.next = old->next->next;
-#endif
+ if (CHECKING_P)
+ {
+ gcc_assert (imm->iter_node.next == old->next);
+ imm->iter_node.next = old->next->next;
+ }
imm->imm_use = old->next;
if (end_readonly_imm_use_p (imm))
diff --git a/gcc/store-motion.c b/gcc/store-motion.c
index ec3faa2..0648bb7 100644
--- a/gcc/store-motion.c
+++ b/gcc/store-motion.c
@@ -644,9 +644,6 @@ compute_store_table (void)
{
int ret;
basic_block bb;
-#ifdef ENABLE_CHECKING
- unsigned regno;
-#endif
rtx_insn *insn;
rtx_insn *tmp;
df_ref def;
@@ -692,11 +689,12 @@ compute_store_table (void)
last_set_in[DF_REF_REGNO (def)] = 0;
}
-#ifdef ENABLE_CHECKING
- /* last_set_in should now be all-zero. */
- for (regno = 0; regno < max_gcse_regno; regno++)
- gcc_assert (!last_set_in[regno]);
-#endif
+ if (CHECKING_P)
+ {
+ /* last_set_in should now be all-zero. */
+ for (unsigned regno = 0; regno < max_gcse_regno; regno++)
+ gcc_assert (!last_set_in[regno]);
+ }
/* Clear temporary marks. */
for (ptr = first_st_expr (); ptr != NULL; ptr = next_st_expr (ptr))
diff --git a/gcc/symbol-summary.h b/gcc/symbol-summary.h
index eefbfd9..a608d6a 100644
--- a/gcc/symbol-summary.h
+++ b/gcc/symbol-summary.h
@@ -39,14 +39,12 @@ public:
function_summary (symbol_table *symtab, bool ggc = false): m_ggc (ggc),
m_map (13, ggc), m_insertion_enabled (true), m_symtab (symtab)
{
-#ifdef ENABLE_CHECKING
- cgraph_node *node;
-
- FOR_EACH_FUNCTION (node)
- {
- gcc_checking_assert (node->summary_uid > 0);
- }
-#endif
+ if (CHECKING_P)
+ {
+ cgraph_node *node;
+ FOR_EACH_FUNCTION (node)
+ gcc_assert (node->summary_uid > 0);
+ }
m_symtab_insertion_hook =
symtab->add_cgraph_insertion_hook
diff --git a/gcc/system.h b/gcc/system.h
index 9ca5b5f..52878f1 100644
--- a/gcc/system.h
+++ b/gcc/system.h
@@ -714,8 +714,11 @@ extern void fancy_abort (const char *, int, const char *) ATTRIBUTE_NORETURN;
#ifdef ENABLE_CHECKING
#define gcc_checking_assert(EXPR) gcc_assert (EXPR)
+#define CHECKING_P 1
#else
+/* N.B.: in release build EXPR is not evaluated. */
#define gcc_checking_assert(EXPR) ((void)(0 && (EXPR)))
+#define CHECKING_P 0
#endif
/* Use gcc_unreachable() to mark unreachable locations (like an
diff --git a/gcc/target.h b/gcc/target.h
index a79f424..ffc4d6a 100644
--- a/gcc/target.h
+++ b/gcc/target.h
@@ -52,21 +52,21 @@
#include "tm.h"
#include "hard-reg-set.h"
-#ifdef ENABLE_CHECKING
+#if CHECKING_P
struct cumulative_args_t { void *magic; void *p; };
-#else /* !ENABLE_CHECKING */
+#else /* !CHECKING_P */
/* When using a GCC build compiler, we could use
__attribute__((transparent_union)) to get cumulative_args_t function
arguments passed like scalars where the ABI would mandate a less
efficient way of argument passing otherwise. However, that would come
- at the cost of less type-safe !ENABLE_CHECKING compilation. */
+ at the cost of less type-safe !CHECKING_P compilation. */
union cumulative_args_t { void *p; };
-#endif /* !ENABLE_CHECKING */
+#endif /* !CHECKING_P */
/* Types used by the record_gcc_switches() target function. */
enum print_switch_type
@@ -200,9 +200,9 @@ extern struct gcc_target targetm;
static inline CUMULATIVE_ARGS *
get_cumulative_args (cumulative_args_t arg)
{
-#ifdef ENABLE_CHECKING
+#if CHECKING_P
gcc_assert (arg.magic == CUMULATIVE_ARGS_MAGIC);
-#endif /* ENABLE_CHECKING */
+#endif /* CHECKING_P */
return (CUMULATIVE_ARGS *) arg.p;
}
@@ -211,9 +211,9 @@ pack_cumulative_args (CUMULATIVE_ARGS *arg)
{
cumulative_args_t ret;
-#ifdef ENABLE_CHECKING
+#if CHECKING_P
ret.magic = CUMULATIVE_ARGS_MAGIC;
-#endif /* ENABLE_CHECKING */
+#endif /* CHECKING_P */
ret.p = (void *) arg;
return ret;
}
diff --git a/gcc/timevar.c b/gcc/timevar.c
index 8249727..02b8113 100644
--- a/gcc/timevar.c
+++ b/gcc/timevar.c
@@ -727,10 +727,13 @@ timer::print (FILE *fp)
#endif
fprintf (fp, "%8u kB\n", (unsigned) (total->ggc_mem >> 10));
-#ifdef ENABLE_CHECKING
- fprintf (fp, "Extra diagnostic checks enabled; compiler may run slowly.\n");
- fprintf (fp, "Configure with --enable-checking=release to disable checks.\n");
-#endif
+ if (CHECKING_P)
+ {
+ fprintf (fp, "Extra diagnostic checks enabled; "
+ "compiler may run slowly.\n");
+ fprintf (fp, "Configure with --enable-checking=release "
+ "to disable checks.\n");
+ }
#ifndef ENABLE_ASSERT_CHECKING
fprintf (fp, "Internal checks disabled; compiler is not suited for release.\n");
fprintf (fp, "Configure with --enable-checking=release to enable checks.\n");
diff --git a/gcc/trans-mem.c b/gcc/trans-mem.c
index 891e638..c513a2e 100644
--- a/gcc/trans-mem.c
+++ b/gcc/trans-mem.c
@@ -5337,9 +5337,8 @@ ipa_tm_execute (void)
enum availability a;
unsigned int i;
-#ifdef ENABLE_CHECKING
- cgraph_node::verify_cgraph_nodes ();
-#endif
+ if (CHECKING_P)
+ cgraph_node::verify_cgraph_nodes ();
bitmap_obstack_initialize (&tm_obstack);
initialize_original_copy_tables ();
@@ -5585,9 +5584,8 @@ ipa_tm_execute (void)
FOR_EACH_FUNCTION (node)
node->aux = NULL;
-#ifdef ENABLE_CHECKING
- cgraph_node::verify_cgraph_nodes ();
-#endif
+ if (CHECKING_P)
+ cgraph_node::verify_cgraph_nodes ();
return 0;
}
diff --git a/gcc/tree-cfg.c b/gcc/tree-cfg.c
index 416c816..fe59d13 100644
--- a/gcc/tree-cfg.c
+++ b/gcc/tree-cfg.c
@@ -6469,14 +6469,12 @@ move_stmt_op (tree *tp, int *walk_subtrees, void *data)
|| (p->orig_block == NULL_TREE
&& block != NULL_TREE))
TREE_SET_BLOCK (t, p->new_block);
-#ifdef ENABLE_CHECKING
- else if (block != NULL_TREE)
+ else if (CHECKING_P && block != NULL_TREE)
{
while (block && TREE_CODE (block) == BLOCK && block != p->orig_block)
block = BLOCK_SUPERCONTEXT (block);
gcc_assert (block == p->orig_block);
}
-#endif
}
else if (DECL_P (t) || TREE_CODE (t) == SSA_NAME)
{
@@ -7045,9 +7043,8 @@ move_sese_region_to_fn (struct function *dest_cfun, basic_block entry_bb,
bbs.create (0);
bbs.safe_push (entry_bb);
gather_blocks_in_sese_region (entry_bb, exit_bb, &bbs);
-#ifdef ENABLE_CHECKING
- verify_sese (entry_bb, exit_bb, &bbs);
-#endif
+ if (CHECKING_P)
+ verify_sese (entry_bb, exit_bb, &bbs);
/* The blocks that used to be dominated by something in BBS will now be
dominated by the new block. */
@@ -7843,13 +7840,11 @@ gimple_flow_call_edges_add (sbitmap blocks)
no edge to the exit block in CFG already.
Calling make_edge in such case would cause us to
mark that edge as fake and remove it later. */
-#ifdef ENABLE_CHECKING
- if (stmt == last_stmt)
+ if (CHECKING_P && stmt == last_stmt)
{
e = find_edge (bb, EXIT_BLOCK_PTR_FOR_FN (cfun));
gcc_assert (e == NULL);
}
-#endif
/* Note that the following may create a new basic block
and renumber the existing basic blocks. */
diff --git a/gcc/tree-cfgcleanup.c b/gcc/tree-cfgcleanup.c
index f3da9c5..f4ec3bf 100644
--- a/gcc/tree-cfgcleanup.c
+++ b/gcc/tree-cfgcleanup.c
@@ -724,9 +724,8 @@ cleanup_tree_cfg_noloop (void)
}
else
{
-#ifdef ENABLE_CHECKING
- verify_dominators (CDI_DOMINATORS);
-#endif
+ if (CHECKING_P)
+ verify_dominators (CDI_DOMINATORS);
changed = false;
}
@@ -735,9 +734,8 @@ cleanup_tree_cfg_noloop (void)
gcc_assert (dom_info_available_p (CDI_DOMINATORS));
compact_blocks ();
-#ifdef ENABLE_CHECKING
- verify_flow_info ();
-#endif
+ if (CHECKING_P)
+ verify_flow_info ();
timevar_pop (TV_TREE_CLEANUP_CFG);
@@ -772,9 +770,8 @@ repair_loop_structures (void)
BITMAP_FREE (changed_bbs);
-#ifdef ENABLE_CHECKING
- verify_loop_structure ();
-#endif
+ if (CHECKING_P)
+ verify_loop_structure ();
scev_reset ();
timevar_pop (TV_REPAIR_LOOPS);
diff --git a/gcc/tree-eh.c b/gcc/tree-eh.c
index c1ca468..4dd17fc 100644
--- a/gcc/tree-eh.c
+++ b/gcc/tree-eh.c
@@ -703,7 +703,7 @@ maybe_record_in_goto_queue (struct leh_state *state, gimple stmt)
}
-#ifdef ENABLE_CHECKING
+#if CHECKING_P
/* We do not process GIMPLE_SWITCHes for now. As long as the original source
was in fact structured, and we've not yet done jump threading, then none
of the labels will leave outer GIMPLE_TRY_FINALLY nodes. Verify this. */
@@ -3912,9 +3912,8 @@ remove_unreachable_handlers (void)
sbitmap_free (r_reachable);
sbitmap_free (lp_reachable);
-#ifdef ENABLE_CHECKING
- verify_eh_tree (cfun);
-#endif
+ if (CHECKING_P)
+ verify_eh_tree (cfun);
}
/* Remove unreachable handlers if any landing pads have been removed after
diff --git a/gcc/tree-if-conv.c b/gcc/tree-if-conv.c
index 291e602..ce8176a 100644
--- a/gcc/tree-if-conv.c
+++ b/gcc/tree-if-conv.c
@@ -2787,13 +2787,12 @@ pass_if_conversion::execute (function *fun)
&& !loop->dont_vectorize))
todo |= tree_if_conversion (loop);
-#ifdef ENABLE_CHECKING
- {
- basic_block bb;
- FOR_EACH_BB_FN (bb, fun)
- gcc_assert (!bb->aux);
- }
-#endif
+ if (CHECKING_P)
+ {
+ basic_block bb;
+ FOR_EACH_BB_FN (bb, fun)
+ gcc_assert (!bb->aux);
+ }
return todo;
}
diff --git a/gcc/tree-inline.c b/gcc/tree-inline.c
index e1ceea4..237af8a 100644
--- a/gcc/tree-inline.c
+++ b/gcc/tree-inline.c
@@ -4476,10 +4476,8 @@ expand_call_inline (basic_block bb, gimple stmt, copy_body_data *id)
fn = cg_edge->callee->decl;
cg_edge->callee->get_untransformed_body ();
-#ifdef ENABLE_CHECKING
- if (cg_edge->callee->decl != id->dst_node->decl)
+ if (CHECKING_P && cg_edge->callee->decl != id->dst_node->decl)
cg_edge->callee->verify ();
-#endif
/* We will be inlining this callee. */
id->eh_lp_nr = lookup_stmt_eh_lp (stmt);
@@ -4967,7 +4965,7 @@ optimize_inline_calls (tree fn)
pop_gimplify_context (NULL);
-#ifdef ENABLE_CHECKING
+ if (CHECKING_P)
{
struct cgraph_edge *e;
@@ -4977,7 +4975,6 @@ optimize_inline_calls (tree fn)
for (e = id.dst_node->callees; e; e = e->next_callee)
gcc_assert (e->inline_failed);
}
-#endif
/* Fold queued statements. */
fold_marked_statements (last, id.statements_to_fold);
@@ -4993,9 +4990,8 @@ optimize_inline_calls (tree fn)
number_blocks (fn);
delete_unreachable_blocks_update_callgraph (&id);
-#ifdef ENABLE_CHECKING
- id.dst_node->verify ();
-#endif
+ if (CHECKING_P)
+ id.dst_node->verify ();
/* It would be nice to check SSA/CFG/statement consistency here, but it is
not possible yet - the IPA passes might make various functions to not
diff --git a/gcc/tree-into-ssa.c b/gcc/tree-into-ssa.c
index cc77618..207d11d 100644
--- a/gcc/tree-into-ssa.c
+++ b/gcc/tree-into-ssa.c
@@ -3179,7 +3179,7 @@ update_ssa (unsigned update_flags)
if (!need_ssa_update_p (cfun))
return;
-#ifdef ENABLE_CHECKING
+#if CHECKING_P
timevar_push (TV_TREE_STMT_VERIFY);
bool err = false;
@@ -3281,7 +3281,7 @@ update_ssa (unsigned update_flags)
placement heuristics. */
prepare_block_for_update (start_bb, insert_phi_p);
-#ifdef ENABLE_CHECKING
+#if CHECKING_P
for (i = 1; i < num_ssa_names; ++i)
{
tree name = ssa_name (i);
diff --git a/gcc/tree-loop-distribution.c b/gcc/tree-loop-distribution.c
index 213793e..be7aaf2 100644
--- a/gcc/tree-loop-distribution.c
+++ b/gcc/tree-loop-distribution.c
@@ -1821,9 +1821,8 @@ out:
rewrite_into_loop_closed_ssa (NULL, TODO_update_ssa);
}
-#ifdef ENABLE_CHECKING
- verify_loop_structure ();
-#endif
+ if (CHECKING_P)
+ verify_loop_structure ();
return 0;
}
diff --git a/gcc/tree-outof-ssa.c b/gcc/tree-outof-ssa.c
index 978476c..15fd149 100644
--- a/gcc/tree-outof-ssa.c
+++ b/gcc/tree-outof-ssa.c
@@ -841,7 +841,7 @@ eliminate_useless_phis (void)
result = gimple_phi_result (phi);
if (virtual_operand_p (result))
{
-#ifdef ENABLE_CHECKING
+#if CHECKING_P
size_t i;
/* There should be no arguments which are not virtual, or the
results will be incorrect. */
@@ -884,9 +884,11 @@ eliminate_useless_phis (void)
variable. */
static void
-rewrite_trees (var_map map ATTRIBUTE_UNUSED)
+rewrite_trees (var_map map)
{
-#ifdef ENABLE_CHECKING
+ if (!CHECKING_P)
+ return;
+
basic_block bb;
/* Search for PHIs where the destination has no partition, but one
or more arguments has a partition. This should not happen and can
@@ -918,7 +920,6 @@ rewrite_trees (var_map map ATTRIBUTE_UNUSED)
}
}
}
-#endif
}
/* Given the out-of-ssa info object SA (with prepared partitions)
diff --git a/gcc/tree-parloops.c b/gcc/tree-parloops.c
index d017479..e6a1319 100644
--- a/gcc/tree-parloops.c
+++ b/gcc/tree-parloops.c
@@ -2748,9 +2748,8 @@ pass_parallelize_loops::execute (function *fun)
{
fun->curr_properties &= ~(PROP_gimple_eomp);
-#ifdef ENABLE_CHECKING
- verify_loop_structure ();
-#endif
+ if (CHECKING_P)
+ verify_loop_structure ();
return TODO_update_ssa;
}
diff --git a/gcc/tree-predcom.c b/gcc/tree-predcom.c
index ea0d30c..ceca0a9 100644
--- a/gcc/tree-predcom.c
+++ b/gcc/tree-predcom.c
@@ -896,13 +896,9 @@ suitable_component_p (struct loop *loop, struct component *comp)
if (!determine_offset (first->ref, a->ref, &a->offset))
return false;
-#ifdef ENABLE_CHECKING
- {
- enum ref_step_type a_step;
- ok = suitable_reference_p (a->ref, &a_step);
- gcc_assert (ok && a_step == comp->comp_step);
- }
-#endif
+ enum ref_step_type a_step;
+ gcc_checking_assert (suitable_reference_p (a->ref, &a_step)
+ && a_step == comp->comp_step);
}
/* If there is a write inside the component, we must know whether the
diff --git a/gcc/tree-profile.c b/gcc/tree-profile.c
index 4dcc58d..b5dd1d0 100644
--- a/gcc/tree-profile.c
+++ b/gcc/tree-profile.c
@@ -462,9 +462,8 @@ gimple_gen_const_delta_profiler (histogram_value value ATTRIBUTE_UNUSED,
unsigned base ATTRIBUTE_UNUSED)
{
/* FIXME implement this. */
-#ifdef ENABLE_CHECKING
- internal_error ("unimplemented functionality");
-#endif
+ if (CHECKING_P)
+ internal_error ("unimplemented functionality");
gcc_unreachable ();
}
diff --git a/gcc/tree-ssa-alias.c b/gcc/tree-ssa-alias.c
index 0445052..f7c740b 100644
--- a/gcc/tree-ssa-alias.c
+++ b/gcc/tree-ssa-alias.c
@@ -1443,11 +1443,9 @@ refs_may_alias_p_1 (ao_ref *ref1, ao_ref *ref2, bool tbaa_p)
tbaa_p);
/* We really do not want to end up here, but returning true is safe. */
-#ifdef ENABLE_CHECKING
- gcc_unreachable ();
-#else
+ if (CHECKING_P)
+ gcc_unreachable ();
return true;
-#endif
}
static bool
diff --git a/gcc/tree-ssa-live.c b/gcc/tree-ssa-live.c
index 4772558..598aa0d 100644
--- a/gcc/tree-ssa-live.c
+++ b/gcc/tree-ssa-live.c
@@ -51,7 +51,7 @@ along with GCC; see the file COPYING3. If not see
#include "cgraph.h"
#include "ipa-utils.h"
-#ifdef ENABLE_CHECKING
+#if CHECKING_P
static void verify_live_on_entry (tree_live_info_p);
#endif
@@ -1142,7 +1142,7 @@ calculate_live_ranges (var_map map, bool want_livein)
live_worklist (live);
-#ifdef ENABLE_CHECKING
+#if CHECKING_P
verify_live_on_entry (live);
#endif
@@ -1281,7 +1281,7 @@ debug (tree_live_info_d *ptr)
}
-#ifdef ENABLE_CHECKING
+#if CHECKING_P
/* Verify that SSA_VAR is a non-virtual SSA_NAME. */
void
diff --git a/gcc/tree-ssa-live.h b/gcc/tree-ssa-live.h
index 1f88358..9ba19fe 100644
--- a/gcc/tree-ssa-live.h
+++ b/gcc/tree-ssa-live.h
@@ -80,7 +80,7 @@ extern void remove_unused_locals (void);
extern void dump_var_map (FILE *, var_map);
extern void debug (_var_map &ref);
extern void debug (_var_map *ptr);
-#ifdef ENABLE_CHECKING
+#if CHECKING_P
extern void register_ssa_partition_check (tree ssa_var);
#endif
@@ -184,7 +184,7 @@ static inline void
register_ssa_partition (var_map map ATTRIBUTE_UNUSED,
tree ssa_var ATTRIBUTE_UNUSED)
{
-#if defined ENABLE_CHECKING
+#if CHECKING_P
register_ssa_partition_check (ssa_var);
#endif
}
diff --git a/gcc/tree-ssa-loop-ivcanon.c b/gcc/tree-ssa-loop-ivcanon.c
index eca70a9..bbd048f 100644
--- a/gcc/tree-ssa-loop-ivcanon.c
+++ b/gcc/tree-ssa-loop-ivcanon.c
@@ -1376,10 +1376,8 @@ tree_unroll_loops_completely (bool may_increase_size, bool unroll_outer)
/* Clean up the information about numbers of iterations, since
complete unrolling might have invalidated it. */
scev_reset ();
-#ifdef ENABLE_CHECKING
- if (loops_state_satisfies_p (LOOP_CLOSED_SSA))
+ if (CHECKING_P && loops_state_satisfies_p (LOOP_CLOSED_SSA))
verify_loop_closed_ssa (true);
-#endif
}
if (loop_closed_ssa_invalidated)
BITMAP_FREE (loop_closed_ssa_invalidated);
diff --git a/gcc/tree-ssa-loop-manip.c b/gcc/tree-ssa-loop-manip.c
index cb762df..e93c2b3 100644
--- a/gcc/tree-ssa-loop-manip.c
+++ b/gcc/tree-ssa-loop-manip.c
@@ -278,22 +278,22 @@ add_exit_phi (basic_block exit, tree var)
edge e;
edge_iterator ei;
-#ifdef ENABLE_CHECKING
/* Check that at least one of the edges entering the EXIT block exits
the loop, or a superloop of that loop, that VAR is defined in. */
- gimple def_stmt = SSA_NAME_DEF_STMT (var);
- basic_block def_bb = gimple_bb (def_stmt);
- FOR_EACH_EDGE (e, ei, exit->preds)
+ if (CHECKING_P)
{
- struct loop *aloop = find_common_loop (def_bb->loop_father,
- e->src->loop_father);
- if (!flow_bb_inside_loop_p (aloop, e->dest))
- break;
+ gimple def_stmt = SSA_NAME_DEF_STMT (var);
+ basic_block def_bb = gimple_bb (def_stmt);
+ FOR_EACH_EDGE (e, ei, exit->preds)
+ {
+ struct loop *aloop = find_common_loop (def_bb->loop_father,
+ e->src->loop_father);
+ if (!flow_bb_inside_loop_p (aloop, e->dest))
+ break;
+ }
+ gcc_checking_assert (e);
}
- gcc_checking_assert (e);
-#endif
-
phi = create_phi_node (NULL_TREE, exit);
create_new_def_for (var, phi, gimple_phi_result_ptr (phi));
FOR_EACH_EDGE (e, ei, exit->preds)
@@ -1274,11 +1274,12 @@ tree_transform_and_unroll_loop (struct loop *loop, unsigned factor,
gimple_cond_set_rhs (exit_if, exit_bound);
update_stmt (exit_if);
-#ifdef ENABLE_CHECKING
- verify_flow_info ();
- verify_loop_structure ();
- verify_loop_closed_ssa (true);
-#endif
+ if (CHECKING_P)
+ {
+ verify_flow_info ();
+ verify_loop_structure ();
+ verify_loop_closed_ssa (true);
+ }
}
/* Wrapper over tree_transform_and_unroll_loop for case we do not
diff --git a/gcc/tree-ssa-math-opts.c b/gcc/tree-ssa-math-opts.c
index eae5358..01d6f8df 100644
--- a/gcc/tree-ssa-math-opts.c
+++ b/gcc/tree-ssa-math-opts.c
@@ -554,10 +554,9 @@ pass_cse_reciprocals::execute (function *fun)
calculate_dominance_info (CDI_DOMINATORS);
calculate_dominance_info (CDI_POST_DOMINATORS);
-#ifdef ENABLE_CHECKING
- FOR_EACH_BB_FN (bb, fun)
- gcc_assert (!bb->aux);
-#endif
+ if (CHECKING_P)
+ FOR_EACH_BB_FN (bb, fun)
+ gcc_assert (!bb->aux);
for (arg = DECL_ARGUMENTS (fun->decl); arg; arg = DECL_CHAIN (arg))
if (FLOAT_TYPE_P (TREE_TYPE (arg))
diff --git a/gcc/tree-ssa-operands.c b/gcc/tree-ssa-operands.c
index b1e3f99..54139d8 100644
--- a/gcc/tree-ssa-operands.c
+++ b/gcc/tree-ssa-operands.c
@@ -882,12 +882,13 @@ get_expr_operands (struct function *fn, gimple stmt, tree *expr_p, int flags)
}
/* If we get here, something has gone wrong. */
-#ifdef ENABLE_CHECKING
- fprintf (stderr, "unhandled expression in get_expr_operands():\n");
- debug_tree (expr);
- fputs ("\n", stderr);
-#endif
- gcc_unreachable ();
+ if (CHECKING_P)
+ {
+ fprintf (stderr, "unhandled expression in get_expr_operands():\n");
+ debug_tree (expr);
+ fputs ("\n", stderr);
+ gcc_unreachable ();
+ }
}
diff --git a/gcc/tree-ssa-propagate.c b/gcc/tree-ssa-propagate.c
index b7684e0..630c19b 100644
--- a/gcc/tree-ssa-propagate.c
+++ b/gcc/tree-ssa-propagate.c
@@ -1501,14 +1501,14 @@ static void
replace_exp_1 (use_operand_p op_p, tree val,
bool for_propagation ATTRIBUTE_UNUSED)
{
-#if defined ENABLE_CHECKING
- tree op = USE_FROM_PTR (op_p);
-
- gcc_assert (!(for_propagation
- && TREE_CODE (op) == SSA_NAME
- && TREE_CODE (val) == SSA_NAME
- && !may_propagate_copy (op, val)));
-#endif
+ if (CHECKING_P)
+ {
+ tree op = USE_FROM_PTR (op_p);
+ gcc_assert (!(for_propagation
+ && TREE_CODE (op) == SSA_NAME
+ && TREE_CODE (val) == SSA_NAME
+ && !may_propagate_copy (op, val)));
+ }
if (TREE_CODE (val) == SSA_NAME)
SET_USE (op_p, val);
diff --git a/gcc/tree-ssa-structalias.c b/gcc/tree-ssa-structalias.c
index 4497919..8f3c2f2 100644
--- a/gcc/tree-ssa-structalias.c
+++ b/gcc/tree-ssa-structalias.c
@@ -2544,10 +2544,11 @@ rewrite_constraints (constraint_graph_t graph,
int i;
constraint_t c;
-#ifdef ENABLE_CHECKING
- for (unsigned int j = 0; j < graph->size; j++)
- gcc_assert (find (j) == j);
-#endif
+ if (CHECKING_P)
+ {
+ for (unsigned int j = 0; j < graph->size; j++)
+ gcc_assert (find (j) == j);
+ }
FOR_EACH_VEC_ELT (constraints, i, c)
{
diff --git a/gcc/tree-ssa-ter.c b/gcc/tree-ssa-ter.c
index f7ca95b..6b32814 100644
--- a/gcc/tree-ssa-ter.c
+++ b/gcc/tree-ssa-ter.c
@@ -182,7 +182,7 @@ typedef struct temp_expr_table_d
/* A place for the many, many bitmaps we create. */
static bitmap_obstack ter_bitmap_obstack;
-#ifdef ENABLE_CHECKING
+#if CHECKING_P
extern void debug_ter (FILE *, temp_expr_table_p);
#endif
@@ -233,16 +233,16 @@ free_temp_expr_table (temp_expr_table_p t)
{
bitmap ret = NULL;
-#ifdef ENABLE_CHECKING
- unsigned x;
- for (x = 0; x <= num_var_partitions (t->map); x++)
- gcc_assert (!t->kill_list[x]);
- for (x = 0; x < num_ssa_names; x++)
+ if (CHECKING_P)
{
- gcc_assert (t->expr_decl_uids[x] == NULL);
- gcc_assert (t->partition_dependencies[x] == NULL);
+ for (unsigned x = 0; x <= num_var_partitions (t->map); x++)
+ gcc_assert (!t->kill_list[x]);
+ for (unsigned x = 0; x < num_ssa_names; x++)
+ {
+ gcc_assert (t->expr_decl_uids[x] == NULL);
+ gcc_assert (t->partition_dependencies[x] == NULL);
+ }
}
-#endif
BITMAP_FREE (t->partition_in_use);
BITMAP_FREE (t->new_replaceable_dependencies);
@@ -749,7 +749,7 @@ dump_replaceable_exprs (FILE *f, bitmap expr)
}
-#ifdef ENABLE_CHECKING
+#if CHECKING_P
/* Dump the status of the various tables in the expression table. This is used
exclusively to debug TER. F is the place to send debug info and T is the
table being debugged. */
diff --git a/gcc/tree-ssa-threadupdate.c b/gcc/tree-ssa-threadupdate.c
index 5a5f8df..a760378 100644
--- a/gcc/tree-ssa-threadupdate.c
+++ b/gcc/tree-ssa-threadupdate.c
@@ -2487,9 +2487,8 @@ duplicate_thread_path (edge entry, edge exit,
scale_bbs_frequencies_int (region_copy, n_region, entry_freq, total_freq);
}
-#ifdef ENABLE_CHECKING
- verify_jump_thread (region_copy, n_region);
-#endif
+ if (CHECKING_P)
+ verify_jump_thread (region_copy, n_region);
/* Remove the last branch in the jump thread path. */
remove_ctrl_stmt_and_useless_edges (region_copy[n_region - 1], exit->dest);
diff --git a/gcc/tree-ssanames.c b/gcc/tree-ssanames.c
index 910cb19..43f8c9e 100644
--- a/gcc/tree-ssanames.c
+++ b/gcc/tree-ssanames.c
@@ -321,9 +321,8 @@ release_ssa_name_fn (struct function *fn, tree var)
if (MAY_HAVE_DEBUG_STMTS)
insert_debug_temp_for_var_def (NULL, var);
-#ifdef ENABLE_CHECKING
- verify_imm_links (stderr, var);
-#endif
+ if (CHECKING_P)
+ verify_imm_links (stderr, var);
while (imm->next != imm)
delink_imm_use (imm->next);
diff --git a/gcc/tree-stdarg.c b/gcc/tree-stdarg.c
index cd595a9..df871c0 100644
--- a/gcc/tree-stdarg.c
+++ b/gcc/tree-stdarg.c
@@ -1105,13 +1105,14 @@ expand_ifn_va_arg (function *fun)
if ((fun->curr_properties & PROP_gimple_lva) == 0)
expand_ifn_va_arg_1 (fun);
-#if ENABLE_CHECKING
+ if (! CHECKING_P)
+ return;
+
basic_block bb;
gimple_stmt_iterator i;
FOR_EACH_BB_FN (bb, fun)
for (i = gsi_start_bb (bb); !gsi_end_p (i); gsi_next (&i))
gcc_assert (!gimple_call_ifn_va_arg_p (gsi_stmt (i)));
-#endif
}
namespace {
diff --git a/gcc/tree-vect-loop-manip.c b/gcc/tree-vect-loop-manip.c
index 4feab78..6697db2 100644
--- a/gcc/tree-vect-loop-manip.c
+++ b/gcc/tree-vect-loop-manip.c
@@ -919,9 +919,8 @@ slpeel_tree_duplicate_loop_to_edge_cfg (struct loop *loop,
free (new_bbs);
free (bbs);
-#ifdef ENABLE_CHECKING
- verify_dominators (CDI_DOMINATORS);
-#endif
+ if (CHECKING_P)
+ verify_dominators (CDI_DOMINATORS);
return new_loop;
}
@@ -1003,8 +1002,7 @@ slpeel_can_duplicate_loop_p (const struct loop *loop, const_edge e)
return true;
}
-#ifdef ENABLE_CHECKING
-static void
+DEBUG_FUNCTION static void
slpeel_verify_cfg_after_peeling (struct loop *first_loop,
struct loop *second_loop)
{
@@ -1035,7 +1033,6 @@ slpeel_verify_cfg_after_peeling (struct loop *first_loop,
second_loop. */
/* TODO */
}
-#endif
/* If the run time cost model check determines that vectorization is
not profitable and hence scalar loop should be generated then set
@@ -1773,9 +1770,8 @@ vect_do_peeling_for_loop_bound (loop_vec_info loop_vinfo,
0, LOOP_VINFO_VECT_FACTOR (loop_vinfo));
gcc_assert (new_loop);
gcc_assert (loop_num == loop->num);
-#ifdef ENABLE_CHECKING
- slpeel_verify_cfg_after_peeling (loop, new_loop);
-#endif
+ if (CHECKING_P)
+ slpeel_verify_cfg_after_peeling (loop, new_loop);
/* A guard that controls whether the new_loop is to be executed or skipped
is placed in LOOP->exit. LOOP->exit therefore has two successors - one
@@ -2032,9 +2028,8 @@ vect_do_peeling_for_alignment (loop_vec_info loop_vinfo, tree ni_name,
bound, 0);
gcc_assert (new_loop);
-#ifdef ENABLE_CHECKING
- slpeel_verify_cfg_after_peeling (new_loop, loop);
-#endif
+ if (CHECKING_P)
+ slpeel_verify_cfg_after_peeling (new_loop, loop);
/* For vectorization factor N, we need to copy at most N-1 values
for alignment and this means N-2 loopback edge executions. */
max_iter = LOOP_VINFO_VECT_FACTOR (loop_vinfo) - 2;
diff --git a/gcc/tree-vrp.c b/gcc/tree-vrp.c
index 21fbed0..77e2315 100644
--- a/gcc/tree-vrp.c
+++ b/gcc/tree-vrp.c
@@ -254,9 +254,7 @@ static inline bool
supports_overflow_infinity (const_tree type)
{
tree min = vrp_val_min (type), max = vrp_val_max (type);
-#ifdef ENABLE_CHECKING
- gcc_assert (needs_overflow_infinity (type));
-#endif
+ gcc_checking_assert (needs_overflow_infinity (type));
return (min != NULL_TREE
&& CONSTANT_CLASS_P (min)
&& max != NULL_TREE
@@ -385,9 +383,9 @@ static void
set_value_range (value_range_t *vr, enum value_range_type t, tree min,
tree max, bitmap equiv)
{
-#if defined ENABLE_CHECKING
/* Check the validity of the range. */
- if (t == VR_RANGE || t == VR_ANTI_RANGE)
+ if (CHECKING_P
+ && (t == VR_RANGE || t == VR_ANTI_RANGE))
{
int cmp;
@@ -407,12 +405,12 @@ set_value_range (value_range_t *vr, enum value_range_type t, tree min,
|| !is_overflow_infinity (max));
}
- if (t == VR_UNDEFINED || t == VR_VARYING)
- gcc_assert (min == NULL_TREE && max == NULL_TREE);
-
- if (t == VR_UNDEFINED || t == VR_VARYING)
- gcc_assert (equiv == NULL || bitmap_empty_p (equiv));
-#endif
+ if (CHECKING_P
+ && (t == VR_UNDEFINED || t == VR_VARYING))
+ {
+ gcc_assert (min == NULL_TREE && max == NULL_TREE);
+ gcc_assert (equiv == NULL || bitmap_empty_p (equiv));
+ }
vr->type = t;
vr->min = min;
diff --git a/gcc/tree.c b/gcc/tree.c
index af3a6a3..c018bb7 100644
--- a/gcc/tree.c
+++ b/gcc/tree.c
@@ -5890,10 +5890,11 @@ free_lang_data_in_cgraph (void)
/* Traverse every type found freeing its language data. */
FOR_EACH_VEC_ELT (fld.types, i, t)
free_lang_data_in_type (t);
-#ifdef ENABLE_CHECKING
- FOR_EACH_VEC_ELT (fld.types, i, t)
- verify_type (t);
-#endif
+ if (CHECKING_P)
+ {
+ FOR_EACH_VEC_ELT (fld.types, i, t)
+ verify_type (t);
+ }
delete fld.pset;
fld.worklist.release ();
diff --git a/gcc/value-prof.c b/gcc/value-prof.c
index 324f3c8..2a6da41 100644
--- a/gcc/value-prof.c
+++ b/gcc/value-prof.c
@@ -230,9 +230,8 @@ gimple_remove_histogram_value (struct function *fun, gimple stmt,
hist2->hvalue.next = hist->hvalue.next;
}
free (hist->hvalue.counters);
-#ifdef ENABLE_CHECKING
- memset (hist, 0xab, sizeof (*hist));
-#endif
+ if (CHECKING_P)
+ memset (hist, 0xab, sizeof (*hist));
free (hist);
}
@@ -595,9 +594,8 @@ free_hist (void **slot, void *data ATTRIBUTE_UNUSED)
{
histogram_value hist = *(histogram_value *) slot;
free (hist->hvalue.counters);
-#ifdef ENABLE_CHECKING
- memset (hist, 0xab, sizeof (*hist));
-#endif
+ if (CHECKING_P)
+ memset (hist, 0xab, sizeof (*hist));
free (hist);
return 1;
}
diff --git a/gcc/var-tracking.c b/gcc/var-tracking.c
index cd394a0..54c7039 100644
--- a/gcc/var-tracking.c
+++ b/gcc/var-tracking.c
@@ -400,7 +400,7 @@ typedef const struct variable_def *const_variable;
/* Macro to access MEM_OFFSET as an HOST_WIDE_INT. Evaluates MEM twice. */
#define INT_MEM_OFFSET(mem) (MEM_OFFSET_KNOWN_P (mem) ? MEM_OFFSET (mem) : 0)
-#if ENABLE_CHECKING && (GCC_VERSION >= 2007)
+#if CHECKING_P && (GCC_VERSION >= 2007)
/* Access VAR's Ith part's offset, checking that it's not a one-part
variable. */
@@ -3572,7 +3572,7 @@ loc_cmp (rtx x, rtx y)
return 0;
}
-#if ENABLE_CHECKING
+#if CHECKING_P
/* Check the order of entries in one-part variables. */
int
@@ -3833,17 +3833,16 @@ canonicalize_values_star (variable_def **slot, dataflow_set *set)
else
gcc_unreachable ();
-#if ENABLE_CHECKING
- while (list)
- {
- if (list->offset == 0
- && (dv_as_opaque (list->dv) == dv_as_opaque (dv)
- || dv_as_opaque (list->dv) == dv_as_opaque (cdv)))
- gcc_unreachable ();
+ if (CHECKING_P)
+ while (list)
+ {
+ if (list->offset == 0
+ && (dv_as_opaque (list->dv) == dv_as_opaque (dv)
+ || dv_as_opaque (list->dv) == dv_as_opaque (cdv)))
+ gcc_unreachable ();
- list = list->next;
- }
-#endif
+ list = list->next;
+ }
}
}
@@ -6931,7 +6930,7 @@ compute_bb_dataflow (basic_block bb)
->traverse <dataflow_set *, canonicalize_values_mark> (out);
shared_hash_htab (out->vars)
->traverse <dataflow_set *, canonicalize_values_star> (out);
-#if ENABLE_CHECKING
+#if CHECKING_P
shared_hash_htab (out->vars)
->traverse <dataflow_set *, canonicalize_loc_order_check> (out);
#endif
@@ -7039,7 +7038,7 @@ vt_find_locations (void)
if (adjust)
{
dataflow_post_merge_adjust (in, &VTI (bb)->permp);
-#if ENABLE_CHECKING
+#if CHECKING_P
/* Merge and merge_adjust should keep entries in
canonical order. */
shared_hash_htab (in->vars)
@@ -9465,7 +9464,7 @@ vt_emit_notes (void)
again. */
dataflow_set_clear (&VTI (bb)->in);
}
-#ifdef ENABLE_CHECKING
+#if CHECKING_P
shared_hash_htab (cur.vars)
->traverse <variable_table_type *, emit_notes_for_differences_1>
(shared_hash_htab (empty_shared_hash));
diff --git a/libcpp/include/line-map.h b/libcpp/include/line-map.h
index bc747c1..e718fc2 100644
--- a/libcpp/include/line-map.h
+++ b/libcpp/include/line-map.h
@@ -272,7 +272,7 @@ struct GTY((tag ("2"))) line_map_macro : public line_map {
source_location expansion;
};
-#if defined ENABLE_CHECKING && (GCC_VERSION >= 2007)
+#if CHECKING_P && (GCC_VERSION >= 2007)
/* Assertion macro to be used in line-map code. */
#define linemap_assert(EXPR) \
diff --git a/libcpp/init.c b/libcpp/init.c
index 2d5626f..0419e95 100644
--- a/libcpp/init.c
+++ b/libcpp/init.c
@@ -535,7 +535,7 @@ cpp_init_builtins (cpp_reader *pfile, int hosted)
/* Sanity-checks are dependent on command-line options, so it is
called as a subroutine of cpp_read_main_file (). */
-#if ENABLE_CHECKING
+#if CHECKING_P
static void sanity_checks (cpp_reader *);
static void sanity_checks (cpp_reader *pfile)
{
diff --git a/libcpp/macro.c b/libcpp/macro.c
index 786c21b..0746c6d 100644
--- a/libcpp/macro.c
+++ b/libcpp/macro.c
@@ -73,7 +73,7 @@ struct macro_arg_token_iter
-ftrack-macro-expansion is used this location tracks loci across
macro expansion. */
const source_location *location_ptr;
-#ifdef ENABLE_CHECKING
+#if CHECKING_P
/* The number of times the iterator went forward. This useful only
when checking is enabled. */
size_t num_forwards;
@@ -1310,14 +1310,13 @@ set_arg_token (macro_arg *arg, const cpp_token *token,
if (loc != NULL)
{
-#ifdef ENABLE_CHECKING
- if (kind == MACRO_ARG_TOKEN_STRINGIFIED
- || !track_macro_exp_p)
+ if (CHECKING_P
+ && (kind == MACRO_ARG_TOKEN_STRINGIFIED
+ || !track_macro_exp_p))
/* We can't set the location of a stringified argument
token and we can't set any location if we aren't tracking
macro expansion locations. */
abort ();
-#endif
*loc = location;
}
}
@@ -1403,7 +1402,7 @@ macro_arg_token_iter_init (macro_arg_token_iter *iter,
iter->location_ptr = NULL;
if (track_macro_exp_p)
iter->location_ptr = get_arg_token_location (arg, kind);
-#ifdef ENABLE_CHECKING
+#if CHECKING_P
iter->num_forwards = 0;
if (track_macro_exp_p
&& token_ptr != NULL
@@ -1428,14 +1427,14 @@ macro_arg_token_iter_forward (macro_arg_token_iter *it)
it->location_ptr++;
break;
case MACRO_ARG_TOKEN_STRINGIFIED:
-#ifdef ENABLE_CHECKING
+#if CHECKING_P
if (it->num_forwards > 0)
abort ();
#endif
break;
}
-#ifdef ENABLE_CHECKING
+#if CHECKING_P
it->num_forwards++;
#endif
}
@@ -1444,7 +1443,7 @@ macro_arg_token_iter_forward (macro_arg_token_iter *it)
static const cpp_token *
macro_arg_token_iter_get_token (const macro_arg_token_iter *it)
{
-#ifdef ENABLE_CHECKING
+#if CHECKING_P
if (it->kind == MACRO_ARG_TOKEN_STRINGIFIED
&& it->num_forwards > 0)
abort ();
@@ -1458,7 +1457,7 @@ macro_arg_token_iter_get_token (const macro_arg_token_iter *it)
static source_location
macro_arg_token_iter_get_location (const macro_arg_token_iter *it)
{
-#ifdef ENABLE_CHECKING
+#if CHECKING_P
if (it->kind == MACRO_ARG_TOKEN_STRINGIFIED
&& it->num_forwards > 0)
abort ();
@@ -2144,11 +2143,11 @@ tokens_buff_add_token (_cpp_buff *buffer,
static void
alloc_expanded_arg_mem (cpp_reader *pfile, macro_arg *arg, size_t capacity)
{
-#ifdef ENABLE_CHECKING
- if (arg->expanded != NULL
- || arg->expanded_virt_locs != NULL)
+ if (CHECKING_P
+ && (arg->expanded != NULL
+ || arg->expanded_virt_locs != NULL))
abort ();
-#endif
+
arg->expanded = XNEWVEC (const cpp_token *, capacity);
if (CPP_OPTION (pfile, track_macro_expansion))
arg->expanded_virt_locs = XNEWVEC (source_location, capacity);
@@ -2709,10 +2708,8 @@ _cpp_backup_tokens (cpp_reader *pfile, unsigned int count)
{
macro_context *m = pfile->context->c.mc;
m->cur_virt_loc--;
-#ifdef ENABLE_CHECKING
- if (m->cur_virt_loc < m->virt_locs)
+ if (CHECKING_P && m->cur_virt_loc < m->virt_locs)
abort ();
-#endif
}
else
abort ();
diff --git a/libcpp/system.h b/libcpp/system.h
index b18d658..d50b67f 100644
--- a/libcpp/system.h
+++ b/libcpp/system.h
@@ -391,6 +391,14 @@ extern void abort (void);
#define __builtin_expect(a, b) (a)
#endif
+#ifdef ENABLE_CHECKING
+#define gcc_checking_assert(EXPR) gcc_assert (EXPR)
+#define CHECKING_P 1
+#else
+#define gcc_checking_assert(EXPR) ((void)(0 && (EXPR)))
+#define CHECKING_P 0
+#endif
+
/* Provide a fake boolean type. We make no attempt to use the
C99 _Bool, as it may not be available in the bootstrap compiler,
and even if it is, it is liable to be buggy.