OSDN Git Service

* targhooks.c (default_unwind_emit, default_scalar_mode_supported_p):
authornathan <nathan@138bc75d-0d04-0410-961f-82ee72b054a4>
Thu, 9 Sep 2004 07:54:12 +0000 (07:54 +0000)
committernathan <nathan@138bc75d-0d04-0410-961f-82ee72b054a4>
Thu, 9 Sep 2004 07:54:12 +0000 (07:54 +0000)
Use gcc_assert, gcc_unreachable & internal_error instead of abort.
* timevar.c (timevar_push, timevar_pop, timevar_start,
timevar_stop): Likewise.
* toplev.c (default_pch_valid_p): Likewise.
* tracer.c (tail_duplicate): Likewise.
* tree-alias-common.c (get_alias_var_decl,
get_values_from_constructor, create_alias_var, delete_alias_vars,
empty_points_to_set, same_points_to_set, ptr_may_alias_var):
Likewise.
* tree.c (tree_size, make_node_stat, copy_node_stat,
build_int_cst_wide, integer_all_onesp, list_length, chainon,
tree_node_structure, type_contains_placeholder_p, substitute_in_expr,
substitute_placeholder_in_expr, tabilize_reference_1, build0_stat,
build1_stat, build2_stat, build3_stat, build4_stat, is_attribute_p,
lookup_attribute, type_hash_canon, host_integerp, iterative_hash_expr,
build_method_type_directly, decl_type_context, get_callee_fndecl,
get_set_constructor_bits, build_vector_type_for_mode, int_cst_value,
tree_fold_gcd): Likewise.
* tree-cfg.c (create_bb, make_ctrl_stmt_edges, make_exit_edges,
make_cond_expr_edges, group_case_labels, tree_merge_blocks,
cleanup_control_expr_graph, find_taken_edge,
find_taken_edge_switch_expr, phi_alternatives_equal,
is_ctrl_altering_stmt, disband_implicit_edges, set_bb_for_stmt,
stmt_for_bsi, tree_find_edge_insert_loc, bsi_insert_on_edge_immediate,
tree_split_edge, tree_verify_flow_info, thread_jumps,
tree_redirect_edge_and_branch, tree_flow_call_edges_add): Likewise.
* tree-chrec.c (chrec_fold_poly_cst, chrec_fold_plus_poly_poly,
chrec_fold_multiply_poly_poly): Likewise.
* tree-complex.c (extract_component, expand_complex_division,
expand_complex_comparison, expand_complex_operations_1,
build_replicated_const, expand_vector_operations_1): Likewise.
* tree-data-ref.c (tree_fold_bezout, build_classic_dist_vector,
build_classic_dir_vector): Likewise.
* tree-dfa.c (compute_immediate_uses_for_phi,
compute_immediate_uses_for_stmt, create_var_ann, create_stmt_ann,
create_tree_ann, collect_dfa_stats, get_virtual_var): Likewise.
* tree-dump.c (dequeue_and_dump): Likewise.
* tree-eh.c (record_stmt_eh_region, add_stmt_to_eh_region,
record_in_finally_tree, replace_goto_queue_1,
maybe_record_in_goto_queue, verify_norecord_switch_expr,
do_return_redirection): Likewise.
* tree-if-conv.c (tree_if_convert_stmt, tree_if_convert_cond_expr,
add_to_dst_predicate_list, find_phi_replacement_condition,
replace_phi_with_cond_modify_expr, get_loop_body_in_if_conv_order):
Likewise.
* tree-inline.c (remap_decl, remap_type, remap_decls, copy_body_r,
initialize_inlined_parameters, declare_return_variable,
estimate_num_insns_1, expand_call_inline, expand_calls_inline,
optimize_inline_calls, copy_tree_r): Likewise.
* tree-into-ssa.c (rewrite_initialize_block_local_data, rewrite_stmt,
ssa_rewrite_stmt, rewrite_into_ssa): Likewise.
* tree-iterator.c (alloc_stmt_list, tsi_link_before, tsi_link_after,
tsi_split_statement_list_after, tsi_split_statement_list_before):
Likewise.
* tree-mudflap.c (mf_varname_tree): Likewise.
* tree-nested.c (create_tmp_var_for, lookup_field_for_decl,
lookup_tramp_for_decl, convert_all_function_calls): Likewise.
* tree-optimize.c (tree_rest_of_compilation): Likewise.
* tree-outof-ssa.c (create_temp, eliminate_build, eliminate_phi,
coalesce_abnormal_edges, coalesce_ssa_name, eliminate_virtual_phis,
free_temp_expr_table, add_dependance, finish_expr, rewrite_trees):
Likewise.
* tree-phinodes.c (resize_phi_node, add_phi_arg,
remove_all_phi_nodes_for): Likewise.
* tree-pretty-print.c (op_prio, print_call_name): Likewise.
* tree-profile.c (tree_gen_interval_profiler, tree_gen_pow2_profiler,
tree_gen_one_value_profiler, tree_gen_const_delta_profiler): Likewise.
* tree-sra.c (type_can_instantiate_all_elements, sra_hash_tree,
sra_elt_eq, sra_walk_expr, instantiate_missing_elements,
generate_one_element_ref, generate_element_copy,
generate_element_zero, scalarize_copy, scalarize_init,
scalarize_ldst): Likewise.
* tree-ssa-alias.c (delete_alias_info, group_aliases, may_alias_p,
add_may_alias, add_pointed_to_expr, add_pointed_to_var,
collect_points_to_info_r, get_tmt_for, get_ptr_info): Likewise.
* tree-ssa.c (walk_use_def_chains, check_phi_redundancy): Likewise.
* tree-ssa-ccp.c (dump_lattice_value, get_default_value, get_value,
set_lattice_value, likely_value, ccp_visit_phi_node, visit_assignment,
widen_bitfield, ccp_fold_builtin): Likewise.
* tree-ssa-copy.c (may_propagate_copy, merge_alias_info,
replace_exp_1, propagate_tree_value): Likewise.
* tree-ssa-copyrename.c (copy_rename_partition_coalesce): Likewise.
* tree-ssa-dce.c (set_control_dependence_map_bit,
find_control_dependence, find_pdom, mark_operand_necessary,
mark_stmt_if_obviously_necessary,
mark_control_dependent_edges_necessary, remove_dead_stmt): Likewise.
* tree-ssa-dom.c (dom_opt_initialize_block_local_data,
simplify_switch_and_lookup_avail_expr, cprop_into_successor_phis,
eliminate_redundant_computations, avail_expr_eq): Likewise.
* tree-ssa-dse.c (fix_stmt_v_may_defs): Likewise.
* tree-ssa-loop-ch.c (should_duplicate_loop_header_p,
duplicate_blocks): Likewise.
* tree-ssa-loop-im.c (for_each_index, set_level,
is_call_clobbered_ref): Likewise.
* tree-ssa-loop-ivopts.c (dump_use, divide, stmt_after_ip_normal_pos,
stmt_after_increment, set_iv, contains_abnormal_ssa_name_p,
find_interesting_uses_outer_or_nonlin, add_derived_ivs_candidates,
peel_address, ptr_difference_cost, may_replace_final_value,
determine_use_iv_cost, rewrite_use_nonlinear_expr, rewrite_use_outer,
rewrite_use, rewrite_uses): Likewise.
* tree-ssa-loop-manip.c (rewrite_into_loop_closed_ssa,
check_loop_closed_ssa_use): Likewise.
* tree-ssanames.c (make_ssa_name): Likewise.
* tree-ssa-operands.c (finalize_ssa_defs, finalize_ssa_uses,
finalize_ssa_v_must_defs, finalize_ssa_stmt_operands,
get_stmt_operands, get_expr_operands, get_asm_expr_operands,
get_indirect_ref_operands, add_stmt_operand): Likewise.
* tree-ssa-pre.c (value_exists_in_set_bitmap,
value_remove_from_set_bitmap, bitmap_insert_into_set, insert_into_set,
phi_translate, valid_in_set, compute_antic,
find_or_generate_expression, create_expression_by_pieces, insert_aux,
create_value_expr_from, eliminate): Likewise.
* tree-ssa-propagate.c (cfg_blocks_get): Likewise.
* tree-ssa-threadupdate.c (remove_last_stmt_and_useless_edges):
Likewise.
* tree-tailcall.c (independent_of_stmt_p, adjust_return_value,
eliminate_tail_call): Likewise.
* tree-vectorizer.c (vect_create_index_for_array_ref,
vect_align_data_ref, vect_create_data_ref,
vect_create_destination_var, vect_get_vec_def_for_operand,
vect_finish_stmt_generation, vect_transform_stmt,
vect_transform_loop_bound, vect_transform_loop,
vect_analyze_operations): Likewise.
* tree-vn.c (vn_compute, set_value_handle, get_value_handle):
Likewise.
* tree-flow-inline.h (var_ann, get_var_ann, get_def_from_ptr,
get_use_op_ptr, immediate_use, phi_ssa_name_p, bsi_start,
bsi_after_labels, bsi_last): Likewise.
* tree-ssa-live.c (var_union, change_partition_var,
create_ssa_var_map, calculate_live_on_entry, root_var_init,
type_var_init, add_coalesce, sort_coalesce_list, pop_best_coalesce):
Likewise.
* tree-ssa-live.h (partition_is_global, live_entry_blocks,
tpa_find_tree): Likewise.
(register_ssa_partition_check): Declare.
(register_ssa_partition): use it.
* tree-ssa-live.c: Include errors.h.
(register_ssa_partition_check): New.
* tree-ssa-operands.c: Include errors.h.
* Makefile.in (tree-ssa-operands.o): Depend on errors.h.

git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@87223 138bc75d-0d04-0410-961f-82ee72b054a4

50 files changed:
gcc/ChangeLog
gcc/Makefile.in
gcc/targhooks.c
gcc/timevar.c
gcc/toplev.c
gcc/tracer.c
gcc/tree-alias-common.c
gcc/tree-cfg.c
gcc/tree-chrec.c
gcc/tree-complex.c
gcc/tree-data-ref.c
gcc/tree-dfa.c
gcc/tree-dump.c
gcc/tree-eh.c
gcc/tree-flow-inline.h
gcc/tree-if-conv.c
gcc/tree-inline.c
gcc/tree-into-ssa.c
gcc/tree-iterator.c
gcc/tree-mudflap.c
gcc/tree-nested.c
gcc/tree-optimize.c
gcc/tree-outof-ssa.c
gcc/tree-phinodes.c
gcc/tree-pretty-print.c
gcc/tree-profile.c
gcc/tree-sra.c
gcc/tree-ssa-alias.c
gcc/tree-ssa-ccp.c
gcc/tree-ssa-copy.c
gcc/tree-ssa-copyrename.c
gcc/tree-ssa-dce.c
gcc/tree-ssa-dom.c
gcc/tree-ssa-dse.c
gcc/tree-ssa-live.c
gcc/tree-ssa-live.h
gcc/tree-ssa-loop-ch.c
gcc/tree-ssa-loop-im.c
gcc/tree-ssa-loop-ivopts.c
gcc/tree-ssa-loop-manip.c
gcc/tree-ssa-operands.c
gcc/tree-ssa-pre.c
gcc/tree-ssa-propagate.c
gcc/tree-ssa-threadupdate.c
gcc/tree-ssa.c
gcc/tree-ssanames.c
gcc/tree-tailcall.c
gcc/tree-vectorizer.c
gcc/tree-vn.c
gcc/tree.c

index e516085..b6050b3 100644 (file)
@@ -1,3 +1,148 @@
+2004-09-09  Giovanni Bajo  <giovannibajo@gcc.gnu.org>
+           Nathan Sidwell  <nathan@codesourcery.com>
+
+       * targhooks.c (default_unwind_emit, default_scalar_mode_supported_p):
+       Use gcc_assert, gcc_unreachable & internal_error instead of abort.
+       * timevar.c (timevar_push, timevar_pop, timevar_start,
+       timevar_stop): Likewise.
+       * toplev.c (default_pch_valid_p): Likewise.
+       * tracer.c (tail_duplicate): Likewise.
+       * tree-alias-common.c (get_alias_var_decl,
+       get_values_from_constructor, create_alias_var, delete_alias_vars,
+       empty_points_to_set, same_points_to_set, ptr_may_alias_var):
+       Likewise.
+       * tree.c (tree_size, make_node_stat, copy_node_stat,
+       build_int_cst_wide, integer_all_onesp, list_length, chainon,
+       tree_node_structure, type_contains_placeholder_p, substitute_in_expr,
+       substitute_placeholder_in_expr, tabilize_reference_1, build0_stat,
+       build1_stat, build2_stat, build3_stat, build4_stat, is_attribute_p,
+       lookup_attribute, type_hash_canon, host_integerp, iterative_hash_expr,
+       build_method_type_directly, decl_type_context, get_callee_fndecl,
+       get_set_constructor_bits, build_vector_type_for_mode, int_cst_value,
+       tree_fold_gcd): Likewise.
+       * tree-cfg.c (create_bb, make_ctrl_stmt_edges, make_exit_edges,
+       make_cond_expr_edges, group_case_labels, tree_merge_blocks,
+       cleanup_control_expr_graph, find_taken_edge,
+       find_taken_edge_switch_expr, phi_alternatives_equal,
+       is_ctrl_altering_stmt, disband_implicit_edges, set_bb_for_stmt,
+       stmt_for_bsi, tree_find_edge_insert_loc, bsi_insert_on_edge_immediate,
+       tree_split_edge, tree_verify_flow_info, thread_jumps,
+       tree_redirect_edge_and_branch, tree_flow_call_edges_add): Likewise.
+       * tree-chrec.c (chrec_fold_poly_cst, chrec_fold_plus_poly_poly,
+       chrec_fold_multiply_poly_poly): Likewise.
+       * tree-complex.c (extract_component, expand_complex_division,
+       expand_complex_comparison, expand_complex_operations_1,
+       build_replicated_const, expand_vector_operations_1): Likewise.
+       * tree-data-ref.c (tree_fold_bezout, build_classic_dist_vector,
+       build_classic_dir_vector): Likewise.
+       * tree-dfa.c (compute_immediate_uses_for_phi,
+       compute_immediate_uses_for_stmt, create_var_ann, create_stmt_ann,
+       create_tree_ann, collect_dfa_stats, get_virtual_var): Likewise.
+       * tree-dump.c (dequeue_and_dump): Likewise.
+       * tree-eh.c (record_stmt_eh_region, add_stmt_to_eh_region,
+       record_in_finally_tree, replace_goto_queue_1,
+       maybe_record_in_goto_queue, verify_norecord_switch_expr,
+       do_return_redirection): Likewise.
+       * tree-if-conv.c (tree_if_convert_stmt, tree_if_convert_cond_expr,
+       add_to_dst_predicate_list, find_phi_replacement_condition,
+       replace_phi_with_cond_modify_expr, get_loop_body_in_if_conv_order):
+       Likewise.
+       * tree-inline.c (remap_decl, remap_type, remap_decls, copy_body_r,
+       initialize_inlined_parameters, declare_return_variable,
+       estimate_num_insns_1, expand_call_inline, expand_calls_inline,
+       optimize_inline_calls, copy_tree_r): Likewise.
+       * tree-into-ssa.c (rewrite_initialize_block_local_data, rewrite_stmt,
+       ssa_rewrite_stmt, rewrite_into_ssa): Likewise.
+       * tree-iterator.c (alloc_stmt_list, tsi_link_before, tsi_link_after,
+       tsi_split_statement_list_after, tsi_split_statement_list_before):
+       Likewise.
+       * tree-mudflap.c (mf_varname_tree): Likewise.
+       * tree-nested.c (create_tmp_var_for, lookup_field_for_decl,
+       lookup_tramp_for_decl, convert_all_function_calls): Likewise.
+       * tree-optimize.c (tree_rest_of_compilation): Likewise.
+       * tree-outof-ssa.c (create_temp, eliminate_build, eliminate_phi,
+       coalesce_abnormal_edges, coalesce_ssa_name, eliminate_virtual_phis,
+       free_temp_expr_table, add_dependance, finish_expr, rewrite_trees):
+       Likewise.
+       * tree-phinodes.c (resize_phi_node, add_phi_arg,
+       remove_all_phi_nodes_for): Likewise.
+       * tree-pretty-print.c (op_prio, print_call_name): Likewise.
+       * tree-profile.c (tree_gen_interval_profiler, tree_gen_pow2_profiler,
+       tree_gen_one_value_profiler, tree_gen_const_delta_profiler): Likewise.
+       * tree-sra.c (type_can_instantiate_all_elements, sra_hash_tree,
+       sra_elt_eq, sra_walk_expr, instantiate_missing_elements,
+       generate_one_element_ref, generate_element_copy,
+       generate_element_zero, scalarize_copy, scalarize_init,
+       scalarize_ldst): Likewise.
+       * tree-ssa-alias.c (delete_alias_info, group_aliases, may_alias_p,
+       add_may_alias, add_pointed_to_expr, add_pointed_to_var,
+       collect_points_to_info_r, get_tmt_for, get_ptr_info): Likewise.
+       * tree-ssa.c (walk_use_def_chains, check_phi_redundancy): Likewise.
+       * tree-ssa-ccp.c (dump_lattice_value, get_default_value, get_value,
+       set_lattice_value, likely_value, ccp_visit_phi_node, visit_assignment,
+       widen_bitfield, ccp_fold_builtin): Likewise.
+       * tree-ssa-copy.c (may_propagate_copy, merge_alias_info,
+       replace_exp_1, propagate_tree_value): Likewise.
+       * tree-ssa-copyrename.c (copy_rename_partition_coalesce): Likewise.
+       * tree-ssa-dce.c (set_control_dependence_map_bit,
+       find_control_dependence, find_pdom, mark_operand_necessary,
+       mark_stmt_if_obviously_necessary,
+       mark_control_dependent_edges_necessary, remove_dead_stmt): Likewise.
+       * tree-ssa-dom.c (dom_opt_initialize_block_local_data,
+       simplify_switch_and_lookup_avail_expr, cprop_into_successor_phis,
+       eliminate_redundant_computations, avail_expr_eq): Likewise.
+       * tree-ssa-dse.c (fix_stmt_v_may_defs): Likewise.
+       * tree-ssa-loop-ch.c (should_duplicate_loop_header_p,
+       duplicate_blocks): Likewise.
+       * tree-ssa-loop-im.c (for_each_index, set_level,
+       is_call_clobbered_ref): Likewise.
+       * tree-ssa-loop-ivopts.c (dump_use, divide, stmt_after_ip_normal_pos,
+       stmt_after_increment, set_iv, contains_abnormal_ssa_name_p,
+       find_interesting_uses_outer_or_nonlin, add_derived_ivs_candidates,
+       peel_address, ptr_difference_cost, may_replace_final_value,
+       determine_use_iv_cost, rewrite_use_nonlinear_expr, rewrite_use_outer,
+       rewrite_use, rewrite_uses): Likewise.
+       * tree-ssa-loop-manip.c (rewrite_into_loop_closed_ssa,
+       check_loop_closed_ssa_use): Likewise.
+       * tree-ssanames.c (make_ssa_name): Likewise.
+       * tree-ssa-operands.c (finalize_ssa_defs, finalize_ssa_uses,
+       finalize_ssa_v_must_defs, finalize_ssa_stmt_operands,
+       get_stmt_operands, get_expr_operands, get_asm_expr_operands,
+       get_indirect_ref_operands, add_stmt_operand): Likewise.
+       * tree-ssa-pre.c (value_exists_in_set_bitmap,
+       value_remove_from_set_bitmap, bitmap_insert_into_set, insert_into_set,
+       phi_translate, valid_in_set, compute_antic,
+       find_or_generate_expression, create_expression_by_pieces, insert_aux,
+       create_value_expr_from, eliminate): Likewise.
+       * tree-ssa-propagate.c (cfg_blocks_get): Likewise.
+       * tree-ssa-threadupdate.c (remove_last_stmt_and_useless_edges):
+       Likewise.
+       * tree-tailcall.c (independent_of_stmt_p, adjust_return_value,
+       eliminate_tail_call): Likewise.
+       * tree-vectorizer.c (vect_create_index_for_array_ref,
+       vect_align_data_ref, vect_create_data_ref,
+       vect_create_destination_var, vect_get_vec_def_for_operand,
+       vect_finish_stmt_generation, vect_transform_stmt,
+       vect_transform_loop_bound, vect_transform_loop,
+       vect_analyze_operations): Likewise.
+       * tree-vn.c (vn_compute, set_value_handle, get_value_handle):
+       Likewise.
+       * tree-flow-inline.h (var_ann, get_var_ann, get_def_from_ptr,
+       get_use_op_ptr, immediate_use, phi_ssa_name_p, bsi_start,
+       bsi_after_labels, bsi_last): Likewise.
+       * tree-ssa-live.c (var_union, change_partition_var,
+       create_ssa_var_map, calculate_live_on_entry, root_var_init,
+       type_var_init, add_coalesce, sort_coalesce_list, pop_best_coalesce):
+       Likewise.
+       * tree-ssa-live.h (partition_is_global, live_entry_blocks,
+       tpa_find_tree): Likewise.
+       (register_ssa_partition_check): Declare.
+       (register_ssa_partition): use it.
+       * tree-ssa-live.c: Include errors.h.
+       (register_ssa_partition_check): New.
+       * tree-ssa-operands.c: Include errors.h.
+       * Makefile.in (tree-ssa-operands.o): Depend on errors.h.
+
 2004-09-09  Richard Sandiford  <rsandifo@redhat.com>
            Catherine Moore  <clm@redhat.com>
 
index e76aa11..995952a 100644 (file)
@@ -1700,7 +1700,7 @@ tree-dfa.o : tree-dfa.c $(TREE_FLOW_H) $(CONFIG_H) $(SYSTEM_H) \
    tree-alias-common.h convert.h $(TM_H) coretypes.h langhooks.h \
    $(TREE_DUMP_H) tree-pass.h params.h
 tree-ssa-operands.o : tree-ssa-operands.c $(TREE_FLOW_H) $(CONFIG_H) \
-   $(SYSTEM_H) $(TREE_H) $(TM_P_H) $(GGC_H) diagnostic.h \
+   $(SYSTEM_H) $(TREE_H) $(TM_P_H) $(GGC_H) diagnostic.h errors.h \
    tree-inline.h $(FLAGS_H) function.h $(TM_H) $(TIMEVAR_H) tree-pass.h
 tree-eh.o : tree-eh.c $(TREE_FLOW_H) $(CONFIG_H) $(SYSTEM_H) \
    $(RTL_H) $(TREE_H) $(TM_H) $(FLAGS_H) function.h except.h langhooks.h \
index 042c83e..95a4909 100644 (file)
@@ -213,7 +213,7 @@ default_unwind_emit (FILE * stream ATTRIBUTE_UNUSED,
                     rtx insn ATTRIBUTE_UNUSED)
 {
   /* Should never happen.  */
-  abort ();
+  gcc_unreachable ();
 }
 
 /* True if MODE is valid for the target.  By "valid", we mean able to
@@ -258,7 +258,7 @@ default_scalar_mode_supported_p (enum machine_mode mode)
       return false;
 
     default:
-      abort ();
+      gcc_unreachable ();
     }
 }
 
index 1b5d244..65323eb 100644 (file)
@@ -263,8 +263,7 @@ timevar_push (timevar_id_t timevar)
   tv->used = 1;
 
   /* Can't push a standalone timer.  */
-  if (tv->standalone)
-    abort ();
+  gcc_assert (!tv->standalone);
 
   /* What time is it?  */
   get_time (&now);
@@ -309,13 +308,8 @@ timevar_pop (timevar_id_t timevar)
   if (!timevar_enable)
     return;
 
-  if (&timevars[timevar] != stack->timevar)
-    {
-      sorry ("cannot timevar_pop '%s' when top of timevars stack is '%s'",
-             timevars[timevar].name, stack->timevar->name);
-      abort ();
-    }
-
+  gcc_assert (&timevars[timevar] == stack->timevar);
+  
   /* What time is it?  */
   get_time (&now);
 
@@ -352,8 +346,7 @@ timevar_start (timevar_id_t timevar)
 
   /* Don't allow the same timing variable to be started more than
      once.  */
-  if (tv->standalone)
-    abort ();
+  gcc_assert (!tv->standalone);
   tv->standalone = 1;
 
   get_time (&tv->start_time);
@@ -372,8 +365,7 @@ timevar_stop (timevar_id_t timevar)
     return;
 
   /* TIMEVAR must have been started via timevar_start.  */
-  if (!tv->standalone)
-    abort ();
+  gcc_assert (tv->standalone);
 
   get_time (&now);
   timevar_accumulate (&tv->elapsed, &tv->start_time, &now);
index d83d6c5..b0a297b 100644 (file)
@@ -1502,7 +1502,7 @@ default_pch_valid_p (const void *data_p, size_t len)
              goto make_message;
            }
        }
-      abort ();
+      gcc_unreachable ();
     }
   data += sizeof (target_flags);
   len -= sizeof (target_flags);
index dd263c4..4fcedca 100644 (file)
@@ -247,8 +247,7 @@ tail_duplicate (void)
 
       if (ignore_bb_p (bb))
        continue;
-      if (seen (bb))
-       abort ();
+      gcc_assert (!seen (bb));
 
       n = find_trace (bb, trace);
 
index fa47ce6..21b8b49 100644 (file)
@@ -139,8 +139,7 @@ static alias_var
 get_alias_var_decl (tree decl)
 {
   alias_var newvar;
-  if (TREE_CODE (decl) == FIELD_DECL)
-    abort ();
+  gcc_assert (TREE_CODE (decl) != FIELD_DECL);
   if (DECL_P (decl))
     {
       if (DECL_PTA_ALIASVAR (decl))
@@ -361,7 +360,7 @@ get_values_from_constructor (tree constructor, varray_type *vals,
        }
       break;
     default:
-      abort();
+      gcc_unreachable ();
     }
 }
 
@@ -944,14 +943,10 @@ create_alias_var (tree decl)
 {
   alias_var avar;
 
-  if (!DECL_P (decl))
-    abort ();
+  gcc_assert (DECL_P (decl));
   
-  if (DECL_P (decl))
-    {
-      if (DECL_PTA_ALIASVAR (decl))
-       return DECL_PTA_ALIASVAR (decl);
-    }
+  if (DECL_PTA_ALIASVAR (decl))
+    return DECL_PTA_ALIASVAR (decl);
 
   if (POINTER_TYPE_P (TREE_TYPE (decl))
       && TREE_CODE (TREE_TYPE (TREE_TYPE (decl))) == FUNCTION_TYPE)
@@ -1067,10 +1062,8 @@ delete_alias_vars (void)
   for (i = 0; i < VARRAY_ACTIVE_SIZE (local_alias_vars); i++)
     {
       tree key = VARRAY_TREE (local_alias_vars, i);
-      if (DECL_P (key))
-       DECL_PTA_ALIASVAR (key) = NULL;
-      else
-       abort ();
+      gcc_assert (DECL_P (key));
+      DECL_PTA_ALIASVAR (key) = NULL;
     }
 
   for (i = 0; i < VARRAY_ACTIVE_SIZE (local_alias_varnums); i ++)
@@ -1130,14 +1123,10 @@ empty_points_to_set (tree ptr)
     ptr = TREE_OPERAND (ptr, 1);
 #endif
 
-  if (DECL_P (ptr))
-    {
-      ptrtv = DECL_PTA_ALIASVAR (ptr);
-      if (!ptrtv)
-       return true;
-    }
-  else
-    abort ();
+  gcc_assert (DECL_P (ptr));
+  ptrtv = DECL_PTA_ALIASVAR (ptr);
+  if (!ptrtv)
+    return true;
 
   return current_alias_ops->empty_points_to_set (current_alias_ops, ptrtv);
 }
@@ -1160,23 +1149,15 @@ same_points_to_set (tree ptr, tree var)
   if (ptr == var)
     return true;
 
-  if (DECL_P (ptr))
-    {
-      ptrtv = DECL_PTA_ALIASVAR (ptr);
-      if (!ptrtv)
-       return false;
-    }
-  else
-    abort ();
+  gcc_assert (DECL_P (ptr));
+  ptrtv = DECL_PTA_ALIASVAR (ptr);
+  if (!ptrtv)
+    return false;
 
-  if (DECL_P (var))
-    {
-      vartv = DECL_PTA_ALIASVAR (var);
-      if (!vartv)
-       return false;
-    }
-  else
-    abort ();
+  gcc_assert (DECL_P (var));
+  vartv = DECL_PTA_ALIASVAR (var);
+  if (!vartv)
+    return false;
 
   return current_alias_ops->same_points_to_set (current_alias_ops, vartv, ptrtv);
 }
@@ -1200,23 +1181,15 @@ ptr_may_alias_var (tree ptr, tree var)
   if (ptr == var)
     return true;
 
-  if (DECL_P (ptr))
-    {
-      ptrtv = DECL_PTA_ALIASVAR (ptr);
-      if (!ptrtv)
-       return false;
-    }
-  else
-    abort ();
+  gcc_assert (DECL_P (ptr));
+  ptrtv = DECL_PTA_ALIASVAR (ptr);
+  if (!ptrtv)
+    return false;
 
-  if (DECL_P (var))
-    {
-      vartv = DECL_PTA_ALIASVAR (var);
-      if (!vartv)
-       return false;
-    }
-  else
-    abort ();
+  gcc_assert (DECL_P (var));
+  vartv = DECL_PTA_ALIASVAR (var);
+  if (!vartv)
+    return false;
 
   return current_alias_ops->may_alias (current_alias_ops, ptrtv, vartv);
 }
index ce0be96..9452dff 100644 (file)
@@ -294,8 +294,7 @@ static void
 create_block_annotation (basic_block bb)
 {
   /* Verify that the tree_annotations field is clear.  */
-  if (bb->tree_annotations)
-    abort ();
+  gcc_assert (!bb->tree_annotations);
   bb->tree_annotations = ggc_alloc_cleared (sizeof (struct bb_ann_d));
 }
 
@@ -374,8 +373,7 @@ create_bb (void *h, void *e, basic_block after)
 {
   basic_block bb;
 
-  if (e)
-    abort ();
+  gcc_assert (!e);
 
   /* Create and initialize a new basic block.  */
   bb = alloc_block ();
@@ -462,11 +460,7 @@ make_ctrl_stmt_edges (basic_block bb)
 {
   tree last = last_stmt (bb);
 
-#if defined ENABLE_CHECKING
-  if (last == NULL_TREE)
-    abort();
-#endif
-
+  gcc_assert (last);
   switch (TREE_CODE (last))
     {
     case GOTO_EXPR:
@@ -493,7 +487,7 @@ make_ctrl_stmt_edges (basic_block bb)
       break;
 
     default:
-      abort ();
+      gcc_unreachable ();
     }
 }
 
@@ -507,9 +501,7 @@ make_exit_edges (basic_block bb)
 {
   tree last = last_stmt (bb), op;
 
-  if (last == NULL_TREE)
-    abort ();
-
+  gcc_assert (last);
   switch (TREE_CODE (last))
     {
     case CALL_EXPR:
@@ -555,7 +547,7 @@ make_exit_edges (basic_block bb)
       break;
 
     default:
-      abort ();
+      gcc_unreachable ();
     }
 }
 
@@ -570,10 +562,8 @@ make_cond_expr_edges (basic_block bb)
   basic_block then_bb, else_bb;
   tree then_label, else_label;
 
-#if defined ENABLE_CHECKING
-  if (entry == NULL_TREE || TREE_CODE (entry) != COND_EXPR)
-    abort ();
-#endif
+  gcc_assert (entry);
+  gcc_assert (TREE_CODE (entry) == COND_EXPR);
 
   /* Entry basic blocks for each component.  */
   then_label = GOTO_DESTINATION (COND_EXPR_THEN (entry));
@@ -955,9 +945,7 @@ group_case_labels (void)
              tree base_case, base_label, base_high, type;
              base_case = TREE_VEC_ELT (labels, i);
 
-             if (! base_case)
-               abort ();
-
+             gcc_assert (base_case);
              base_label = CASE_LABEL (base_case);
 
              /* Discard cases that have the same destination as the
@@ -1080,12 +1068,8 @@ tree_merge_blocks (basic_block a, basic_block b)
   /* Ensure that B follows A.  */
   move_block_after (b, a);
 
-  if (!(a->succ->flags & EDGE_FALLTHRU))
-    abort ();
-
-  if (last_stmt (a)
-      && stmt_ends_bb_p (last_stmt (a)))
-    abort ();
+  gcc_assert (a->succ->flags & EDGE_FALLTHRU);
+  gcc_assert (!last_stmt (a) || !stmt_ends_bb_p (last_stmt (a)));
 
   /* Remove labels from B and set bb_for_stmt to A for other statements.  */
   for (bsi = bsi_start (b); !bsi_end_p (bsi);)
@@ -1964,7 +1948,7 @@ cleanup_control_expr_graph (basic_block bb, block_stmt_iterator bsi)
          break;
 
        default:
-         abort ();
+         gcc_unreachable ();
        }
 
       taken_edge = find_taken_edge (bb, val);
@@ -2011,10 +1995,8 @@ find_taken_edge (basic_block bb, tree val)
 
   stmt = last_stmt (bb);
 
-#if defined ENABLE_CHECKING
-  if (stmt == NULL_TREE || !is_ctrl_stmt (stmt))
-    abort ();
-#endif
+  gcc_assert (stmt);
+  gcc_assert (is_ctrl_stmt (stmt));
 
   /* If VAL is a predicate of the form N RELOP N, where N is an
      SSA_NAME, we can always determine its truth value (except when
@@ -2097,8 +2079,7 @@ find_taken_edge_switch_expr (basic_block bb, tree val)
   dest_bb = label_to_block (CASE_LABEL (taken_case));
 
   e = find_edge (bb, dest_bb);
-  if (!e)
-    abort ();
+  gcc_assert (e);
   return e;
 }
 
@@ -2161,10 +2142,8 @@ phi_alternatives_equal (basic_block dest, edge e1, edge e2)
       n1 = phi_arg_from_edge (phi, e1);
       n2 = phi_arg_from_edge (phi, e2);
 
-#ifdef ENABLE_CHECKING
-      if (n1 < 0 || n2 < 0)
-       abort ();
-#endif
+      gcc_assert (n1 >= 0);
+      gcc_assert (n2 >= 0);
 
       val1 = PHI_ARG_DEF (phi, n1);
       val2 = PHI_ARG_DEF (phi, n2);
@@ -2430,11 +2409,7 @@ is_ctrl_altering_stmt (tree t)
 {
   tree call;
 
-#if defined ENABLE_CHECKING
-  if (t == NULL)
-    abort ();
-#endif
-
+  gcc_assert (t);
   call = get_call_expr_in (t);
   if (call)
     {
@@ -2556,7 +2531,7 @@ disband_implicit_edges (void)
              else if (e->flags & EDGE_FALSE_VALUE)
                COND_EXPR_ELSE (stmt) = build_empty_stmt ();
              else
-               abort ();
+               gcc_unreachable ();
              e->flags |= EDGE_FALLTHRU;
            }
 
@@ -2567,10 +2542,9 @@ disband_implicit_edges (void)
        {
          /* Remove the RETURN_EXPR if we may fall though to the exit
             instead.  */
-         if (!bb->succ
-             || bb->succ->succ_next
-             || bb->succ->dest != EXIT_BLOCK_PTR)
-           abort ();
+         gcc_assert (bb->succ);
+         gcc_assert (!bb->succ->succ_next);
+         gcc_assert (bb->succ->dest == EXIT_BLOCK_PTR);
 
          if (bb->next_bb == EXIT_BLOCK_PTR
              && !TREE_OPERAND (stmt, 0))
@@ -2594,9 +2568,7 @@ disband_implicit_edges (void)
       if (!e || e->dest == bb->next_bb)
        continue;
 
-      if (e->dest == EXIT_BLOCK_PTR)
-       abort ();
-
+      gcc_assert (e->dest != EXIT_BLOCK_PTR);
       label = tree_block_label (e->dest);
 
       stmt = build1 (GOTO_EXPR, void_type_node, label);
@@ -2720,14 +2692,9 @@ set_bb_for_stmt (tree t, basic_block bb)
                VARRAY_GROW (label_to_block_map, 3 * uid / 2);
            }
          else
-           {
-#ifdef ENABLE_CHECKING
-             /* We're moving an existing label.  Make sure that we've
-                removed it from the old block.  */
-             if (bb && VARRAY_BB (label_to_block_map, uid))
-               abort ();
-#endif
-           }
+           /* We're moving an existing label.  Make sure that we've
+               removed it from the old block.  */
+           gcc_assert (!bb || !VARRAY_BB (label_to_block_map, uid));
          VARRAY_BB (label_to_block_map, uid) = bb;
        }
     }
@@ -2744,7 +2711,7 @@ stmt_for_bsi (tree stmt)
     if (bsi_stmt (bsi) == stmt)
       return bsi;
 
-  abort ();
+  gcc_unreachable ();
 }
 
 /* Insert statement (or statement list) T before the statement
@@ -2926,8 +2893,7 @@ tree_find_edge_insert_loc (edge e, block_stmt_iterator *bsi,
          tree op = TREE_OPERAND (tmp, 0);
          if (!is_gimple_val (op))
            {
-             if (TREE_CODE (op) != MODIFY_EXPR)
-               abort ();
+             gcc_assert (TREE_CODE (op) == MODIFY_EXPR);
              bsi_insert_before (bsi, op, BSI_NEW_STMT);
              TREE_OPERAND (tmp, 0) = TREE_OPERAND (op, 0);
            }
@@ -3009,8 +2975,7 @@ bsi_insert_on_edge_immediate (edge e, tree stmt)
   block_stmt_iterator bsi;
   basic_block new_bb = NULL;
 
-  if (PENDING_STMT (e))
-    abort ();
+  gcc_assert (!PENDING_STMT (e));
 
   if (tree_find_edge_insert_loc (e, &bsi, &new_bb))
     bsi_insert_after (&bsi, stmt, BSI_NEW_STMT);
@@ -3036,8 +3001,7 @@ tree_split_edge (edge edge_in)
   int i, num_elem;
 
   /* Abnormal edges cannot be split.  */
-  if (edge_in->flags & EDGE_ABNORMAL)
-    abort ();
+  gcc_assert (!(edge_in->flags & EDGE_ABNORMAL));
 
   src = edge_in->src;
   dest = edge_in->dest;
@@ -3070,11 +3034,9 @@ tree_split_edge (edge edge_in)
          }
     }
 
-  if (!redirect_edge_and_branch (edge_in, new_bb))
-    abort ();
-
-  if (PENDING_STMT (edge_in))
-    abort ();
+  e = redirect_edge_and_branch (edge_in, new_bb);
+  gcc_assert (e);
+  gcc_assert (!PENDING_STMT (edge_in));
 
   return new_bb;
 }
@@ -3655,8 +3617,7 @@ tree_verify_flow_info (void)
                tree lab = CASE_LABEL (TREE_VEC_ELT (vec, i));
                basic_block label_bb = label_to_block (lab);
 
-               if (label_bb->aux && label_bb->aux != (void *)1)
-                 abort ();
+               gcc_assert (!label_bb->aux || label_bb->aux == (void *)1);
                label_bb->aux = (void *)1;
              }
 
@@ -3962,8 +3923,7 @@ thread_jumps (void)
              for (phi = phi_nodes (dest); phi; phi = PHI_CHAIN (phi))
                {
                  arg = phi_arg_from_edge (phi, last);
-                 if (arg < 0)
-                   abort ();
+                 gcc_assert (arg >= 0);
                  add_phi_arg (&phi, PHI_ARG_DEF (phi, arg), e);
                }
            }
@@ -4130,7 +4090,7 @@ tree_redirect_edge_and_branch (edge e, basic_block dest)
     case GOTO_EXPR:
       /* No non-abnormal edges should lead from a non-simple goto, and
         simple ones should be represented implicitly.  */
-      abort ();
+      gcc_unreachable ();
 
     case SWITCH_EXPR:
       {
@@ -4154,8 +4114,7 @@ tree_redirect_edge_and_branch (edge e, basic_block dest)
     default:
       /* Otherwise it must be a fallthru edge, and we don't need to
         do anything besides redirecting it.  */
-      if (!(e->flags & EDGE_FALLTHRU))
-       abort ();
+      gcc_assert (e->flags & EDGE_FALLTHRU);
       break;
     }
 
@@ -4174,8 +4133,7 @@ static basic_block
 tree_redirect_edge_and_branch_force (edge e, basic_block dest)
 {
   e = tree_redirect_edge_and_branch (e, dest);
-  if (!e)
-    abort ();
+  gcc_assert (e);
 
   return NULL;
 }
@@ -4650,8 +4608,7 @@ tree_flow_call_edges_add (sbitmap blocks)
 #ifdef ENABLE_CHECKING
                  if (stmt == last_stmt)
                    for (e = bb->succ; e; e = e->succ_next)
-                     if (e->dest == EXIT_BLOCK_PTR)
-                       abort ();
+                     gcc_assert (e->dest != EXIT_BLOCK_PTR);
 #endif
 
                  /* Note that the following may create a new basic block
index d16522f..0929f69 100644 (file)
@@ -56,13 +56,10 @@ chrec_fold_poly_cst (enum tree_code code,
                     tree poly, 
                     tree cst)
 {
-#if defined ENABLE_CHECKING
-  if (poly == NULL_TREE
-      || cst == NULL_TREE
-      || TREE_CODE (poly) != POLYNOMIAL_CHREC
-      || is_not_constant_evolution (cst))
-    abort ();
-#endif
+  gcc_assert (poly);
+  gcc_assert (cst);
+  gcc_assert (TREE_CODE (poly) == POLYNOMIAL_CHREC);
+  gcc_assert (!is_not_constant_evolution (cst));
   
   switch (code)
     {
@@ -98,14 +95,11 @@ chrec_fold_plus_poly_poly (enum tree_code code,
                           tree poly1)
 {
   tree left, right;
-  
-#if defined ENABLE_CHECKING
-  if (poly0 == NULL_TREE
-      || poly1 == NULL_TREE
-      || TREE_CODE (poly0) != POLYNOMIAL_CHREC
-      || TREE_CODE (poly1) != POLYNOMIAL_CHREC)
-    abort ();
-#endif
+
+  gcc_assert (poly0);
+  gcc_assert (poly1);
+  gcc_assert (TREE_CODE (poly0) == POLYNOMIAL_CHREC);
+  gcc_assert (TREE_CODE (poly1) == POLYNOMIAL_CHREC);
   
   /*
     {a, +, b}_1 + {c, +, d}_2  ->  {{a, +, b}_1 + c, +, d}_2,
@@ -171,13 +165,10 @@ chrec_fold_multiply_poly_poly (tree type,
                               tree poly0, 
                               tree poly1)
 {
-#if defined ENABLE_CHECKING
-  if (poly0 == NULL_TREE
-      || poly1 == NULL_TREE
-      || TREE_CODE (poly0) != POLYNOMIAL_CHREC
-      || TREE_CODE (poly1) != POLYNOMIAL_CHREC)
-    abort ();
-#endif
+  gcc_assert (poly0);
+  gcc_assert (poly1);
+  gcc_assert (TREE_CODE (poly0) == POLYNOMIAL_CHREC);
+  gcc_assert (TREE_CODE (poly1) == POLYNOMIAL_CHREC);
   
   /* {a, +, b}_1 * {c, +, d}_2  ->  {c*{a, +, b}_1, +, d}_2,
      {a, +, b}_2 * {c, +, d}_1  ->  {a*{c, +, d}_1, +, b}_2,
index d0c6c63..363e3a2 100644 (file)
@@ -64,7 +64,7 @@ extract_component (block_stmt_iterator *bsi, tree t, bool imagpart_p)
       break;
 
     default:
-      abort ();
+      gcc_unreachable ();
     }
 
   return gimplify_val (bsi, inner_type, ret);
@@ -285,7 +285,7 @@ expand_complex_division (block_stmt_iterator *bsi, tree inner_type,
       break;
     default:
       /* C99-like requirements for complex divide (not yet implemented).  */
-      abort ();
+      gcc_unreachable ();
     }
 }
 
@@ -349,7 +349,7 @@ expand_complex_comparison (block_stmt_iterator *bsi, tree ar, tree ai,
       TREE_OPERAND (stmt, 0) = cc;
       break;
     default:
-      abort ();
+      gcc_unreachable ();
     }
 
   modify_stmt (stmt);
@@ -472,7 +472,7 @@ expand_complex_operations_1 (block_stmt_iterator *bsi)
       break;
 
     default:
-      abort ();
+      gcc_unreachable ();
     }
 }
 \f
@@ -486,8 +486,7 @@ build_replicated_const (tree type, tree inner_type, HOST_WIDE_INT value)
   unsigned HOST_WIDE_INT low, high, mask;
   tree ret;
 
-  if (n == 0)
-    abort ();
+  gcc_assert (n);
 
   if (width == HOST_BITS_PER_WIDE_INT)
     low = value;
@@ -504,7 +503,7 @@ build_replicated_const (tree type, tree inner_type, HOST_WIDE_INT value)
   else if (TYPE_PRECISION (type) == 2 * HOST_BITS_PER_WIDE_INT)
     high = low;
   else
-    abort ();
+    gcc_unreachable ();
 
   ret = build_int_cst_wide (type, low, high);
   return ret;
@@ -783,10 +782,8 @@ expand_vector_operations_1 (block_stmt_iterator *bsi)
 
   if (code == NOP_EXPR || code == VIEW_CONVERT_EXPR)
     return;
-
-  if (code == CONVERT_EXPR)
-    abort ();
-
+  
+  gcc_assert (code != CONVERT_EXPR);
   op = optab_for_tree_code (code, type);
 
   /* Optabs will try converting a negation into a subtraction, so
index 57f20bb..db5dea6 100644 (file)
@@ -270,21 +270,19 @@ tree_fold_bezout (tree a1,
       zs2 = fold (build (MULT_EXPR, integer_type_node, z, s2));
       
       /* row1 -= z * row2.  */
+      gcc_assert (sign != 0);
       if (sign < 0)
        {
          *u11 = fold (build (PLUS_EXPR, integer_type_node, *u11, zu21));
          *u12 = fold (build (PLUS_EXPR, integer_type_node, *u12, zu22));
          s1 = fold (build (PLUS_EXPR, integer_type_node, s1, zs2));
        }
-      else if (sign > 0)
+      else
        {
          *u11 = fold (build (MINUS_EXPR, integer_type_node, *u11, zu21));
          *u12 = fold (build (MINUS_EXPR, integer_type_node, *u12, zu22));
          s1 = fold (build (MINUS_EXPR, integer_type_node, s1, zs2));
        }
-      else
-       /* Should not happen.  */
-       abort ();
       
       /* Interchange row1 and row2.  */
       {
@@ -1466,8 +1464,8 @@ build_classic_dist_vector (struct data_dependence_relation *ddr,
          /* If the loop number is still greater than the number of
             loops we've been asked to analyze, or negative,
             something is borked.  */
-         if (loop_nb < 0 || loop_nb >= nb_loops)
-           abort ();
+         gcc_assert (loop_nb >= 0);
+         gcc_assert (loop_nb < nb_loops);
          dist = int_cst_value (SUB_DISTANCE (subscript));
 
          /* This is the subscript coupling test.  
@@ -1508,8 +1506,8 @@ build_classic_dist_vector (struct data_dependence_relation *ddr,
     
     lca_nb = lca->num;
     lca_nb -= first_loop;
-    if (lca_nb < 0 || lca_nb >= nb_loops)
-      abort ();
+    gcc_assert (lca_nb >= 0);
+    gcc_assert (lca_nb < nb_loops);
     /* For each outer loop where init_v is not set, the accesses are
        in dependence of distance 1 in the loop.  */
     if (lca != loop_a
@@ -1524,8 +1522,8 @@ build_classic_dist_vector (struct data_dependence_relation *ddr,
        lca_nb = lca->num - first_loop;
        while (lca->depth != 0)
          {
-           if (lca_nb < 0 || lca_nb >= nb_loops)
-             abort ();
+           gcc_assert (lca_nb >= 0);
+           gcc_assert (lca_nb < nb_loops);
            if (init_v[lca_nb] == 0)
              dist_v[lca_nb] = 1;
            lca = lca->outer;
@@ -1575,13 +1573,9 @@ build_classic_dir_vector (struct data_dependence_relation *ddr,
          /* If the loop number is still greater than the number of
             loops we've been asked to analyze, or negative,
             something is borked.  */
-         if (loop_nb < 0 || loop_nb >= nb_loops)
-           abort ();     
-         if (chrec_contains_undetermined (SUB_DISTANCE (subscript)))
-           {
-             
-           }
-         else
+         gcc_assert (loop_nb >= 0);
+         gcc_assert (loop_nb < nb_loops);
+         if (!chrec_contains_undetermined (SUB_DISTANCE (subscript)))
            {
              int dist = int_cst_value (SUB_DISTANCE (subscript));
              
@@ -1632,8 +1626,8 @@ build_classic_dir_vector (struct data_dependence_relation *ddr,
     lca = find_common_loop (loop_a, loop_b); 
     lca_nb = lca->num - first_loop;
 
-    if (lca_nb < 0 || lca_nb >= nb_loops)
-      abort ();
+    gcc_assert (lca_nb >= 0);
+    gcc_assert (lca_nb < nb_loops);
     /* For each outer loop where init_v is not set, the accesses are
        in dependence of distance 1 in the loop.  */
     if (lca != loop_a
@@ -1647,8 +1641,8 @@ build_classic_dir_vector (struct data_dependence_relation *ddr,
        lca_nb = lca->num - first_loop;
        while (lca->depth != 0)
          {
-           if (lca_nb < 0 || lca_nb >= nb_loops)
-             abort ();
+           gcc_assert (lca_nb >= 0);
+           gcc_assert (lca_nb < nb_loops);
            if (init_v[lca_nb] == 0)
              dir_v[lca_nb] = dir_positive;
            lca = lca->outer;
index 87e0ac8..ad14e12 100644 (file)
@@ -244,10 +244,7 @@ compute_immediate_uses_for_phi (tree phi, bool (*calc_for)(tree))
 {
   int i;
 
-#ifdef ENABLE_CHECKING
-  if (TREE_CODE (phi) != PHI_NODE)
-    abort ();
-#endif
+  gcc_assert (TREE_CODE (phi) == PHI_NODE);
 
   for (i = 0; i < PHI_NUM_ARGS (phi); i++)
     {
@@ -274,11 +271,8 @@ compute_immediate_uses_for_stmt (tree stmt, int flags, bool (*calc_for)(tree))
   tree use;
   ssa_op_iter iter;
 
-#ifdef ENABLE_CHECKING
   /* PHI nodes are handled elsewhere.  */
-  if (TREE_CODE (stmt) == PHI_NODE)
-    abort ();
-#endif
+  gcc_assert (TREE_CODE (stmt) != PHI_NODE);
 
   /* Look at USE_OPS or VUSE_OPS according to FLAGS.  */
   if (flags & TDFA_USE_OPS)
@@ -382,13 +376,9 @@ create_var_ann (tree t)
 {
   var_ann_t ann;
 
-#if defined ENABLE_CHECKING
-  if (t == NULL_TREE
-      || !DECL_P (t)
-      || (t->common.ann
-         && t->common.ann->common.type != VAR_ANN))
-    abort ();
-#endif
+  gcc_assert (t);
+  gcc_assert (DECL_P (t));
+  gcc_assert (!t->common.ann || t->common.ann->common.type == VAR_ANN);
 
   ann = ggc_alloc (sizeof (*ann));
   memset ((void *) ann, 0, sizeof (*ann));
@@ -408,12 +398,8 @@ create_stmt_ann (tree t)
 {
   stmt_ann_t ann;
 
-#if defined ENABLE_CHECKING
-  if ((!is_gimple_stmt (t))
-      || (t->common.ann
-         && t->common.ann->common.type != STMT_ANN))
-    abort ();
-#endif
+  gcc_assert (is_gimple_stmt (t));
+  gcc_assert (!t->common.ann || t->common.ann->common.type == STMT_ANN);
 
   ann = ggc_alloc (sizeof (*ann));
   memset ((void *) ann, 0, sizeof (*ann));
@@ -436,12 +422,8 @@ create_tree_ann (tree t)
 {
   tree_ann_t ann;
 
-#if defined ENABLE_CHECKING
-  if (t == NULL_TREE
-      || (t->common.ann
-         && t->common.ann->common.type != TREE_ANN_COMMON))
-    abort ();
-#endif
+  gcc_assert (t);
+  gcc_assert (!t->common.ann || t->common.ann->common.type == TREE_ANN_COMMON);
 
   ann = ggc_alloc (sizeof (*ann));
   memset ((void *) ann, 0, sizeof (*ann));
@@ -750,8 +732,7 @@ collect_dfa_stats (struct dfa_stats_d *dfa_stats_p)
   basic_block bb;
   block_stmt_iterator i;
 
-  if (dfa_stats_p == NULL)
-    abort ();
+  gcc_assert (dfa_stats_p);
 
   memset ((void *)dfa_stats_p, 0, sizeof (struct dfa_stats_d));
 
@@ -906,14 +887,11 @@ get_virtual_var (tree var)
         || handled_component_p (var))
     var = TREE_OPERAND (var, 0);
 
-#ifdef ENABLE_CHECKING
   /* Treating GIMPLE registers as virtual variables makes no sense.
      Also complain if we couldn't extract a _DECL out of the original
      expression.  */
-  if (!SSA_VAR_P (var)
-      || is_gimple_reg (var))
-    abort ();
-#endif
+  gcc_assert (SSA_VAR_P (var));
+  gcc_assert (!is_gimple_reg (var));
 
   return var;
 }
index dfe2ebb..c09fc53 100644 (file)
@@ -274,7 +274,7 @@ dequeue_and_dump (dump_info_p di)
          else if (access == access_private_node)
            string = "priv";
          else
-           abort ();
+           gcc_unreachable ();
 
          dump_string (di, string);
          queue_and_dump_index (di, "binf", base, DUMP_BINFO);
@@ -309,7 +309,7 @@ dequeue_and_dump (dump_info_p di)
          break;
 
        default:
-         abort ();
+         gcc_unreachable ();
        }
     }
   else if (DECL_P (t))
index 2126047..008632d 100644 (file)
@@ -103,8 +103,7 @@ record_stmt_eh_region (struct eh_region *region, tree t)
   n->region_nr = get_eh_region_number (region);
 
   slot = htab_find_slot (throw_stmt_table, n, INSERT);
-  if (*slot)
-    abort ();
+  gcc_assert (!*slot);
   *slot = n;
 }
 
@@ -114,16 +113,14 @@ add_stmt_to_eh_region (tree t, int num)
   struct throw_stmt_node *n;
   void **slot;
 
-  if (num < 0)
-    abort ();
+  gcc_assert (num >= 0);
 
   n = ggc_alloc (sizeof (*n));
   n->stmt = t;
   n->region_nr = num;
 
   slot = htab_find_slot (throw_stmt_table, n, INSERT);
-  if (*slot)
-    abort ();
+  gcc_assert (!*slot);
   *slot = n;
 }
 
@@ -186,8 +183,7 @@ record_in_finally_tree (tree child, tree parent)
   n->parent = parent;
 
   slot = htab_find_slot (finally_tree, n, INSERT);
-  if (*slot)
-    abort ();
+  gcc_assert (!*slot);
   *slot = n;
 }
 
@@ -422,7 +418,7 @@ replace_goto_queue_1 (tree t, struct leh_tf_state *tf, tree_stmt_iterator *tsi)
       break;
 
     case STATEMENT_LIST:
-      abort ();
+      gcc_unreachable ();
 
     default:
       /* These won't have gotos in them.  */
@@ -505,7 +501,7 @@ maybe_record_in_goto_queue (struct leh_state *state, tree stmt)
       break;
 
     default:
-      abort ();
+      gcc_unreachable ();
     }
 
   active = tf->goto_queue_active;
@@ -547,8 +543,7 @@ verify_norecord_switch_expr (struct leh_state *state, tree switch_expr)
   for (i = 0; i < n; ++i)
     {
       tree lab = CASE_LABEL (TREE_VEC_ELT (vec, i));
-      if (outside_finally_tree (lab, tf->try_finally_expr))
-       abort ();
+      gcc_assert (!outside_finally_tree (lab, tf->try_finally_expr));
     }
 }
 #else
@@ -591,47 +586,51 @@ do_return_redirection (struct goto_queue_node *q, tree finlab, tree mod,
          depends, I guess, but it does make generation of the switch in
          lower_try_finally_switch easier.  */
 
-      if (TREE_CODE (ret_expr) == RESULT_DECL)
+      switch (TREE_CODE (ret_expr))
        {
+       case RESULT_DECL:
          if (!*return_value_p)
            *return_value_p = ret_expr;
-         else if (*return_value_p != ret_expr)
-           abort ();
-          q->cont_stmt = q->stmt;
-       }
-      else if (TREE_CODE (ret_expr) == MODIFY_EXPR)
-       {
-         tree result = TREE_OPERAND (ret_expr, 0);
-         tree new, old = TREE_OPERAND (ret_expr, 1);
-
-         if (!*return_value_p)
-           {
-             if (aggregate_value_p (TREE_TYPE (result),
-                                    TREE_TYPE (current_function_decl)))
-               /* If this function returns in memory, copy the argument
-                  into the return slot now.  Otherwise, we might need to
-                  worry about magic return semantics, so we need to use a
-                  temporary to hold the value until we're actually ready
-                  to return.  */
-               new = result;
-             else
-               new = create_tmp_var (TREE_TYPE (old), "rettmp");
-             *return_value_p = new;
-           }
          else
-           new = *return_value_p;
+           gcc_assert (*return_value_p == ret_expr);
+         q->cont_stmt = q->stmt;
+         break;
 
-         x = build (MODIFY_EXPR, TREE_TYPE (new), new, old);
-         append_to_statement_list (x, &q->repl_stmt);
+       case MODIFY_EXPR:
+         {
+           tree result = TREE_OPERAND (ret_expr, 0);
+           tree new, old = TREE_OPERAND (ret_expr, 1);
+
+           if (!*return_value_p)
+             {
+               if (aggregate_value_p (TREE_TYPE (result),
+                                     TREE_TYPE (current_function_decl)))
+                 /* If this function returns in memory, copy the argument
+                   into the return slot now.  Otherwise, we might need to
+                   worry about magic return semantics, so we need to use a
+                   temporary to hold the value until we're actually ready
+                   to return.  */
+                 new = result;
+               else
+                 new = create_tmp_var (TREE_TYPE (old), "rettmp");
+               *return_value_p = new;
+             }
+           else
+             new = *return_value_p;
+
+           x = build (MODIFY_EXPR, TREE_TYPE (new), new, old);
+           append_to_statement_list (x, &q->repl_stmt);
+
+           if (new == result)
+             x = result;
+           else
+             x = build (MODIFY_EXPR, TREE_TYPE (result), result, new);
+           q->cont_stmt = build1 (RETURN_EXPR, void_type_node, x);
+         }
 
-         if (new == result)
-           x = result;
-         else
-           x = build (MODIFY_EXPR, TREE_TYPE (result), result, new);
-         q->cont_stmt = build1 (RETURN_EXPR, void_type_node, x);
+       default:
+         gcc_unreachable ();
        }
-      else
-       abort ();
     }
   else
     {
index 423088c..cd2bf9e 100644 (file)
@@ -30,13 +30,9 @@ Boston, MA 02111-1307, USA.  */
 static inline var_ann_t
 var_ann (tree t)
 {
-#if defined ENABLE_CHECKING
-  if (t == NULL_TREE
-      || !DECL_P (t)
-      || (t->common.ann
-         && t->common.ann->common.type != VAR_ANN))
-    abort ();
-#endif
+  gcc_assert (t);
+  gcc_assert (DECL_P (t));
+  gcc_assert (!t->common.ann || t->common.ann->common.type == VAR_ANN);
 
   return (var_ann_t) t->common.ann;
 }
@@ -55,11 +51,9 @@ get_var_ann (tree var)
 static inline stmt_ann_t
 stmt_ann (tree t)
 {
-#if defined ENABLE_CHECKING
-  if (!is_gimple_stmt (t))
-    abort ();
+#ifdef ENABLE_CHECKING
+  gcc_assert (is_gimple_stmt (t));
 #endif
-
   return (stmt_ann_t) t->common.ann;
 }
 
@@ -223,10 +217,7 @@ get_def_from_ptr (def_operand_p def)
 static inline use_operand_p
 get_use_op_ptr (use_optype uses, unsigned int index)
 {
-#ifdef ENABLE_CHECKING
-  if (index >= uses->num_uses)
-    abort();
-#endif
+  gcc_assert (index < uses->num_uses);
   return uses->uses[index];
 }
 
@@ -234,10 +225,7 @@ get_use_op_ptr (use_optype uses, unsigned int index)
 static inline def_operand_p
 get_def_op_ptr (def_optype defs, unsigned int index)
 {
-#ifdef ENABLE_CHECKING
-  if (index >= defs->num_defs)
-    abort();
-#endif
+  gcc_assert (index < defs->num_defs);
   return defs->defs[index];
 }
 
@@ -248,10 +236,7 @@ static inline def_operand_p
 get_v_may_def_result_ptr(v_may_def_optype v_may_defs, unsigned int index)
 {
   def_operand_p op;
-#ifdef ENABLE_CHECKING
-  if (index >= v_may_defs->num_v_may_defs)
-    abort();
-#endif
+  gcc_assert (index < v_may_defs->num_v_may_defs);
   op.def = &(v_may_defs->v_may_defs[index].def);
   return op;
 }
@@ -262,10 +247,7 @@ static inline use_operand_p
 get_v_may_def_op_ptr(v_may_def_optype v_may_defs, unsigned int index)
 {
   use_operand_p op;
-#ifdef ENABLE_CHECKING
-  if (index >= v_may_defs->num_v_may_defs)
-    abort();
-#endif
+  gcc_assert (index < v_may_defs->num_v_may_defs);
   op.use = &(v_may_defs->v_may_defs[index].use);
   return op;
 }
@@ -275,10 +257,7 @@ static inline use_operand_p
 get_vuse_op_ptr(vuse_optype vuses, unsigned int index)
 {
   use_operand_p op;
-#ifdef ENABLE_CHECKING
-  if (index >= vuses->num_vuses)
-    abort();
-#endif
+  gcc_assert (index < vuses->num_vuses);
   op.use = &(vuses->vuses[index]);
   return op;
 }
@@ -289,10 +268,7 @@ static inline def_operand_p
 get_v_must_def_op_ptr (v_must_def_optype v_must_defs, unsigned int index)
 {
   def_operand_p op;
-#ifdef ENABLE_CHECKING
-  if (index >= v_must_defs->num_v_must_defs)
-    abort();
-#endif
+  gcc_assert (index < v_must_defs->num_v_must_defs);
   op.def = &(v_must_defs->v_must_defs[index]);
   return op;
 }
@@ -358,8 +334,7 @@ immediate_use (dataflow_t df, int num)
     return NULL_TREE;
 
 #ifdef ENABLE_CHECKING
-  if (num >= num_immediate_uses (df))
-    abort ();
+  gcc_assert (num < num_immediate_uses (df));
 #endif
   if (num < 2)
     return df->uses[num];
@@ -400,10 +375,8 @@ static inline int
 phi_arg_from_edge (tree phi, edge e)
 {
   int i;
-#if defined ENABLE_CHECKING
-  if (!phi || TREE_CODE (phi) != PHI_NODE)
-    abort();
-#endif
+  gcc_assert (phi);
+  gcc_assert (TREE_CODE (phi) == PHI_NODE);
 
   for (i = 0; i < PHI_NUM_ARGS (phi); i++)
     if (PHI_ARG_EDGE (phi, i) == e)
@@ -477,8 +450,7 @@ phi_ssa_name_p (tree t)
   if (TREE_CODE (t) == SSA_NAME)
     return true;
 #ifdef ENABLE_CHECKING
-  if (!is_gimple_min_invariant (t))
-    abort ();
+  gcc_assert (is_gimple_min_invariant (t));
 #endif
   return false;
 }
@@ -495,10 +467,7 @@ bsi_start (basic_block bb)
     bsi.tsi = tsi_start (bb->stmt_list);
   else
     {
-#ifdef ENABLE_CHECKING
-      if (bb->index >= 0)
-       abort ();
-#endif
+      gcc_assert (bb->index < 0);
       bsi.tsi.ptr = NULL;
       bsi.tsi.container = NULL;
     }
@@ -519,10 +488,7 @@ bsi_after_labels (basic_block bb)
 
   if (!bb->stmt_list)
     {
-#ifdef ENABLE_CHECKING
-      if (bb->index >= 0)
-       abort ();
-#endif
+      gcc_assert (bb->index < 0);
       bsi.tsi.ptr = NULL;
       bsi.tsi.container = NULL;
       return bsi;
@@ -537,8 +503,7 @@ bsi_after_labels (basic_block bb)
      be placed at the start of the basic block.  This would not work if the
      first statement was not label; rather fail here than enable the user
      proceed in wrong way.  */
-  if (TREE_CODE (tsi_stmt (bsi.tsi)) != LABEL_EXPR)
-    abort ();
+  gcc_assert (TREE_CODE (tsi_stmt (bsi.tsi)) == LABEL_EXPR);
 
   next = bsi.tsi;
   tsi_next (&next);
@@ -563,10 +528,7 @@ bsi_last (basic_block bb)
     bsi.tsi = tsi_last (bb->stmt_list);
   else
     {
-#ifdef ENABLE_CHECKING
-      if (bb->index >= 0)
-       abort ();
-#endif
+      gcc_assert (bb->index < 0);
       bsi.tsi.ptr = NULL;
       bsi.tsi.container = NULL;
     }
index 1e2fd76..0c9a4b6 100644 (file)
@@ -257,8 +257,7 @@ tree_if_convert_stmt (struct loop *  loop, tree t, tree cond,
       break;
 
     default:
-      abort ();
-      break;
+      gcc_unreachable ();
     }
   return cond;
 }
@@ -275,10 +274,7 @@ tree_if_convert_cond_expr (struct loop *loop, tree stmt, tree cond,
   tree then_clause, else_clause, c, new_cond;
   new_cond = NULL_TREE;
 
-#ifdef ENABLE_CHECKING
-  if (TREE_CODE (stmt) != COND_EXPR)
-    abort ();
-#endif
+  gcc_assert (TREE_CODE (stmt) == COND_EXPR);
 
   c = TREE_OPERAND (stmt, 0);
   then_clause = TREE_OPERAND (stmt, 1);
@@ -634,10 +630,7 @@ add_to_dst_predicate_list (struct loop * loop, tree dst,
   basic_block bb;
   tree new_cond = NULL_TREE;
 
-#ifdef ENABLE_CHECKING
-  if (TREE_CODE (dst) != GOTO_EXPR)
-    abort ();
-#endif
+  gcc_assert (TREE_CODE (dst) == GOTO_EXPR);
   bb = label_to_block (TREE_OPERAND (dst, 0));
   if (!flow_bb_inside_loop_p (loop, bb))
     return NULL_TREE;
@@ -688,11 +681,11 @@ find_phi_replacement_condition (basic_block bb, tree *cond,
     {
       if (p1 == NULL)
          p1 = e->src;
-      else if (p2 == NULL)
-       p2 = e->src;
-      else
-       /* More than two predecessors. This is not expected.  */
-       abort ();
+      else 
+       {
+         gcc_assert (!p2);
+         p2 = e->src;
+       }
     }
 
   /* Use condition that is not TRUTH_NOT_EXPR in conditional modify expr.  */
@@ -722,10 +715,7 @@ find_phi_replacement_condition (basic_block bb, tree *cond,
       *cond = TREE_OPERAND (new_stmt, 0);
     }
 
-#ifdef ENABLE_CHECKING
-  if (*cond == NULL_TREE)
-    abort ();
-#endif
+  gcc_assert (*cond);
 
   return true_bb;
 }
@@ -749,15 +739,11 @@ replace_phi_with_cond_modify_expr (tree phi, tree cond, basic_block true_bb,
   basic_block bb;
   tree rhs;
   tree arg_0, arg_1;
-  
-#ifdef ENABLE_CHECKING
-  if (TREE_CODE (phi) != PHI_NODE)
-    abort ();
 
+  gcc_assert (TREE_CODE (phi) == PHI_NODE);
+  
   /* If this is not filtered earlier, then now it is too late.  */
-  if (PHI_NUM_ARGS (phi) != 2)
-     abort ();
-#endif
+  gcc_assert (PHI_NUM_ARGS (phi) == 2);
 
   /* Find basic block and initialize iterator.  */
   bb = bb_for_stmt (phi);
@@ -991,11 +977,8 @@ get_loop_body_in_if_conv_order (const struct loop *loop)
   unsigned int index = 0;
   unsigned int visited_count = 0;
 
-  if (!loop->num_nodes)
-    abort ();
-
-  if (loop->latch == EXIT_BLOCK_PTR)
-    abort ();
+  gcc_assert (loop->num_nodes);
+  gcc_assert (loop->latch != EXIT_BLOCK_PTR);
 
   blocks = xcalloc (loop->num_nodes, sizeof (basic_block));
   visited = BITMAP_XMALLOC ();
index 71e9ef2..7a80528 100644 (file)
@@ -206,8 +206,7 @@ remap_decl (tree decl, inline_data *id)
            {
              tree member = remap_decl (TREE_VALUE (src), id);
 
-             if (TREE_PURPOSE (src))
-               abort ();
+             gcc_assert (!TREE_PURPOSE (src));
              members = tree_cons (NULL, member, members);
            }
          DECL_ANON_UNION_ELEMS (t) = nreverse (members);
@@ -326,7 +325,7 @@ remap_type (tree type, inline_data *id)
     case OFFSET_TYPE:
     default:
       /* Shouldn't have been thought variable sized.  */
-      abort ();
+      gcc_unreachable ();
     }
 
   walk_tree (&TYPE_SIZE (new), copy_body_r, id, NULL);
@@ -354,12 +353,9 @@ remap_decls (tree decls, inline_data *id)
         already declared somewhere else, so don't declare it here.  */
       if (!new_var || new_var == id->retvar)
        ;
-#ifdef ENABLE_CHECKING
-      else if (!DECL_P (new_var))
-       abort ();
-#endif
       else
        {
+         gcc_assert (DECL_P (new_var));
          TREE_CHAIN (new_var) = new_decls;
          new_decls = new_var;
        }
@@ -461,8 +457,7 @@ copy_body_r (tree *tp, int *walk_subtrees, void *data)
      what function they come from.  */
   if ((TREE_CODE (*tp) == VAR_DECL || TREE_CODE (*tp) == LABEL_DECL)
       && DECL_NAMESPACE_SCOPE_P (*tp))
-    if (! DECL_EXTERNAL (*tp) && ! TREE_STATIC (*tp))
-      abort ();
+    gcc_assert (DECL_EXTERNAL (*tp) || TREE_STATIC (*tp));
 #endif
 
   /* If this is a RETURN_EXPR, change it into a MODIFY_EXPR and a
@@ -504,17 +499,11 @@ copy_body_r (tree *tp, int *walk_subtrees, void *data)
 
       /* Remap the declaration.  */
       new_decl = remap_decl (*tp, id);
-      if (! new_decl)
-       abort ();
+      gcc_assert (new_decl);
       /* Replace this variable with the copy.  */
       STRIP_TYPE_NOPS (new_decl);
       *tp = new_decl;
     }
-#if 0
-  else if (nonstatic_local_decl_p (*tp)
-          && DECL_CONTEXT (*tp) != VARRAY_TREE (id->fns, 0))
-    abort ();
-#endif
   else if (TREE_CODE (*tp) == STATEMENT_LIST)
     copy_statement_list (tp);
   else if (TREE_CODE (*tp) == SAVE_EXPR)
@@ -536,8 +525,7 @@ copy_body_r (tree *tp, int *walk_subtrees, void *data)
        = splay_tree_lookup (id->decl_map,
                             (splay_tree_key) TREE_OPERAND (*tp, 0));
       /* We _must_ have seen the enclosing LABELED_BLOCK_EXPR.  */
-      if (! n)
-       abort ();
+      gcc_assert (n);
       *tp = copy_node (*tp);
       TREE_OPERAND (*tp, 0) = (tree) n->value;
     }
@@ -608,10 +596,8 @@ copy_body_r (tree *tp, int *walk_subtrees, void *data)
              for (node = id->node->next_clone; node; node = node->next_clone)
                {
                  edge = cgraph_edge (node, old_node);
-                 if (edge)
-                   edge->call_expr = *tp;
-                 else
-                   abort ();
+                 gcc_assert (edge);
+                 edge->call_expr = *tp;
                }
            }
          else
@@ -793,11 +779,10 @@ initialize_inlined_parameters (inline_data *id, tree args, tree static_chain,
   if (p)
     {
       /* No static chain?  Seems like a bug in tree-nested.c.  */
-      if (!static_chain)
-       abort ();
+      gcc_assert (static_chain);
 
-       setup_one_parameter (id, p, static_chain, fn, &init_stmts, &vars,
-                           &gimplify_init_stmts_p);
+      setup_one_parameter (id, p, static_chain, fn, &init_stmts, &vars,
+                          &gimplify_init_stmts_p);
     }
 
   if (gimplify_init_stmts_p)
@@ -841,8 +826,7 @@ declare_return_variable (inline_data *id, tree return_slot_addr,
     {
       /* The front end shouldn't have used both return_slot_addr and
         a modify expression.  */
-      if (modify_dest)
-       abort ();
+      gcc_assert (!modify_dest);
       if (DECL_BY_REFERENCE (result))
        var = return_slot_addr;
       else
@@ -852,8 +836,7 @@ declare_return_variable (inline_data *id, tree return_slot_addr,
     }
 
   /* All types requiring non-trivial constructors should have been handled.  */
-  if (TREE_ADDRESSABLE (callee_type))
-    abort ();
+  gcc_assert (!TREE_ADDRESSABLE (callee_type));
 
   /* Attempt to avoid creating a new temporary variable.  */
   if (modify_dest)
@@ -886,8 +869,7 @@ declare_return_variable (inline_data *id, tree return_slot_addr,
        }
     }
 
-  if (TREE_CODE (TYPE_SIZE_UNIT (callee_type)) != INTEGER_CST)
-    abort ();
+  gcc_assert (TREE_CODE (TYPE_SIZE_UNIT (callee_type)) == INTEGER_CST);
 
   var = copy_decl_for_inlining (result, callee, caller);
   DECL_SEEN_IN_BIND_EXPR_P (var) = 1;
@@ -1359,7 +1341,7 @@ estimate_num_insns_1 (tree *tp, int *walk_subtrees, void *data)
       }
     default:
       /* Abort here se we know we don't miss any nodes.  */
-      abort ();
+      gcc_unreachable ();
     }
   return NULL;
 }
@@ -1481,8 +1463,7 @@ expand_call_inline (tree *tp, int *walk_subtrees, void *data)
          where previous inlining turned indirect call into direct call by
          constant propagating arguments.  In all other cases we hit a bug
          (incorrect node sharing is most common reason for missing edges.  */
-      if (!dest->needed)
-       abort ();
+      gcc_assert (dest->needed);
       cgraph_create_edge (id->node, dest, t)->inline_failed
        = N_("originally indirect function call not considered for inlining");
       goto egress;
@@ -1585,9 +1566,8 @@ expand_call_inline (tree *tp, int *walk_subtrees, void *data)
   DECL_CONTEXT (id->ret_label) = VARRAY_TREE (id->fns, 0);
   insert_decl_map (id, id->ret_label, id->ret_label);
 
-  if (! DECL_INITIAL (fn)
-      || TREE_CODE (DECL_INITIAL (fn)) != BLOCK)
-    abort ();
+  gcc_assert (DECL_INITIAL (fn));
+  gcc_assert (TREE_CODE (DECL_INITIAL (fn)) == BLOCK);
 
   /* Find the lhs to which the result of this call is assigned.  */
   modify_dest = tsi_stmt (id->tsi);
@@ -1725,7 +1705,7 @@ expand_calls_inline (tree *stmt_p, inline_data *id)
 
     case COMPOUND_EXPR:
       /* We're gimple.  We should have gotten rid of all these.  */
-      abort ();
+      gcc_unreachable ();
 
     case RETURN_EXPR:
       stmt_p = &TREE_OPERAND (stmt, 0);
@@ -1817,8 +1797,7 @@ optimize_inline_calls (tree fn)
 
       /* Double check that we inlined everything we are supposed to inline.  */
       for (e = id.node->callees; e; e = e->next_callee)
-       if (!e->inline_failed)
-         abort ();
+       gcc_assert (e->inline_failed);
     }
 #endif
 }
@@ -2303,9 +2282,8 @@ copy_tree_r (tree *tp, int *walk_subtrees, void *data ATTRIBUTE_UNUSED)
     *walk_subtrees = 0;
   else if (TREE_CODE_CLASS (code) == 'd')
     *walk_subtrees = 0;
- else if (code == STATEMENT_LIST)
-    abort ();
-
+  else
+    gcc_assert (code != STATEMENT_LIST);
   return NULL_TREE;
 }
 
index 735d71f..bbec1b2 100644 (file)
@@ -649,7 +649,6 @@ rewrite_initialize_block_local_data (struct dom_walk_data *walk_data ATTRIBUTE_U
                                     basic_block bb ATTRIBUTE_UNUSED,
                                     bool recycled ATTRIBUTE_UNUSED)
 {
-#ifdef ENABLE_CHECKING
   struct rewrite_block_data *bd
     = (struct rewrite_block_data *)VARRAY_TOP_GENERIC_PTR (walk_data->block_data_stack);
                                                                                 
@@ -657,9 +656,7 @@ rewrite_initialize_block_local_data (struct dom_walk_data *walk_data ATTRIBUTE_U
      not cleared, then we are re-using a previously allocated entry.  In
      that case, we can also re-use the underlying virtual arrays.  Just
      make sure we clear them before using them!  */
-  if (recycled && bd->block_defs && VARRAY_ACTIVE_SIZE (bd->block_defs) > 0)
-    abort ();
-#endif
+  gcc_assert (!recycled || !bd->block_defs || !(VARRAY_ACTIVE_SIZE (bd->block_defs) > 0));
 }
 
 
@@ -1064,12 +1061,9 @@ rewrite_stmt (struct dom_walk_data *walk_data,
       fprintf (dump_file, "\n");
     }
 
-#if defined ENABLE_CHECKING
   /* We have just scanned the code for operands.  No statement should
      be modified.  */
-  if (ann->modified)
-    abort ();
-#endif
+  gcc_assert (!ann->modified);
 
   /* Step 1.  Rewrite USES and VUSES in the statement.  */
   FOR_EACH_SSA_USE_OPERAND (use_p, stmt, iter, SSA_OP_ALL_USES)
@@ -1114,12 +1108,9 @@ ssa_rewrite_stmt (struct dom_walk_data *walk_data,
       fprintf (dump_file, "\n");
     }
 
-#if defined ENABLE_CHECKING
   /* We have just scanned the code for operands.  No statement should
      be modified.  */
-  if (ann->modified)
-    abort ();
-#endif
+  gcc_assert (!ann->modified);
 
   /* Step 1.  Rewrite USES and VUSES in the statement.  */
   FOR_EACH_SSA_USE_OPERAND (use_p, stmt, iter, SSA_OP_ALL_USES)
@@ -1421,9 +1412,7 @@ rewrite_into_ssa (bool all)
   else
     {
       /* Initialize the array of variables to rename.  */
-      if (vars_to_rename == NULL)
-       abort ();
+      gcc_assert (vars_to_rename);
 
       if (bitmap_first_set_bit (vars_to_rename) < 0)
        {
index d13ea96..1b78160 100644 (file)
@@ -52,10 +52,8 @@ alloc_stmt_list (void)
 void
 free_stmt_list (tree t)
 {
-#ifdef ENABLE_CHECKING
-  if (STATEMENT_LIST_HEAD (t) || STATEMENT_LIST_TAIL (t))
-    abort ();
-#endif
+  gcc_assert (!STATEMENT_LIST_HEAD (t));
+  gcc_assert (!STATEMENT_LIST_TAIL (t));
   TREE_CHAIN (t) = stmt_list_cache;
   stmt_list_cache = t;
 }
@@ -68,8 +66,7 @@ tsi_link_before (tree_stmt_iterator *i, tree t, enum tsi_iterator_update mode)
   struct tree_statement_list_node *head, *tail, *cur;
 
   /* Die on looping.  */
-  if (t == i->container)
-    abort ();
+  gcc_assert (t != i->container);
 
   if (TREE_CODE (t) == STATEMENT_LIST)
     {
@@ -83,8 +80,7 @@ tsi_link_before (tree_stmt_iterator *i, tree t, enum tsi_iterator_update mode)
       /* Empty statement lists need no work.  */
       if (!head || !tail)
        {
-         if (head != tail)
-           abort ();
+         gcc_assert (head == tail);
          return;
        }
     }
@@ -114,8 +110,7 @@ tsi_link_before (tree_stmt_iterator *i, tree t, enum tsi_iterator_update mode)
     }
   else
     {
-      if (STATEMENT_LIST_TAIL (i->container))
-       abort ();
+      gcc_assert (!STATEMENT_LIST_TAIL (i->container));
       STATEMENT_LIST_HEAD (i->container) = head;
       STATEMENT_LIST_TAIL (i->container) = tail;
     }
@@ -132,8 +127,7 @@ tsi_link_before (tree_stmt_iterator *i, tree t, enum tsi_iterator_update mode)
       i->ptr = tail;
       break;
     case TSI_SAME_STMT:
-      if (!cur)
-       abort ();
+      gcc_assert (cur);
       break;
     }
 }
@@ -146,8 +140,7 @@ tsi_link_after (tree_stmt_iterator *i, tree t, enum tsi_iterator_update mode)
   struct tree_statement_list_node *head, *tail, *cur;
 
   /* Die on looping.  */
-  if (t == i->container)
-    abort ();
+  gcc_assert (t != i->container);
 
   if (TREE_CODE (t) == STATEMENT_LIST)
     {
@@ -161,8 +154,7 @@ tsi_link_after (tree_stmt_iterator *i, tree t, enum tsi_iterator_update mode)
       /* Empty statement lists need no work.  */
       if (!head || !tail)
        {
-         if (head != tail)
-           abort ();
+         gcc_assert (head == tail);
          return;
        }
     }
@@ -192,8 +184,7 @@ tsi_link_after (tree_stmt_iterator *i, tree t, enum tsi_iterator_update mode)
     }
   else
     {
-      if (STATEMENT_LIST_TAIL (i->container))
-       abort ();
+      gcc_assert (!STATEMENT_LIST_TAIL (i->container));
       STATEMENT_LIST_HEAD (i->container) = head;
       STATEMENT_LIST_TAIL (i->container) = tail;
     }
@@ -210,8 +201,7 @@ tsi_link_after (tree_stmt_iterator *i, tree t, enum tsi_iterator_update mode)
       i->ptr = tail;
       break;
     case TSI_SAME_STMT:
-      if (!cur)
-        abort ();
+      gcc_assert (cur);
       break;
     }
 }
@@ -254,8 +244,7 @@ tsi_split_statement_list_after (const tree_stmt_iterator *i)
 
   cur = i->ptr;
   /* How can we possibly split after the end, or before the beginning?  */
-  if (cur == NULL)
-    abort ();
+  gcc_assert (cur);
   next = cur->next;
 
   old_sl = i->container;
@@ -282,8 +271,7 @@ tsi_split_statement_list_before (tree_stmt_iterator *i)
 
   cur = i->ptr;
   /* How can we possibly split after the end, or before the beginning?  */
-  if (cur == NULL)
-    abort ();
+  gcc_assert (cur);
   prev = cur->prev;
 
   old_sl = i->container;
index 55263e8..ba589f9 100644 (file)
@@ -102,8 +102,7 @@ mf_varname_tree (tree decl)
   const char *buf_contents;
   tree result;
 
-  if (decl == NULL_TREE)
-    abort ();
+  gcc_assert (decl);
 
   if (!initialized)
     {
index 8d5017b..3b7e3c5 100644 (file)
@@ -132,15 +132,12 @@ create_tmp_var_for (struct nesting_info *info, tree type, const char *prefix)
 {
   tree tmp_var;
 
-#if defined ENABLE_CHECKING
   /* If the type is of variable size or a type which must be created by the
      frontend, something is wrong.  Note that we explicitly allow
      incomplete types here, since we create them ourselves here.  */
-  if (TREE_ADDRESSABLE (type)
-      || (TYPE_SIZE_UNIT (type)
-         && TREE_CODE (TYPE_SIZE_UNIT (type)) != INTEGER_CST))
-    abort ();
-#endif
+  gcc_assert (TREE_ADDRESSABLE (type));
+  gcc_assert (!TYPE_SIZE_UNIT (type)
+             || TREE_CODE (TYPE_SIZE_UNIT (type)) == INTEGER_CST);
 
   tmp_var = create_tmp_var_raw (type, prefix);
   DECL_CONTEXT (tmp_var) = info->context;
@@ -249,8 +246,7 @@ lookup_field_for_decl (struct nesting_info *info, tree decl,
   slot = htab_find_slot (info->var_map, &dummy, insert);
   if (!slot)
     {
-      if (insert == INSERT)
-       abort ();
+      gcc_assert (insert != INSERT);
       return NULL;
     }
   elt = *slot;
@@ -434,8 +430,7 @@ lookup_tramp_for_decl (struct nesting_info *info, tree decl,
   slot = htab_find_slot (info->var_map, &dummy, insert);
   if (!slot)
     {
-      if (insert == INSERT)
-       abort ();
+      gcc_assert (insert != INSERT);
       return NULL;
     }
   elt = *slot;
@@ -1194,12 +1189,7 @@ convert_all_function_calls (struct nesting_info *root)
       if (root->outer && !root->chain_decl && !root->chain_field)
        DECL_NO_STATIC_CHAIN (root->context) = 1;
       else
-       {
-#ifdef ENABLE_CHECKING
-         if (DECL_NO_STATIC_CHAIN (root->context))
-           abort ();
-#endif
-       }
+       gcc_assert (!DECL_NO_STATIC_CHAIN (root->context));
 
       root = root->next;
     }
index 5ad1891..e1687af 100644 (file)
@@ -555,8 +555,7 @@ tree_rest_of_compilation (tree fndecl, bool nested_p)
 
   timevar_push (TV_EXPAND);
 
-  if (flag_unit_at_a_time && !cgraph_global_info_ready)
-    abort ();
+  gcc_assert (!flag_unit_at_a_time || cgraph_global_info_ready);
 
   /* Initialize the RTL code for the function.  */
   current_function_decl = fndecl;
index c9403f0..3910501 100644 (file)
@@ -146,10 +146,8 @@ create_temp (tree t)
 
   if (TREE_CODE (t) == SSA_NAME)
     t = SSA_NAME_VAR (t);
-  if (TREE_CODE (t) != VAR_DECL 
-      && TREE_CODE (t) != PARM_DECL)
-    abort ();
+
+  gcc_assert (TREE_CODE (t) == VAR_DECL || TREE_CODE (t) == PARM_DECL);
 
   type = TREE_TYPE (t);
   tmp = DECL_NAME (t);
@@ -368,8 +366,7 @@ eliminate_build (elim_graph g, basic_block B, int i)
             in the same order as all of the other PHI nodes. If they don't 
             match, find the appropriate index here.  */
          pi = phi_arg_from_edge (phi, g->e);
-         if (pi == -1)
-           abort();
+         gcc_assert (pi != -1);
          Ti = PHI_ARG_DEF (phi, pi);
        }
 
@@ -496,12 +493,8 @@ eliminate_phi (edge e, int i, elim_graph g)
   int x;
   basic_block B = e->dest;
 
-#if defined ENABLE_CHECKING
-  if (i == -1)
-    abort ();
-  if (VARRAY_ACTIVE_SIZE (g->const_copies) != 0)
-    abort ();
-#endif
+  gcc_assert (i != -1);
+  gcc_assert (VARRAY_ACTIVE_SIZE (g->const_copies) == 0);
 
   /* Abnormal edges already have everything coalesced, or the coalescer
      would have aborted.  */
@@ -609,59 +602,71 @@ coalesce_abnormal_edges (var_map map, conflict_graph graph, root_var_p rv)
              continue;
 
            y = phi_arg_from_edge (phi, e);
-           if (y == -1)
-             abort ();
+           gcc_assert (y != -1);
 
            tmp = PHI_ARG_DEF (phi, y);
+#ifdef ENABLE_CHECKING
            if (!phi_ssa_name_p (tmp))
              {
                print_exprs_edge (stderr, e,
                                  "\nConstant argument in PHI. Can't insert :",
                                  var, " = ", tmp);
-               abort ();
+               internal_error ("SSA corruption");
              }
+#else
+           gcc_assert (phi_ssa_name (tmp));
+#endif
            y = var_to_partition (map, tmp);
-           if (x == NO_PARTITION || y == NO_PARTITION)
-             abort ();
+           gcc_assert (x != NO_PARTITION);
+           gcc_assert (y != NO_PARTITION);
+#ifdef ENABLE_CHECKING
            if (root_var_find (rv, x) != root_var_find (rv, y))
              {
                print_exprs_edge (stderr, e, "\nDifferent root vars: ",
                                  root_var (rv, root_var_find (rv, x)), 
                                  " and ", 
                                  root_var (rv, root_var_find (rv, y)));
-               abort ();
+               internal_error ("SSA corruption");
              }
+#else
+           gcc_assert (root_var_find (rv, x) == root_var_find (rv, y));
+#endif
 
            if (x != y)
              {
-               if (!conflict_graph_conflict_p (graph, x, y))
-                 {
-                   /* Now map the partitions back to their real variables.  */
-                   var = partition_to_var (map, x);
-                   tmp = partition_to_var (map, y);
-                   if (dump_file 
-                       && (dump_flags & TDF_DETAILS))
-                     {
-                       print_exprs_edge (dump_file, e, 
-                                         "ABNORMAL: Coalescing ",
-                                         var, " and ", tmp);
-                     }
-                   if (var_union (map, var, tmp) == NO_PARTITION)
-                     {
-                       print_exprs_edge (stderr, e, "\nUnable to coalesce", 
-                                         partition_to_var (map, x), " and ", 
-                                         partition_to_var (map, y));
-                       abort ();
-                     }
-                   conflict_graph_merge_regs (graph, x, y);
-                 }
-               else
+#ifdef ENABLE_CHECKING
+               if (conflict_graph_conflict_p (graph, x, y))
                  {
                    print_exprs_edge (stderr, e, "\n Conflict ", 
                                      partition_to_var (map, x),
                                      " and ", partition_to_var (map, y));
-                   abort ();
+                   internal_error ("SSA corruption");
                  }
+#else
+               gcc_assert (!conflict_graph_conflict_p (graph, x, y));
+#endif
+               
+               /* Now map the partitions back to their real variables.  */
+               var = partition_to_var (map, x);
+               tmp = partition_to_var (map, y);
+               if (dump_file && (dump_flags & TDF_DETAILS))
+                 {
+                   print_exprs_edge (dump_file, e, 
+                                     "ABNORMAL: Coalescing ",
+                                     var, " and ", tmp);
+                 }
+#ifdef ENABLE_CHECKING
+               if (var_union (map, var, tmp) == NO_PARTITION)
+                 {
+                   print_exprs_edge (stderr, e, "\nUnable to coalesce", 
+                                     partition_to_var (map, x), " and ", 
+                                     partition_to_var (map, y));
+                   internal_error ("SSA corruption");
+                 }
+#else
+               gcc_assert (var_union (map, var, tmp) != NO_PARTITION);
+#endif
+               conflict_graph_merge_regs (graph, x, y);
              }
          }
 }
@@ -801,12 +806,9 @@ coalesce_ssa_name (var_map map, int flags)
       /* If these aren't already coalesced...  */
       if (partition_to_var (map, x) != var)
        {
-         if (ann->out_of_ssa_tag)
-           {
-             /* This root variable has already been assigned to another
-                partition which is not coalesced with this one.  */
-             abort ();
-           }
+         /* This root variable should have not already been assigned
+            to another partition which is not coalesced with this one.  */
+         gcc_assert (!ann->out_of_ssa_tag);
 
          if (dump_file && (dump_flags & TDF_DETAILS))
            {
@@ -1032,7 +1034,7 @@ eliminate_virtual_phis (void)
                      print_generic_expr (stderr, arg, TDF_SLIM);
                      fprintf (stderr, "), but the result is :");
                      print_generic_stmt (stderr, phi, TDF_SLIM);
-                     abort();
+                     internal_error ("SSA corruption");
                    }
                }
 #endif
@@ -1279,7 +1281,7 @@ free_temp_expr_table (temp_expr_table_p t)
   int x;
   for (x = 0; x <= num_var_partitions (t->map); x++)
     if (t->partition_dep_list[x] != NULL)
-      abort();
+      gcc_unreachable ();
 #endif
 
   while ((p = t->free_list))
@@ -1438,10 +1440,7 @@ add_dependance (temp_expr_table_p tab, int version, tree var)
   else
     {
       i = var_to_partition (tab->map, var);
-#ifdef ENABLE_CHECKING
-      if (i== NO_PARTITION)
-       abort ();
-#endif
+      gcc_assert (i != NO_PARTITION);
       add_value_to_list (tab, &(tab->partition_dep_list[i]), version);
       add_value_to_list (tab, 
                         (value_expr_p *)&(tab->version_info[version]), i);
@@ -1548,16 +1547,10 @@ finish_expr (temp_expr_table_p tab, int version, bool replace)
   for (info = (value_expr_p) tab->version_info[version]; info; info = tmp)
     {
       partition = info->value;
-#ifdef ENABLE_CHECKING
-      if (tab->partition_dep_list[partition] == NULL)
-        abort ();
-#endif
+      gcc_assert (tab->partition_dep_list[partition]);
       tmp = remove_value_from_list (&(tab->partition_dep_list[partition]), 
                                    version);
-#ifdef ENABLE_CHECKING
-      if (!tmp)
-        abort ();
-#endif
+      gcc_assert (tmp);
       free_value_expr (tab, tmp);
       /* Only clear the bit when the dependency list is emptied via 
          a replacement. Otherwise kill_expr will take care of it.  */
@@ -1575,10 +1568,7 @@ finish_expr (temp_expr_table_p tab, int version, bool replace)
     }
   else
     {
-#ifdef ENABLE_CHECKING
-      if (bitmap_bit_p (tab->replaceable, version))
-       abort ();
-#endif
+      gcc_assert (!bitmap_bit_p (tab->replaceable, version));
       tab->version_info[version] = NULL;
     }
 }
@@ -1858,7 +1848,7 @@ rewrite_trees (var_map map, tree *values)
                      print_generic_expr (stderr, arg, TDF_SLIM);
                      fprintf (stderr, "), but the result is not :");
                      print_generic_stmt (stderr, phi, TDF_SLIM);
-                     abort();
+                     internal_error ("SSA corruption");
                    }
                }
            }
index 5bf7736..712e3f9 100644 (file)
@@ -235,12 +235,9 @@ resize_phi_node (tree *phi, int len)
   int size, old_size;
   tree new_phi;
   int i, old_len, bucket = NUM_BUCKETS - 2;
-                                                                                
-#ifdef ENABLE_CHECKING
-  if (len < PHI_ARG_CAPACITY (*phi))
-    abort ();
-#endif
-                                                                                
+
+  gcc_assert (len >= PHI_ARG_CAPACITY (*phi));
+
   /* Note that OLD_SIZE is guaranteed to be smaller than SIZE.  */
   old_size = (sizeof (struct tree_phi_node)
             + (PHI_ARG_CAPACITY (*phi) - 1) * sizeof (struct phi_arg_d));
@@ -357,9 +354,7 @@ add_phi_arg (tree *phi, tree def, edge e)
                   p = PHI_CHAIN (p))
                ;
 
-             if (!p)
-               abort ();
-
+             gcc_assert (p);
              PHI_CHAIN (p) = *phi;
            }
        }
@@ -524,8 +519,7 @@ remove_all_phi_nodes_for (bitmap vars)
       for (phi = phi_nodes (bb); phi; phi = PHI_CHAIN (phi))
        {
          tree var = SSA_NAME_VAR (PHI_RESULT (phi));
-         if (bitmap_bit_p (vars, var_ann (var)->uid))
-           abort ();
+         gcc_assert (!bitmap_bit_p (vars, var_ann (var)->uid));
        }
 #endif
     }
index 0d1e540..af3a029 100644 (file)
@@ -1744,8 +1744,7 @@ op_prio (tree op)
 static const char *
 op_symbol (tree op)
 {
-  if (op == NULL)
-    abort ();
+  gcc_assert (op);
 
   switch (TREE_CODE (op))
     {
@@ -1882,8 +1881,7 @@ print_call_name (pretty_printer *buffer, tree node)
 {
   tree op0;
 
-  if (TREE_CODE (node) != CALL_EXPR)
-    abort ();
+  gcc_assert (TREE_CODE (node) == CALL_EXPR);
 
   op0 = TREE_OPERAND (node, 0);
 
index 582a6ec..29299e5 100644 (file)
@@ -99,7 +99,10 @@ tree_gen_interval_profiler (histogram_value value ATTRIBUTE_UNUSED,
                            unsigned base ATTRIBUTE_UNUSED)
 {
   /* FIXME implement this.  */
-  abort ();
+#ifdef ENABLE_CHECKING
+  internal_error ("unimplemented functionality");
+#endif
+  gcc_unreachable ();
 }
 
 /* Output instructions as GIMPLE trees to increment the power of two histogram 
@@ -112,7 +115,10 @@ tree_gen_pow2_profiler (histogram_value value ATTRIBUTE_UNUSED,
                        unsigned base ATTRIBUTE_UNUSED)
 {
   /* FIXME implement this.  */
-  abort ();
+#ifdef ENABLE_CHECKING
+  internal_error ("unimplemented functionality");
+#endif
+  gcc_unreachable ();
 }
 
 /* Output instructions as GIMPLE trees for code to find the most common value.
@@ -125,7 +131,10 @@ tree_gen_one_value_profiler (histogram_value value ATTRIBUTE_UNUSED,
                            unsigned base ATTRIBUTE_UNUSED)
 {
   /* FIXME implement this.  */
-  abort ();
+#ifdef ENABLE_CHECKING
+  internal_error ("unimplemented functionality");
+#endif
+  gcc_unreachable ();
 }
 
 /* Output instructions as GIMPLE trees for code to find the most common value 
@@ -139,7 +148,10 @@ tree_gen_const_delta_profiler (histogram_value value ATTRIBUTE_UNUSED,
                                unsigned base ATTRIBUTE_UNUSED)
 {
   /* FIXME implement this.  */
-  abort ();
+#ifdef ENABLE_CHECKING
+  internal_error ("unimplemented functionality");
+#endif
+  gcc_unreachable ();
 }
 
 /* Return 1 if tree-based profiling is in effect, else 0.
index 3e3da79..b8ec2e1 100644 (file)
@@ -329,7 +329,7 @@ type_can_instantiate_all_elements (tree type)
       return true;
 
     default:
-      abort ();
+      gcc_unreachable ();
     }
 }
 
@@ -379,7 +379,7 @@ sra_hash_tree (tree t)
       break;
 
     default:
-      abort ();
+      gcc_unreachable ();
     }
 
   return h;
@@ -446,7 +446,7 @@ sra_elt_eq (const void *x, const void *y)
       return fields_compatible_p (ae, be);
 
     default:
-      abort ();
+      gcc_unreachable ();
     }
 }
 
@@ -744,8 +744,7 @@ sra_walk_expr (tree *expr_p, block_stmt_iterator *bsi, bool is_output,
       default:
 #ifdef ENABLE_CHECKING
        /* Validate that we're not missing any references.  */
-       if (walk_tree (&inner, sra_find_candidate_decl, NULL, NULL))
-         abort ();
+       gcc_assert (!walk_tree (&inner, sra_find_candidate_decl, NULL, NULL));
 #endif
        return;
       }
@@ -1246,7 +1245,7 @@ instantiate_missing_elements (struct sra_elt *elt)
       break;
 
     default:
-      abort ();
+      gcc_unreachable ();
     }
 }
 
@@ -1438,7 +1437,7 @@ generate_one_element_ref (struct sra_elt *elt, tree base)
        return build (IMAGPART_EXPR, elt->type, base);
 
     default:
-      abort ();
+      gcc_unreachable ();
     }
 }
 
@@ -1495,8 +1494,7 @@ generate_element_copy (struct sra_elt *dst, struct sra_elt *src, tree *list_p)
   for (dc = dst->children; dc ; dc = dc->sibling)
     {
       sc = lookup_element (src, dc->element, NULL, NO_INSERT);
-      if (sc == NULL)
-       abort ();
+      gcc_assert (sc);
       generate_element_copy (dc, sc, list_p);
     }
 
@@ -1504,8 +1502,7 @@ generate_element_copy (struct sra_elt *dst, struct sra_elt *src, tree *list_p)
     {
       tree t;
 
-      if (src->replacement == NULL)
-       abort ();
+      gcc_assert (src->replacement);
 
       t = build (MODIFY_EXPR, void_type_node, dst->replacement,
                 src->replacement);
@@ -1536,11 +1533,8 @@ generate_element_zero (struct sra_elt *elt, tree *list_p)
     {
       tree t;
 
-      if (elt->is_scalar)
-       t = build_int_cst (elt->type, 0);
-      else
-       /* We generated a replacement for a non-scalar?  */
-       abort ();
+      gcc_assert (elt->is_scalar);
+      t = build_int_cst (elt->type, 0);
 
       t = build (MODIFY_EXPR, void_type_node, elt->replacement, t);
       append_to_statement_list (t, list_p);
@@ -1788,12 +1782,9 @@ scalarize_copy (struct sra_elt *lhs_elt, struct sra_elt *rhs_elt,
       /* If we have two scalar operands, modify the existing statement.  */
       stmt = bsi_stmt (*bsi);
 
-#ifdef ENABLE_CHECKING
       /* See the commentary in sra_walk_function concerning
         RETURN_EXPR, and why we should never see one here.  */
-      if (TREE_CODE (stmt) != MODIFY_EXPR)
-       abort ();
-#endif
+      gcc_assert (TREE_CODE (stmt) == MODIFY_EXPR);
 
       TREE_OPERAND (stmt, 0) = lhs_elt->replacement;
       TREE_OPERAND (stmt, 1) = rhs_elt->replacement;
@@ -1835,8 +1826,7 @@ scalarize_copy (struct sra_elt *lhs_elt, struct sra_elt *rhs_elt,
 
       list = NULL;
       generate_element_copy (lhs_elt, rhs_elt, &list);
-      if (list == NULL)
-       abort ();
+      gcc_assert (list);
       sra_replace (bsi, list);
     }
 }
@@ -1894,8 +1884,7 @@ scalarize_init (struct sra_elt *lhs_elt, tree rhs, block_stmt_iterator *bsi)
     {
       /* The LHS is fully instantiated.  The list of initializations
         replaces the original structure assignment.  */
-      if (!list)
-       abort ();
+      gcc_assert (list);
       mark_all_v_defs (bsi_stmt (*bsi));
       sra_replace (bsi, list);
     }
@@ -1929,8 +1918,7 @@ scalarize_ldst (struct sra_elt *elt, tree other,
                block_stmt_iterator *bsi, bool is_output)
 {
   /* Shouldn't have gotten called for a scalar.  */
-  if (elt->replacement)
-    abort ();
+  gcc_assert (!elt->replacement);
 
   if (elt->use_block_copy)
     {
@@ -1948,8 +1936,7 @@ scalarize_ldst (struct sra_elt *elt, tree other,
 
       mark_all_v_defs (stmt);
       generate_copy_inout (elt, is_output, other, &list);
-      if (list == NULL)
-       abort ();
+      gcc_assert (list);
 
       /* Preserve EH semantics.  */
       if (stmt_ends_bb_p (stmt))
index 4bd438b..70a4525 100644 (file)
@@ -486,10 +486,7 @@ delete_alias_info (struct alias_info *ai)
 static void
 collect_points_to_info_for (struct alias_info *ai, tree ptr)
 {
-#if defined ENABLE_CHECKING
-  if (!POINTER_TYPE_P (TREE_TYPE (ptr)))
-    abort ();
-#endif
+  gcc_assert (POINTER_TYPE_P (TREE_TYPE (ptr)));
 
   if (!bitmap_bit_p (ai->ssa_names_visited, SSA_NAME_VERSION (ptr)))
     {
@@ -1207,10 +1204,8 @@ group_aliases (struct alias_info *ai)
            {
              tree new_alias;
 
-#if defined ENABLE_CHECKING
-             if (VARRAY_ACTIVE_SIZE (ann->may_aliases) != 1)
-               abort ();
-#endif
+             gcc_assert (VARRAY_ACTIVE_SIZE (ann->may_aliases) == 1);
+
              new_alias = VARRAY_TREE (ann->may_aliases, 0);
              replace_may_alias (name_tag, j, new_alias);
            }
@@ -1546,10 +1541,7 @@ may_alias_p (tree ptr, HOST_WIDE_INT mem_alias_set,
   v_ann = var_ann (var);
   m_ann = var_ann (mem);
 
-#if defined ENABLE_CHECKING
-  if (m_ann->mem_tag_kind != TYPE_TAG)
-    abort ();
-#endif
+  gcc_assert (m_ann->mem_tag_kind == TYPE_TAG);
 
   alias_stats.tbaa_queries++;
 
@@ -1652,10 +1644,7 @@ add_may_alias (tree var, tree alias)
   var_ann_t v_ann = get_var_ann (var);
   var_ann_t a_ann = get_var_ann (alias);
 
-#if defined ENABLE_CHECKING
-  if (var == alias)
-    abort ();
-#endif
+  gcc_assert (var != alias);
 
   if (v_ann->may_aliases == NULL)
     VARRAY_TREE_INIT (v_ann->may_aliases, 2, "aliases");
@@ -1790,12 +1779,9 @@ add_pointed_to_expr (tree ptr, tree value)
   if (TREE_CODE (value) == WITH_SIZE_EXPR)
     value = TREE_OPERAND (value, 0);
 
-#if defined ENABLE_CHECKING
   /* Pointer variables should have been handled by merge_pointed_to_info.  */
-  if (TREE_CODE (value) == SSA_NAME
-      && POINTER_TYPE_P (TREE_TYPE (value)))
-    abort ();
-#endif
+  gcc_assert (TREE_CODE (value) != SSA_NAME
+             || !POINTER_TYPE_P (TREE_TYPE (value)));
 
   get_ptr_info (ptr);
 
@@ -1835,10 +1821,7 @@ add_pointed_to_var (struct alias_info *ai, tree ptr, tree value)
   tree pt_var;
   size_t uid;
 
-#if defined ENABLE_CHECKING
-  if (TREE_CODE (value) != ADDR_EXPR)
-    abort ();
-#endif
+  gcc_assert (TREE_CODE (value) == ADDR_EXPR);
 
   pt_var = TREE_OPERAND (value, 0);
   if (TREE_CODE_CLASS (TREE_CODE (pt_var)) == 'r')
@@ -1883,95 +1866,109 @@ collect_points_to_info_r (tree var, tree stmt, void *data)
       fprintf (dump_file, "\n");
     }
 
-  if (TREE_CODE (stmt) == MODIFY_EXPR)
+  switch (TREE_CODE (stmt))
     {
-      tree rhs = TREE_OPERAND (stmt, 1);
-      STRIP_NOPS (rhs);
-
-      /* Found P_i = ADDR_EXPR  */
-      if (TREE_CODE (rhs) == ADDR_EXPR)
-       add_pointed_to_var (ai, var, rhs);
-
-      /* Found P_i = Q_j.  */
-      else if (TREE_CODE (rhs) == SSA_NAME
-              && POINTER_TYPE_P (TREE_TYPE (rhs)))
-       merge_pointed_to_info (ai, var, rhs);
+    case MODIFY_EXPR:
+      {
+       tree rhs = TREE_OPERAND (stmt, 1);
+       STRIP_NOPS (rhs);
 
-      /* Found P_i = PLUS_EXPR or P_i = MINUS_EXPR  */
-      else if (TREE_CODE (rhs) == PLUS_EXPR
-              || TREE_CODE (rhs) == MINUS_EXPR)
-       {
-         tree op0 = TREE_OPERAND (rhs, 0);
-         tree op1 = TREE_OPERAND (rhs, 1);
+       /* Found P_i = ADDR_EXPR  */
+       if (TREE_CODE (rhs) == ADDR_EXPR)
+         add_pointed_to_var (ai, var, rhs);
 
-         /* Both operands may be of pointer type.  FIXME: Shouldn't
-            we just expect PTR + OFFSET always?  */
-         if (POINTER_TYPE_P (TREE_TYPE (op0)))
-           {
-             if (TREE_CODE (op0) == SSA_NAME)
-               merge_pointed_to_info (ai, var, op0);
-             else if (TREE_CODE (op0) == ADDR_EXPR)
-               add_pointed_to_var (ai, var, op0);
-             else
-               add_pointed_to_expr (var, op0);
-           }
-
-         if (POINTER_TYPE_P (TREE_TYPE (op1)))
-           {
-             if (TREE_CODE (op1) == SSA_NAME)
-               merge_pointed_to_info (ai, var, op1);
-             else if (TREE_CODE (op1) == ADDR_EXPR)
-               add_pointed_to_var (ai, var, op1);
-             else
-               add_pointed_to_expr (var, op1);
-           }
+       /* Found P_i = Q_j.  */
+       else if (TREE_CODE (rhs) == SSA_NAME
+                && POINTER_TYPE_P (TREE_TYPE (rhs)))
+         merge_pointed_to_info (ai, var, rhs);
 
-         /* Neither operand is a pointer?  VAR can be pointing
-            anywhere.   FIXME: Is this right?  If we get here, we
-            found PTR = INT_CST + INT_CST.  */
-         if (!POINTER_TYPE_P (TREE_TYPE (op0))
-             && !POINTER_TYPE_P (TREE_TYPE (op1)))
-           add_pointed_to_expr (var, rhs);
-       }
+       /* Found P_i = PLUS_EXPR or P_i = MINUS_EXPR  */
+       else if (TREE_CODE (rhs) == PLUS_EXPR
+                || TREE_CODE (rhs) == MINUS_EXPR)
+         {
+           tree op0 = TREE_OPERAND (rhs, 0);
+           tree op1 = TREE_OPERAND (rhs, 1);
+           
+           /* Both operands may be of pointer type.  FIXME: Shouldn't
+              we just expect PTR + OFFSET always?  */
+           if (POINTER_TYPE_P (TREE_TYPE (op0)))
+             {
+               if (TREE_CODE (op0) == SSA_NAME)
+                 merge_pointed_to_info (ai, var, op0);
+               else if (TREE_CODE (op0) == ADDR_EXPR)
+                 add_pointed_to_var (ai, var, op0);
+               else
+                 add_pointed_to_expr (var, op0);
+             }
+
+           if (POINTER_TYPE_P (TREE_TYPE (op1)))
+             {
+               if (TREE_CODE (op1) == SSA_NAME)
+                 merge_pointed_to_info (ai, var, op1);
+               else if (TREE_CODE (op1) == ADDR_EXPR)
+                 add_pointed_to_var (ai, var, op1);
+               else
+                 add_pointed_to_expr (var, op1);
+             }
+
+           /* Neither operand is a pointer?  VAR can be pointing
+              anywhere.  FIXME: Is this right?  If we get here, we
+              found PTR = INT_CST + INT_CST.  */
+           if (!POINTER_TYPE_P (TREE_TYPE (op0))
+               && !POINTER_TYPE_P (TREE_TYPE (op1)))
+             add_pointed_to_expr (var, rhs);
+         }
 
-      /* Something else.  */
-      else
-       add_pointed_to_expr (var, rhs);
-    }
-  else if (TREE_CODE (stmt) == ASM_EXPR)
-    {
+       /* Something else.  */
+       else
+         add_pointed_to_expr (var, rhs);
+       break;
+      }
+    case ASM_EXPR:
       /* Pointers defined by __asm__ statements can point anywhere.  */
       set_pt_anything (var);
-    }
-  else if (IS_EMPTY_STMT (stmt))
-    {
-      tree decl = SSA_NAME_VAR (var);
+      break;
 
-      if (TREE_CODE (decl) == PARM_DECL)
-       add_pointed_to_expr (var, decl);
-      else if (DECL_INITIAL (decl))
-       add_pointed_to_var (ai, var, DECL_INITIAL (decl));
-      else
-       add_pointed_to_expr (var, decl);
-    }
-  else if (TREE_CODE (stmt) == PHI_NODE)
-    {
-      /* It STMT is a PHI node, then VAR is one of its arguments.  The
-        variable that we are analyzing is the LHS of the PHI node.  */
-      tree lhs = PHI_RESULT (stmt);
-
-      if (TREE_CODE (var) == ADDR_EXPR)
-       add_pointed_to_var (ai, lhs, var);
-      else if (TREE_CODE (var) == SSA_NAME)
-       merge_pointed_to_info (ai, lhs, var);
-      else if (is_gimple_min_invariant (var))
-       add_pointed_to_expr (lhs, var);
-      else
-       abort ();
-    }
-  else
-    abort ();
+    case NOP_EXPR:
+      if (IS_EMPTY_STMT (stmt))
+       {
+         tree decl = SSA_NAME_VAR (var);
+         
+         if (TREE_CODE (decl) == PARM_DECL)
+           add_pointed_to_expr (var, decl);
+         else if (DECL_INITIAL (decl))
+           add_pointed_to_var (ai, var, DECL_INITIAL (decl));
+         else
+           add_pointed_to_expr (var, decl);
+       }
+      break;
+    case PHI_NODE:
+      {
+        /* It STMT is a PHI node, then VAR is one of its arguments.  The
+          variable that we are analyzing is the LHS of the PHI node.  */
+       tree lhs = PHI_RESULT (stmt);
 
+       switch (TREE_CODE (var))
+         {
+         case ADDR_EXPR:
+           add_pointed_to_var (ai, lhs, var);
+           break;
+           
+         case SSA_NAME:
+           merge_pointed_to_info (ai, lhs, var);
+           break;
+           
+         default:
+           gcc_assert (is_gimple_min_invariant (var));
+           add_pointed_to_expr (lhs, var);
+           break;
+         }
+       break;
+      }
+    default:
+      gcc_unreachable ();
+    }
+  
   return false;
 }
 
@@ -2154,13 +2151,9 @@ get_tmt_for (tree ptr, struct alias_info *ai)
       ai->pointers[ai->num_pointers++] = alias_map;
     }
 
-#if defined ENABLE_CHECKING
   /* Make sure that the type tag has the same alias set as the
      pointed-to type.  */
-  if (tag_set != get_alias_set (tag))
-    abort ();
-#endif
-
+  gcc_assert (tag_set == get_alias_set (tag));
 
   return tag;
 }
@@ -2297,10 +2290,7 @@ get_ptr_info (tree t)
 {
   struct ptr_info_def *pi;
 
-#if defined ENABLE_CHECKING
-  if (!POINTER_TYPE_P (TREE_TYPE (t)))
-    abort ();
-#endif
+  gcc_assert (POINTER_TYPE_P (TREE_TYPE (t)));
 
   pi = SSA_NAME_PTR_INFO (t);
   if (pi == NULL)
index b1b74b1..ddde45d 100644 (file)
@@ -99,7 +99,7 @@ dump_lattice_value (FILE *outf, const char *prefix, value val)
       print_generic_expr (outf, val.const_val, dump_flags);
       break;
     default:
-      abort ();
+      gcc_unreachable ();
     }
 }
 
@@ -128,10 +128,7 @@ get_default_value (tree var)
     sym = SSA_NAME_VAR (var);
   else
     {
-#ifdef ENABLE_CHECKING
-      if (!DECL_P (var))
-       abort ();
-#endif
+      gcc_assert (DECL_P (var));
       sym = var;
     }
 
@@ -188,10 +185,7 @@ get_value (tree var)
 {
   value *val;
 
-#if defined ENABLE_CHECKING
-  if (TREE_CODE (var) != SSA_NAME)
-    abort ();
-#endif
+  gcc_assert (TREE_CODE (var) == SSA_NAME);
 
   val = &value_vector[SSA_NAME_VERSION (var)];
   if (val->lattice_val == UNINITIALIZED)
@@ -209,32 +203,24 @@ set_lattice_value (tree var, value val)
 {
   value *old = get_value (var);
 
-#ifdef ENABLE_CHECKING
   if (val.lattice_val == UNDEFINED)
     {
       /* CONSTANT->UNDEFINED is never a valid state transition.  */
-      if (old->lattice_val == CONSTANT)
-       abort ();
+      gcc_assert (old->lattice_val != CONSTANT);
        
       /* UNKNOWN_VAL->UNDEFINED is never a valid state transition.  */
-      if (old->lattice_val == UNKNOWN_VAL)
-       abort ();
+      gcc_assert (old->lattice_val != UNKNOWN_VAL);
 
       /* VARYING->UNDEFINED is generally not a valid state transition,
         except for values which are initialized to VARYING.  */
-      if (old->lattice_val == VARYING
-         && get_default_value (var).lattice_val != VARYING)
-       abort ();
+      gcc_assert (old->lattice_val != VARYING
+                 || get_default_value (var).lattice_val == VARYING);
     }
   else if (val.lattice_val == CONSTANT)
-    {
-      /* VARYING -> CONSTANT is an invalid state transition, except
-        for objects which start off in a VARYING state.  */
-      if (old->lattice_val == VARYING
-         && get_default_value (var).lattice_val != VARYING)
-       abort ();
-    }
-#endif
+    /* VARYING -> CONSTANT is an invalid state transition, except
+       for objects which start off in a VARYING state.  */
+    gcc_assert (old->lattice_val == VARYING
+               || get_default_value (var).lattice_val != VARYING);
 
   /* If the constant for VAR has changed, then this VAR is really varying.  */
   if (old->lattice_val == CONSTANT
@@ -326,11 +312,8 @@ likely_value (tree stmt)
       if (val->lattice_val == UNKNOWN_VAL)
         return UNKNOWN_VAL;
        
-#ifdef ENABLE_CHECKING
-  /* There should be no VUSE operands that are UNDEFINED.  */
-  if (val->lattice_val == UNDEFINED)
-    abort ();
-#endif
+      /* There should be no VUSE operands that are UNDEFINED.  */
+      gcc_assert (val->lattice_val != UNDEFINED);
        
       if (val->lattice_val == CONSTANT)
        found_constant = 1;
@@ -719,7 +702,7 @@ ccp_visit_phi_node (tree phi)
       break;
 
     default:
-      abort ();
+      gcc_unreachable ();
     }
 
   for (i = 0; i < PHI_NUM_ARGS (phi); i++)
@@ -1016,12 +999,9 @@ visit_assignment (tree stmt, tree *output_p)
   vuses = STMT_VUSE_OPS (stmt);
   v_must_defs = STMT_V_MUST_DEF_OPS (stmt);
 
-#if defined ENABLE_CHECKING
-  if (NUM_V_MAY_DEFS (STMT_V_MAY_DEF_OPS (stmt)) > 0
-      || (NUM_V_MUST_DEFS (v_must_defs) != 1
-          && TREE_CODE (lhs) != SSA_NAME))
-    abort ();
-#endif
+  gcc_assert (NUM_V_MAY_DEFS (STMT_V_MAY_DEF_OPS (stmt)) == 0);
+  gcc_assert (NUM_V_MUST_DEFS (v_must_defs) == 1
+             || TREE_CODE (lhs) == SSA_NAME);
 
   /* We require the SSA version number of the lhs for the value_vector.
      Make sure we have it.  */
@@ -1250,10 +1230,7 @@ widen_bitfield (tree val, tree field, tree var)
   if (field_size > HOST_BITS_PER_WIDE_INT || var_size > HOST_BITS_PER_WIDE_INT)
     return NULL_TREE;
 
-#if defined ENABLE_CHECKING
-  if (var_size < field_size)
-    abort ();
-#endif
+  gcc_assert (var_size >= field_size);
 
   /* If the sign bit of the value is not set or the field's type is unsigned,
      just mask off the high order bits of the value.  */
@@ -2000,7 +1977,7 @@ ccp_fold_builtin (tree stmt, tree fn)
       break;
 
     default:
-      abort ();
+      gcc_unreachable ();
     }
 
   if (result && ignore)
index 1a760ec..7b27c68 100644 (file)
@@ -131,8 +131,7 @@ may_propagate_copy (tree dest, tree orig)
 #ifdef ENABLE_CHECKING
          /* If we have one real and one virtual operand, then something has
             gone terribly wrong.  */
-         if (is_gimple_reg (orig))
-           abort ();
+         gcc_assert (!is_gimple_reg (orig));
 #endif
        }
 
@@ -170,18 +169,17 @@ merge_alias_info (tree orig, tree new)
   var_ann_t new_ann = var_ann (new_sym);
   var_ann_t orig_ann = var_ann (orig_sym);
 
+  gcc_assert (POINTER_TYPE_P (TREE_TYPE (orig)));
+  gcc_assert (POINTER_TYPE_P (TREE_TYPE (new)));
 #if defined ENABLE_CHECKING
-  if (!POINTER_TYPE_P (TREE_TYPE (orig))
-      || !POINTER_TYPE_P (TREE_TYPE (new))
-      || !lang_hooks.types_compatible_p (TREE_TYPE (orig), TREE_TYPE (new)))
-    abort ();
+  gcc_assert (lang_hooks.types_compatible_p (TREE_TYPE (orig),
+                                            TREE_TYPE (new)));
 
   /* If the pointed-to alias sets are different, these two pointers
      would never have the same memory tag.  In this case, NEW should
      not have been propagated into ORIG.  */
-  if (get_alias_set (TREE_TYPE (TREE_TYPE (new_sym)))
-      != get_alias_set (TREE_TYPE (TREE_TYPE (orig_sym))))
-    abort ();
+  gcc_assert (get_alias_set (TREE_TYPE (TREE_TYPE (new_sym)))
+             == get_alias_set (TREE_TYPE (TREE_TYPE (orig_sym))));
 #endif
 
   /* Merge type-based alias info.  */
@@ -189,8 +187,8 @@ merge_alias_info (tree orig, tree new)
     new_ann->type_mem_tag = orig_ann->type_mem_tag;
   else if (orig_ann->type_mem_tag == NULL_TREE)
     orig_ann->type_mem_tag = new_ann->type_mem_tag;
-  else if (new_ann->type_mem_tag != orig_ann->type_mem_tag)
-    abort ();
+  else
+    gcc_assert (new_ann->type_mem_tag == orig_ann->type_mem_tag);
 }
 
 
@@ -206,11 +204,10 @@ replace_exp_1 (use_operand_p op_p, tree val,
   tree op = USE_FROM_PTR (op_p);
 
 #if defined ENABLE_CHECKING
-  if (for_propagation
-      && TREE_CODE (op) == SSA_NAME
-      && TREE_CODE (val) == SSA_NAME
-      && !may_propagate_copy (op, val))
-    abort ();
+  gcc_assert (!(for_propagation
+               && TREE_CODE (op) == SSA_NAME
+               && TREE_CODE (val) == SSA_NAME
+               && !may_propagate_copy (op, val)));
 #endif
 
   if (TREE_CODE (val) == SSA_NAME)
@@ -249,10 +246,9 @@ void
 propagate_tree_value (tree *op_p, tree val)
 {
 #if defined ENABLE_CHECKING
-  if (TREE_CODE (val) == SSA_NAME
-      && TREE_CODE (*op_p) == SSA_NAME
-      && !may_propagate_copy (*op_p, val))
-    abort ();
+  gcc_assert (!(TREE_CODE (val) == SSA_NAME
+               && TREE_CODE (*op_p) == SSA_NAME
+               && !may_propagate_copy (*op_p, val)));
 #endif
 
   if (TREE_CODE (val) == SSA_NAME)
index db85d9c..e38b77a 100644 (file)
@@ -120,10 +120,8 @@ copy_rename_partition_coalesce (var_map map, tree var1, tree var2, FILE *debug)
   var_ann_t ann1, ann2, ann3;
   bool ign1, ign2;
 
-#ifdef ENABLE_CHECKING
-  if (TREE_CODE (var1) != SSA_NAME || TREE_CODE (var2) != SSA_NAME)
-    abort ();
-#endif
+  gcc_assert (TREE_CODE (var1) == SSA_NAME);
+  gcc_assert (TREE_CODE (var2) == SSA_NAME);
 
   register_ssa_partition (map, var1, false);
   register_ssa_partition (map, var2, true);
@@ -140,10 +138,8 @@ copy_rename_partition_coalesce (var_map map, tree var1, tree var2, FILE *debug)
       fprintf (debug, "(P%d)", p2);
     }
 
-#ifdef ENABLE_CHECKING
-  if (p1 == NO_PARTITION || p2 == NO_PARTITION)
-    abort ();
-#endif
+  gcc_assert (p1 != NO_PARTITION);
+  gcc_assert (p2 != NO_PARTITION);
 
   root1 = SSA_NAME_VAR (partition_to_var (map, p1));
   root2 = SSA_NAME_VAR (partition_to_var (map, p2));
index b1d9365..ccfa0f5 100644 (file)
@@ -127,8 +127,7 @@ set_control_dependence_map_bit (basic_block bb, int edge_index)
 {
   if (bb == ENTRY_BLOCK_PTR)
     return;
-  if (bb == EXIT_BLOCK_PTR)
-    abort ();
+  gcc_assert (bb != EXIT_BLOCK_PTR);
   bitmap_set_bit (control_dependence_map[bb->index], edge_index);
 }
 
@@ -160,10 +159,7 @@ find_control_dependence (struct edge_list *el, int edge_index)
   basic_block current_block;
   basic_block ending_block;
 
-#ifdef ENABLE_CHECKING
-  if (INDEX_EDGE_PRED_BB (el, edge_index) == EXIT_BLOCK_PTR)
-    abort ();
-#endif
+  gcc_assert (INDEX_EDGE_PRED_BB (el, edge_index) != EXIT_BLOCK_PTR);
 
   if (INDEX_EDGE_PRED_BB (el, edge_index) == ENTRY_BLOCK_PTR)
     ending_block = ENTRY_BLOCK_PTR->next_bb;
@@ -192,9 +188,9 @@ find_control_dependence (struct edge_list *el, int edge_index)
 static inline basic_block
 find_pdom (basic_block block)
 {
-  if (block == ENTRY_BLOCK_PTR)
-    abort ();
-  else if (block == EXIT_BLOCK_PTR)
+  gcc_assert (block != ENTRY_BLOCK_PTR);
+
+  if (block == EXIT_BLOCK_PTR)
     return EXIT_BLOCK_PTR;
   else
     {
@@ -212,12 +208,9 @@ find_pdom (basic_block block)
 static inline void
 mark_stmt_necessary (tree stmt, bool add_to_worklist)
 {
-#ifdef ENABLE_CHECKING
-  if (stmt == NULL
-      || stmt == error_mark_node
-      || (stmt && DECL_P (stmt)))
-    abort ();
-#endif
+  gcc_assert (stmt);
+  gcc_assert (stmt != error_mark_node);
+  gcc_assert (!DECL_P (stmt));
 
   if (NECESSARY (stmt))
     return;
@@ -242,10 +235,7 @@ mark_operand_necessary (tree op)
   tree stmt;
   int ver;
 
-#ifdef ENABLE_CHECKING
-  if (op == NULL)
-    abort ();
-#endif
+  gcc_assert (op);
 
   ver = SSA_NAME_VERSION (op);
   if (TEST_BIT (processed, ver))
@@ -253,10 +243,7 @@ mark_operand_necessary (tree op)
   SET_BIT (processed, ver);
 
   stmt = SSA_NAME_DEF_STMT (op);
-#ifdef ENABLE_CHECKING
-  if (stmt == NULL)
-    abort ();
-#endif
+  gcc_assert (stmt);
 
   if (NECESSARY (stmt)
       || IS_EMPTY_STMT (stmt))
@@ -387,10 +374,7 @@ mark_stmt_if_obviously_necessary (tree stmt, bool aggressive)
     {
       tree lhs;
 
-#if defined ENABLE_CHECKING
-      if (TREE_CODE (stmt) != MODIFY_EXPR)
-       abort ();
-#endif
+      gcc_assert (TREE_CODE (stmt) == MODIFY_EXPR);
 
       /* Note that we must not check the individual virtual operands
         here.  In particular, if this is an aliased store, we could
@@ -451,7 +435,7 @@ mark_stmt_if_obviously_necessary (tree stmt, bool aggressive)
            }
        }
       else
-       abort ();
+       gcc_unreachable ();
     }
 
   return;
@@ -526,10 +510,7 @@ mark_control_dependent_edges_necessary (basic_block bb, struct edge_list *el)
 {
   int edge_number;
 
-#ifdef ENABLE_CHECKING
-  if (bb == EXIT_BLOCK_PTR)
-    abort ();
-#endif
+  gcc_assert (bb != EXIT_BLOCK_PTR);
 
   if (bb == ENTRY_BLOCK_PTR)
     return;
@@ -742,11 +723,8 @@ remove_dead_stmt (block_stmt_iterator *i, basic_block bb)
     {
       basic_block post_dom_bb;
       edge e;
-#ifdef ENABLE_CHECKING
       /* The post dominance info has to be up-to-date.  */
-      if (dom_computed[CDI_POST_DOMINATORS] != DOM_OK)
-       abort ();
-#endif
+      gcc_assert (dom_computed[CDI_POST_DOMINATORS] == DOM_OK);
       /* Get the immediate post dominator of bb.  */
       post_dom_bb = get_immediate_dominator (CDI_POST_DOMINATORS, bb);
       /* Some blocks don't have an immediate post dominator.  This can happen
index c644e4a..7b1c3ac 100644 (file)
@@ -715,7 +715,6 @@ dom_opt_initialize_block_local_data (struct dom_walk_data *walk_data ATTRIBUTE_U
                                     basic_block bb ATTRIBUTE_UNUSED,
                                     bool recycled ATTRIBUTE_UNUSED)
 {
-#ifdef ENABLE_CHECKING
   struct dom_walk_block_data *bd
     = (struct dom_walk_block_data *)VARRAY_TOP_GENERIC_PTR (walk_data->block_data_stack);
 
@@ -725,20 +724,19 @@ dom_opt_initialize_block_local_data (struct dom_walk_data *walk_data ATTRIBUTE_U
      make sure we clear them before using them!  */
   if (recycled)
     {
-      if (bd->avail_exprs && VARRAY_ACTIVE_SIZE (bd->avail_exprs) > 0)
-       abort ();
-      if (bd->const_and_copies && VARRAY_ACTIVE_SIZE (bd->const_and_copies) > 0)
-       abort ();
-      if (bd->nonzero_vars && VARRAY_ACTIVE_SIZE (bd->nonzero_vars) > 0)
-       abort ();
-      if (bd->stmts_to_rescan && VARRAY_ACTIVE_SIZE (bd->stmts_to_rescan) > 0)
-       abort ();
-      if (bd->vrp_variables && VARRAY_ACTIVE_SIZE (bd->vrp_variables) > 0)
-       abort ();
-      if (bd->block_defs && VARRAY_ACTIVE_SIZE (bd->block_defs) > 0)
-       abort ();
+      gcc_assert (!bd->avail_exprs
+                 || VARRAY_ACTIVE_SIZE (bd->avail_exprs) == 0);
+      gcc_assert (!bd->const_and_copies
+                 || VARRAY_ACTIVE_SIZE (bd->const_and_copies) == 0);
+      gcc_assert (!bd->nonzero_vars
+                 || VARRAY_ACTIVE_SIZE (bd->nonzero_vars) == 0);
+      gcc_assert (!bd->stmts_to_rescan
+                 || VARRAY_ACTIVE_SIZE (bd->stmts_to_rescan) == 0);
+      gcc_assert (!bd->vrp_variables
+                 || VARRAY_ACTIVE_SIZE (bd->vrp_variables) == 0);
+      gcc_assert (!bd->block_defs
+                 || VARRAY_ACTIVE_SIZE (bd->block_defs) == 0);
     }
-#endif
 }
 
 /* Initialize local stacks for this optimizer and record equivalences
@@ -2216,8 +2214,7 @@ simplify_switch_and_lookup_avail_expr (tree stmt,
 
 #ifdef ENABLE_CHECKING
              /* ??? Why was Jeff testing this?  We are gimple...  */
-             if (!is_gimple_val (def))
-               abort ();
+             gcc_assert (is_gimple_val (def));
 #endif
 
              to = TREE_TYPE (cond);
@@ -2316,12 +2313,9 @@ cprop_into_successor_phis (basic_block bb,
              hint = i;
            }
 
-#ifdef ENABLE_CHECKING
          /* If we did not find the proper alternative, then something is
             horribly wrong.  */
-         if (hint == phi_num_args)
-           abort ();
-#endif
+         gcc_assert (hint != phi_num_args);
 
          /* The alternative may be associated with a constant, so verify
             it is an SSA_NAME before doing anything with it.  */
@@ -2447,9 +2441,8 @@ eliminate_redundant_computations (struct dom_walk_data *walk_data,
       opt_stats.num_re++;
 
 #if defined ENABLE_CHECKING
-      if (TREE_CODE (cached_lhs) != SSA_NAME
-         && !is_gimple_min_invariant (cached_lhs))
-       abort ();
+      gcc_assert (TREE_CODE (cached_lhs) == SSA_NAME
+                 || is_gimple_min_invariant (cached_lhs));
 #endif
 
       if (TREE_CODE (cached_lhs) == ADDR_EXPR
@@ -3333,11 +3326,8 @@ avail_expr_eq (const void *p1, const void *p2)
        if (VUSE_OP (ops1, i) != VUSE_OP (ops2, i))
          return false;
 
-#ifdef ENABLE_CHECKING
-      if (((struct expr_hash_elt *)p1)->hash
-         != ((struct expr_hash_elt *)p2)->hash)
-       abort ();
-#endif
+      gcc_assert (((struct expr_hash_elt *)p1)->hash
+                 == ((struct expr_hash_elt *)p2)->hash);
       return true;
     }
 
index 558d50d..820b2c6 100644 (file)
@@ -169,13 +169,9 @@ fix_stmt_v_may_defs (tree stmt1, tree stmt2)
            }
        }
 
-#ifdef ENABLE_CHECKING
       /* If we did not find a corresponding V_MAY_DEF_RESULT, then something
         has gone terribly wrong.  */
-      if (j == NUM_V_MAY_DEFS (v_may_defs2))
-       abort ();
-#endif
-
+      gcc_assert (j != NUM_V_MAY_DEFS (v_may_defs2));
     }
 }
 
index 014ec2d..d65d6fb 100644 (file)
@@ -38,6 +38,7 @@ Boston, MA 02111-1307, USA.  */
 #include "hashtab.h"
 #include "tree-dump.h"
 #include "tree-ssa-live.h"
+#include "errors.h"
 
 static void live_worklist (tree_live_info_p, varray_type, int);
 static tree_live_info_p new_tree_live_info (var_map);
@@ -144,8 +145,8 @@ var_union (var_map map, tree var1, tree var2)
        other_var = var2;
     }
 
-  if (p1 == NO_PARTITION || p2 == NO_PARTITION)
-    abort ();
+  gcc_assert (p1 != NO_PARTITION);
+  gcc_assert (p2 != NO_PARTITION);
 
   if (p1 == p2)
     p3 = p1;
@@ -274,8 +275,7 @@ change_partition_var (var_map map, tree var, int part)
 {
   var_ann_t ann;
 
-  if (TREE_CODE (var) == SSA_NAME)
-    abort();
+  gcc_assert (TREE_CODE (var) != SSA_NAME);
 
   ann = var_ann (var);
   ann->out_of_ssa_tag = 1;
@@ -415,7 +415,7 @@ create_ssa_var_map (int flags)
        EXECUTE_IF_SET_IN_SBITMAP (both, 0, i,
          fprintf (stderr, "Variable %s used in real and virtual operands\n",
                   get_name (referenced_var (i))));
-       abort ();
+       internal_error ("SSA corruption");
       }
 
     sbitmap_free (used_in_real_ops);
@@ -715,8 +715,7 @@ calculate_live_on_entry (var_map map)
              }
        }
     }
-  if (num > 0)
-    abort ();
+  gcc_assert (num <= 0);
 #endif
 
   BITMAP_XFREE (saw_def);
@@ -943,10 +942,7 @@ root_var_init (var_map map)
 
       p = var_to_partition (map, t);
 
-#ifdef ENABLE_CHECKING
-      if (p == NO_PARTITION)
-        abort ();
-#endif
+      gcc_assert (p != NO_PARTITION);
 
       /* Make sure we only put coalesced partitions into the list once.  */
       if (TEST_BIT (seen, p))
@@ -1019,10 +1015,7 @@ type_var_init (var_map map)
 
       p = var_to_partition (map, t);
 
-#ifdef ENABLE_CHECKING
-      if (p == NO_PARTITION)
-        abort ();
-#endif
+      gcc_assert (p != NO_PARTITION);
 
       /* If partitions have been coalesced, only add the representative 
         for the partition to the list once.  */
@@ -1143,10 +1136,7 @@ add_coalesce (coalesce_list_p cl, int p1, int p2, int value)
 {
   partition_pair_p node;
 
-#ifdef ENABLE_CHECKING
-  if (!cl->add_mode)
-    abort();
-#endif
+  gcc_assert (cl->add_mode);
 
   if (p1 == p2)
     return;
@@ -1177,8 +1167,7 @@ sort_coalesce_list (coalesce_list_p cl)
   partition_pair_p chain, p;
   partition_pair_p  *list;
 
-  if (!cl->add_mode)
-    abort();
+  gcc_assert (cl->add_mode);
 
   cl->add_mode = false;
 
@@ -1204,10 +1193,7 @@ sort_coalesce_list (coalesce_list_p cl)
       for (p = chain; p != NULL; p = p->next)
        list[count++] = p;
 
-#ifdef ENABLE_CHECKING
-  if (count != num)
-    abort ();
-#endif
+      gcc_assert (count == num);
        
       qsort (list, count, sizeof (partition_pair_p), compare_pairs);
 
@@ -1248,8 +1234,7 @@ pop_best_coalesce (coalesce_list_p cl, int *p1, int *p2)
   partition_pair_p node;
   int ret;
 
-  if (cl->add_mode)
-    abort();
+  gcc_assert (!cl->add_mode);
 
   node = cl->list[0];
   if (!node)
@@ -1793,3 +1778,18 @@ dump_live_info (FILE *f, tree_live_info_p live, int flag)
        }
     }
 }
+
+#ifdef ENABLE_CHECKING
+void
+register_ssa_partition_check (tree ssa_var)
+{
+  gcc_assert (TREE_CODE (ssa_var) == SSA_NAME);
+  if (!is_gimple_reg (SSA_NAME_VAR (ssa_var)))
+    {
+      fprintf (stderr, "Illegally registering a virtual SSA name :");
+      print_generic_expr (stderr, ssa_var, TDF_SLIM);
+      fprintf (stderr, " in the SSA->Normal phase.\n");
+      internal_error ("SSA corruption");
+    }
+}
+#endif
index b863795..eb93305 100644 (file)
@@ -65,6 +65,9 @@ extern int var_union (var_map, tree, tree);
 extern void change_partition_var (var_map, tree, int);
 extern void compact_var_map (var_map, int);
 extern tree make_ssa_temp (tree);
+#ifdef ENABLE_CHECKING
+extern void register_ssa_partition_check (tree ssa_var);
+#endif
 
 static inline int num_var_partitions (var_map);
 static inline tree var_to_partition_to_var (var_map, tree);
@@ -77,7 +80,6 @@ static inline void register_ssa_partition (var_map, tree, bool);
 #define SSA_VAR_MAP_REF_COUNT   0x01
 extern var_map create_ssa_var_map (int);
 
-
 /* Number of partitions in MAP.  */
 
 static inline int 
@@ -93,10 +95,7 @@ static inline int
 version_ref_count (var_map map, tree ssa_var)
 {
   int version = SSA_NAME_VERSION (ssa_var);
-#ifdef ENABLE_CHECKING
-  if (!map->ref_count)
-    abort ();
-#endif
+  gcc_assert (map->ref_count);
   return map->ref_count[version];
 }
  
@@ -182,16 +181,7 @@ register_ssa_partition (var_map map, tree ssa_var, bool is_use)
   int version;
 
 #if defined ENABLE_CHECKING
-  if (TREE_CODE (ssa_var) != SSA_NAME)
-    abort ();
-
-  if (!is_gimple_reg (SSA_NAME_VAR (ssa_var)))
-    {
-      fprintf (stderr, "Illegally registering a virtual SSA name :");
-      print_generic_expr (stderr, ssa_var, TDF_SLIM);
-      fprintf (stderr, " in the SSA->Normal phase.\n");
-      abort();
-    }
+  register_ssa_partition_check (ssa_var);
 #endif
 
   version = SSA_NAME_VERSION (ssa_var);
@@ -274,9 +264,7 @@ static inline void make_live_on_entry (tree_live_info_p, basic_block, int);
 static inline int
 partition_is_global (tree_live_info_p live, int p)
 {
-  if (!live->global)
-    abort ();
-
+  gcc_assert (live->global);
   return bitmap_bit_p (live->global, p);
 }
 
@@ -287,9 +275,7 @@ partition_is_global (tree_live_info_p live, int p)
 static inline bitmap
 live_entry_blocks (tree_live_info_p live, int p)
 {
-  if (!live->livein)
-    abort ();
-
+  gcc_assert (live->livein);
   return live->livein[p];
 }
 
@@ -300,12 +286,10 @@ live_entry_blocks (tree_live_info_p live, int p)
 static inline bitmap
 live_on_exit (tree_live_info_p live, basic_block bb)
 {
-  if (!live->liveout)
-    abort();
+  gcc_assert (live->liveout);
+  gcc_assert (bb != ENTRY_BLOCK_PTR);
+  gcc_assert (bb != EXIT_BLOCK_PTR);
 
-  if (bb == ENTRY_BLOCK_PTR || bb == EXIT_BLOCK_PTR)
-    abort ();
-  
   return live->liveout[bb->index];
 }
 
@@ -428,10 +412,7 @@ tpa_find_tree (tpa_p tpa, int i)
      a compressed element, so return TPA_NONE.  */
   if (index != TPA_NONE && index >= tpa_num_trees (tpa))
     {
-#ifdef ENABLE_CHECKING
-      if (tpa->uncompressed_num == -1)
-        abort ();
-#endif
+      gcc_assert (tpa->uncompressed_num != -1);
       index = TPA_NONE;
     }
 
@@ -444,10 +425,7 @@ tpa_find_tree (tpa_p tpa, int i)
 static inline void 
 tpa_decompact(tpa_p tpa)
 {
-#ifdef ENABLE_CHECKING
-  if (tpa->uncompressed_num == -1)
-    abort ();
-#endif
+  gcc_assert (tpa->uncompressed_num != -1);
   tpa->num_trees = tpa->uncompressed_num;
 }
 
index f815c3c..a03dabd 100644 (file)
@@ -59,8 +59,7 @@ should_duplicate_loop_header_p (basic_block header, struct loop *loop,
   if (header->aux)
     return false;
 
-  if (!header->succ)
-    abort ();
+  gcc_assert (header->succ);
   if (!header->succ->succ_next)
     return false;
   if (header->succ->succ_next->succ_next)
@@ -118,8 +117,7 @@ duplicate_blocks (varray_type bbs_to_duplicate)
       preheader_edge = VARRAY_GENERIC_PTR_NOGC (bbs_to_duplicate, i);
       header = preheader_edge->dest;
 
-      if (!header->aux)
-       abort ();
+      gcc_assert (header->aux);
       header->aux = NULL;
 
       new_header = duplicate_block (header, preheader_edge);
index d05617d..c0d2c00 100644 (file)
@@ -150,7 +150,7 @@ for_each_index (tree *addr_p, bool (*cbck) (tree, tree *, void *), void *data)
          return true;
 
        default:
-         abort ();
+         gcc_unreachable ();
        }
     }
 }
@@ -438,12 +438,9 @@ set_level (tree stmt, struct loop *orig_loop, struct loop *level)
   if (flow_loop_nested_p (stmt_loop, level))
     return;
 
-  if (!LIM_DATA (stmt))
-    abort ();
-
-  if (level != LIM_DATA (stmt)->max_loop
-      && !flow_loop_nested_p (LIM_DATA (stmt)->max_loop, level))
-    abort ();
+  gcc_assert (LIM_DATA (stmt));
+  gcc_assert (level == LIM_DATA (stmt)->max_loop
+             || flow_loop_nested_p (LIM_DATA (stmt)->max_loop, level));
 
   LIM_DATA (stmt)->tgt_loop = level;
   for (dep = LIM_DATA (stmt)->depends; dep; dep = dep->next)
@@ -1106,7 +1103,7 @@ is_call_clobbered_ref (tree ref)
       return false;
     }
 
-  abort ();
+  gcc_unreachable ();
 }
 
 /* Determine whether all memory references inside LOOP corresponding to the
index c5b6e40..fd0250b 100644 (file)
@@ -355,7 +355,7 @@ dump_use (FILE *file, struct iv_use *use)
       break;
 
     default:
-      abort ();
+      gcc_unreachable ();
     }
 
    fprintf (file, "  in statement ");
@@ -513,8 +513,7 @@ divide (unsigned bits, unsigned HOST_WIDE_INT a, unsigned HOST_WIDE_INT b,
 
   val = (a * inv) & mask;
 
-  if (((val * b) & mask) != a)
-    abort ();
+  gcc_assert (((val * b) & mask) == a);
 
   if ((val >> (bits - 1)) & 1)
     val |= ~mask;
@@ -532,8 +531,7 @@ stmt_after_ip_normal_pos (struct loop *loop, tree stmt)
 {
   basic_block bb = ip_normal_pos (loop), sbb = bb_for_stmt (stmt);
 
-  if (!bb)
-    abort ();
+  gcc_assert (bb);
 
   if (sbb == loop->latch)
     return true;
@@ -589,7 +587,7 @@ stmt_after_increment (struct loop *loop, struct iv_cand *cand, tree stmt)
       return stmt_after_ip_original_pos (cand, stmt);
 
     default:
-      abort ();
+      gcc_unreachable ();
     }
 }
 
@@ -644,8 +642,7 @@ set_iv (struct ivopts_data *data, tree iv, tree base, tree step)
 {
   struct version_info *info = name_info (data, iv);
 
-  if (info->iv)
-    abort ();
+  gcc_assert (!info->iv);
 
   bitmap_set_bit (data->relevant, SSA_NAME_VERSION (iv));
   info->iv = alloc_iv (base, step);
@@ -741,7 +738,7 @@ contains_abnormal_ssa_name_p (tree expr)
       break;
 
     default:
-      abort ();
+      gcc_unreachable ();
     }
 
   return false;
@@ -1030,9 +1027,8 @@ find_interesting_uses_outer_or_nonlin (struct ivopts_data *data, tree op,
     {
       use = iv_use (data, iv->use_id);
 
-      if (use->type != USE_NONLINEAR_EXPR
-         && use->type != USE_OUTER)
-       abort ();
+      gcc_assert (use->type == USE_NONLINEAR_EXPR
+                 || use->type == USE_OUTER);
 
       if (type == USE_NONLINEAR_EXPR)
        use->type = USE_NONLINEAR_EXPR;
@@ -1050,9 +1046,8 @@ find_interesting_uses_outer_or_nonlin (struct ivopts_data *data, tree op,
   *civ = *iv;
 
   stmt = SSA_NAME_DEF_STMT (op);
-  if (TREE_CODE (stmt) != PHI_NODE
-      && TREE_CODE (stmt) != MODIFY_EXPR)
-    abort ();
+  gcc_assert (TREE_CODE (stmt) == PHI_NODE
+             || TREE_CODE (stmt) == MODIFY_EXPR);
 
   use = record_use (data, NULL, civ, stmt, type);
   iv->use_id = use->id;
@@ -1742,7 +1737,7 @@ add_derived_ivs_candidates (struct ivopts_data *data)
          break;
 
        default:
-         abort ();
+         gcc_unreachable ();
        }
     }
 }
@@ -2531,8 +2526,7 @@ peel_address (tree addr, unsigned HOST_WIDE_INT *diff)
       off = DECL_FIELD_BIT_OFFSET (TREE_OPERAND (addr, 1));
       bit_offset = TREE_INT_CST_LOW (off);
 
-      if (bit_offset % BITS_PER_UNIT)
-       abort ();
+      gcc_assert ((bit_offset % BITS_PER_UNIT) == 0);
       
       if (diff)
        *diff += bit_offset / BITS_PER_UNIT;
@@ -2557,7 +2551,7 @@ peel_address (tree addr, unsigned HOST_WIDE_INT *diff)
       return TREE_OPERAND (addr, 0);
 
     default:
-      abort ();
+      gcc_unreachable ();
     }
 }
 
@@ -2647,8 +2641,7 @@ ptr_difference_cost (struct ivopts_data *data,
   unsigned HOST_WIDE_INT diff = 0;
   unsigned cost;
 
-  if (TREE_CODE (e1) != ADDR_EXPR)
-    abort ();
+  gcc_assert (TREE_CODE (e1) == ADDR_EXPR);
 
   if (TREE_CODE (e2) == ADDR_EXPR
       && ptr_difference_const (TREE_OPERAND (e1, 0),
@@ -3041,9 +3034,8 @@ may_replace_final_value (struct loop *loop, struct iv_use *use, tree *value)
   if (!exit)
     return false;
 
-  if (!dominated_by_p (CDI_DOMINATORS, exit->src,
-                      bb_for_stmt (use->stmt)))
-    abort ();
+  gcc_assert (dominated_by_p (CDI_DOMINATORS, exit->src,
+                             bb_for_stmt (use->stmt)));
 
   niter = &loop_data (loop)->niter;
   if (!niter->niter
@@ -3129,7 +3121,7 @@ determine_use_iv_cost (struct ivopts_data *data,
       break;
 
     default:
-      abort ();
+      gcc_unreachable ();
     }
 }
 
@@ -3790,8 +3782,9 @@ rewrite_use_nonlinear_expr (struct ivopts_data *data,
   tree op, stmts, tgt, ass;
   block_stmt_iterator bsi, pbsi;
  
-  if (TREE_CODE (use->stmt) == PHI_NODE)
+  switch (TREE_CODE (use->stmt))
     {
+    case PHI_NODE:
       tgt = PHI_RESULT (use->stmt);
 
       /* If we should keep the biv, do not replace it.  */
@@ -3805,14 +3798,16 @@ rewrite_use_nonlinear_expr (struct ivopts_data *data,
          bsi = pbsi;
          bsi_next (&pbsi);
        }
-    }
-  else if (TREE_CODE (use->stmt) == MODIFY_EXPR)
-    {
+      break;
+
+    case MODIFY_EXPR:
       tgt = TREE_OPERAND (use->stmt, 0);
       bsi = stmt_for_bsi (use->stmt);
+      break;
+
+    default:
+      gcc_unreachable ();
     }
-  else
-    abort ();
 
   op = force_gimple_operand (comp, &stmts, false, SSA_NAME_VAR (tgt));
 
@@ -4102,20 +4097,26 @@ rewrite_use_outer (struct ivopts_data *data,
   tree value, op, stmts, tgt;
   tree phi;
 
-  if (TREE_CODE (use->stmt) == PHI_NODE)
-    tgt = PHI_RESULT (use->stmt);
-  else if (TREE_CODE (use->stmt) == MODIFY_EXPR)
-    tgt = TREE_OPERAND (use->stmt, 0);
-  else
-    abort ();
+  switch (TREE_CODE (use->stmt))
+    {
+    case PHI_NODE:
+      tgt = PHI_RESULT (use->stmt);
+      break;
+    case MODIFY_EXPR:
+      tgt = TREE_OPERAND (use->stmt, 0);
+      break;
+    default:
+      gcc_unreachable ();
+    }
+
   exit = single_dom_exit (data->current_loop);
 
   if (exit)
     {
       if (!cand->iv)
        {
-         if (!may_replace_final_value (data->current_loop, use, &value))
-           abort ();
+         bool ok = may_replace_final_value (data->current_loop, use, &value);
+         gcc_assert (ok);
        }
       else
        value = get_computation_at (data->current_loop,
@@ -4180,7 +4181,7 @@ rewrite_use (struct ivopts_data *data,
        break;
 
       default:
-       abort ();
+       gcc_unreachable ();
     }
   modify_stmt (use->stmt);
 }
@@ -4198,8 +4199,7 @@ rewrite_uses (struct ivopts_data *data)
     {
       use = iv_use (data, i);
       cand = use->selected;
-      if (!cand)
-       abort ();
+      gcc_assert (cand);
 
       rewrite_use (data, use, cand);
     }
index 51e29fd..cde3ce8 100644 (file)
@@ -310,8 +310,7 @@ rewrite_into_loop_closed_ssa (void)
   unsigned i;
   bitmap names_to_rename;
 
-  if (any_marked_for_rewrite_p ())
-    abort ();
+  gcc_assert (!any_marked_for_rewrite_p ());
 
   use_blocks = xcalloc (num_ssa_names, sizeof (bitmap));
 
@@ -346,9 +345,8 @@ check_loop_closed_ssa_use (basic_block bb, tree use)
 
   def = SSA_NAME_DEF_STMT (use);
   def_bb = bb_for_stmt (def);
-  if (def_bb
-      && !flow_bb_inside_loop_p (def_bb->loop_father, bb))
-    abort ();
+  gcc_assert (!def_bb
+             || flow_bb_inside_loop_p (def_bb->loop_father, bb));
 }
 
 /* Checks invariants of loop closed ssa form in statement STMT in BB.  */
index c11360d..6b234c1 100644 (file)
@@ -26,6 +26,7 @@ Boston, MA 02111-1307, USA.  */
 #include "flags.h"
 #include "function.h"
 #include "diagnostic.h"
+#include "errors.h"
 #include "tree-flow.h"
 #include "tree-inline.h"
 #include "tree-pass.h"
@@ -322,11 +323,8 @@ finalize_ssa_defs (def_optype *old_ops_p, tree stmt ATTRIBUTE_UNUSED)
   if (num == 0)
     return NULL;
 
-#ifdef ENABLE_CHECKING
   /* There should only be a single real definition per assignment.  */
-  if (TREE_CODE (stmt) == MODIFY_EXPR && num > 1)
-    abort ();
-#endif
+  gcc_assert (TREE_CODE (stmt) != MODIFY_EXPR || num <= 1);
 
   old_ops = *old_ops_p;
 
@@ -382,8 +380,7 @@ finalize_ssa_uses (use_optype *old_ops_p, tree stmt ATTRIBUTE_UNUSED)
        initial call to get_stmt_operands does not pass a pointer to a 
        statement).  */
     for (x = 0; x < num; x++)
-      if (*(VARRAY_TREE_PTR (build_uses, x)) == stmt)
-       abort ();
+      gcc_assert (*(VARRAY_TREE_PTR (build_uses, x)) != stmt);
   }
 #endif
   old_ops = *old_ops_p;
@@ -639,11 +636,8 @@ finalize_ssa_v_must_defs (v_must_def_optype *old_ops_p,
   if (num == 0)
     return NULL;
 
-#ifdef ENABLE_CHECKING
   /* There should only be a single V_MUST_DEF per assignment.  */
-  if (TREE_CODE (stmt) == MODIFY_EXPR && num > 1)
-    abort ();
-#endif
+  gcc_assert (TREE_CODE (stmt) != MODIFY_EXPR || num <= 1);
 
   old_ops = *old_ops_p;
 
@@ -721,14 +715,11 @@ finalize_ssa_stmt_operands (tree stmt, stmt_operands_p old_ops,
 static inline void
 start_ssa_stmt_operands (void)
 {
-#ifdef ENABLE_CHECKING
-  if (VARRAY_ACTIVE_SIZE (build_defs) > 0 
-      || VARRAY_ACTIVE_SIZE (build_uses) > 0
-      || VARRAY_ACTIVE_SIZE (build_vuses) > 0
-      || VARRAY_ACTIVE_SIZE (build_v_may_defs) > 0
-      || VARRAY_ACTIVE_SIZE (build_v_must_defs) > 0)
-    abort ();
-#endif
+  gcc_assert (VARRAY_ACTIVE_SIZE (build_defs) == 0);
+  gcc_assert (VARRAY_ACTIVE_SIZE (build_uses) == 0);
+  gcc_assert (VARRAY_ACTIVE_SIZE (build_vuses) == 0);
+  gcc_assert (VARRAY_ACTIVE_SIZE (build_v_may_defs) == 0);
+  gcc_assert (VARRAY_ACTIVE_SIZE (build_v_must_defs) == 0);
 }
 
 
@@ -935,12 +926,9 @@ get_stmt_operands (tree stmt)
   stmt_ann_t ann;
   stmt_operands_t old_operands;
 
-#if defined ENABLE_CHECKING
   /* The optimizers cannot handle statements that are nothing but a
      _DECL.  This indicates a bug in the gimplifier.  */
-  if (SSA_VAR_P (stmt))
-    abort ();
-#endif
+  gcc_assert (!SSA_VAR_P (stmt));
 
   /* Ignore error statements.  */
   if (TREE_CODE (stmt) == ERROR_MARK)
@@ -1189,10 +1177,13 @@ get_expr_operands (tree 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);
-  abort ();
+  internal_error ("internal error");
+#endif
+  gcc_unreachable ();
 }
 
 
@@ -1217,11 +1208,8 @@ get_asm_expr_operands (tree stmt)
       parse_output_constraint (&constraint, i, 0, 0,
          &allows_mem, &allows_reg, &is_inout);
 
-#if defined ENABLE_CHECKING
       /* This should have been split in gimplify_asm_expr.  */
-      if (allows_reg && is_inout)
-       abort ();
-#endif
+      gcc_assert (!allows_reg || !is_inout);
 
       /* Memory operands are addressable.  Note that STMT needs the
         address of this operand.  */
@@ -1379,7 +1367,7 @@ get_indirect_ref_operands (tree stmt, tree expr, int flags)
 
   /* Ok, this isn't even is_gimple_min_invariant.  Something's broke.  */
   else
-    abort ();
+    gcc_unreachable ();
 
   /* Add a USE operand for the base pointer.  */
   get_expr_operands (stmt, pptr, opf_none);
@@ -1489,12 +1477,9 @@ add_stmt_operand (tree *var_p, tree stmt, int flags)
            {
              if (flags & opf_kill_def)
                {
-#if defined ENABLE_CHECKING
                  /* Only regular variables may get a V_MUST_DEF
                     operand.  */
-                 if (v_ann->mem_tag_kind != NOT_A_TAG)
-                   abort ();
-#endif
+                 gcc_assert (v_ann->mem_tag_kind == NOT_A_TAG);
                  /* V_MUST_DEF for non-aliased, non-GIMPLE register 
                    variable definitions.  */
                  append_v_must_def (var);
@@ -1519,10 +1504,7 @@ add_stmt_operand (tree *var_p, tree stmt, int flags)
 
          /* The variable is aliased.  Add its aliases to the virtual
             operands.  */
-#if defined ENABLE_CHECKING
-         if (VARRAY_ACTIVE_SIZE (aliases) == 0)
-           abort ();
-#endif
+         gcc_assert (VARRAY_ACTIVE_SIZE (aliases) != 0);
 
          if (flags & opf_is_def)
            {
index ec12f62..b322755 100644 (file)
@@ -444,10 +444,7 @@ value_exists_in_set_bitmap (value_set_t set, tree v)
 static void
 value_remove_from_set_bitmap (value_set_t set, tree v)
 {
-#ifdef ENABLE_CHECKING
-  if (!set->indexed)
-    abort ();
-#endif
+  gcc_assert (set->indexed);
 
   if (!set->values)
     return;
@@ -462,10 +459,7 @@ value_remove_from_set_bitmap (value_set_t set, tree v)
 static inline void
 value_insert_into_set_bitmap (value_set_t set, tree v)
 {
-#ifdef ENABLE_CHECKING
-  if (!set->indexed)
-    abort ();
-#endif
+  gcc_assert (set->indexed);
 
   if (set->values == NULL)
     {
@@ -511,12 +505,10 @@ bitmap_insert_into_set (bitmap_set_t set, tree expr)
 {
   tree val;
   /* XXX: For now, we only let SSA_NAMES into the bitmap sets.  */
-  if (TREE_CODE (expr) != SSA_NAME)
-    abort ();
+  gcc_assert (TREE_CODE (expr) == SSA_NAME);
   val = get_value_handle (expr);
   
-  if (val == NULL)
-    abort ();
+  gcc_assert (val);
   if (!is_gimple_min_invariant (val))
     bitmap_set_bit (set->values, VALUE_HANDLE_ID (val));
   bitmap_set_bit (set->expressions, SSA_NAME_VERSION (expr));
@@ -529,9 +521,7 @@ insert_into_set (value_set_t set, tree expr)
 {
   value_set_node_t newnode = pool_alloc (value_set_node_pool);
   tree val = get_value_handle (expr);
-  
-  if (val == NULL)
-    abort ();
+  gcc_assert (val);
 
   /* For indexed sets, insert the value into the set value bitmap.
      For all sets, add it to the linked list and increment the list
@@ -923,13 +913,12 @@ phi_translate (tree expr, value_set_t set, basic_block pred,
       }
       break;
     case 'd':
-      abort ();
+      gcc_unreachable ();
     case 'x':
       {
        tree phi = NULL;
        int i;
-       if (TREE_CODE (expr) != SSA_NAME)
-         abort ();
+       gcc_assert (TREE_CODE (expr) == SSA_NAME);
        if (TREE_CODE (SSA_NAME_DEF_STMT (expr)) == PHI_NODE)
          phi = SSA_NAME_DEF_STMT (expr);
        else
@@ -1078,12 +1067,11 @@ valid_in_set (value_set_t set, tree expr)
       }
     case 'x':
       {
-       if (TREE_CODE (expr) == SSA_NAME)
-         return true;
-       abort ();
+       gcc_assert (TREE_CODE (expr) == SSA_NAME);
+       return true;
       }
     case 'c':
-      abort ();
+      gcc_unreachable ();
     }
   return false;
 }
@@ -1258,8 +1246,7 @@ compute_antic (void)
   FOR_ALL_BB (bb)
     {
       ANTIC_IN (bb) = set_new (true);
-      if (bb->flags & BB_VISITED)
-       abort ();
+      gcc_assert (!(bb->flags & BB_VISITED));
     }
 
   while (changed)
@@ -1304,10 +1291,9 @@ find_or_generate_expression (basic_block block, tree expr, tree stmts)
   if (genop == NULL)
     {
       genop = VALUE_HANDLE_EXPR_SET (expr)->head->expr;
-      if (TREE_CODE_CLASS (TREE_CODE (genop)) != '1'
-         && TREE_CODE_CLASS (TREE_CODE (genop)) != '2'
-         && TREE_CODE_CLASS (TREE_CODE (genop)) != 'r')
-       abort ();
+      gcc_assert (TREE_CODE_CLASS (TREE_CODE (genop)) == '1'
+                 || TREE_CODE_CLASS (TREE_CODE (genop)) == '2'
+                 || TREE_CODE_CLASS (TREE_CODE (genop)) == 'r');
       genop = create_expression_by_pieces (block, genop, stmts);
     }
   return genop;
@@ -1381,7 +1367,7 @@ create_expression_by_pieces (basic_block block, tree expr, tree stmts)
        break;
       }
     default:
-      abort ();
+      gcc_unreachable ();
       
     }
   v = get_value_handle (expr);
@@ -1497,8 +1483,7 @@ insert_aux (basic_block block)
                            }
 
                          vprime = get_value_handle (eprime);
-                         if (!vprime)
-                           abort ();                     
+                         gcc_assert (vprime);
                          edoubleprime = bitmap_find_leader (AVAIL_OUT (bprime),
                                                             vprime);
                          if (edoubleprime == NULL)
@@ -1514,9 +1499,9 @@ insert_aux (basic_block block)
                                first_s = edoubleprime;
                              else if (first_s != edoubleprime)
                                all_same = false;
-                             if (first_s != edoubleprime 
-                                 && operand_equal_p (first_s, edoubleprime, 0))
-                               abort ();
+                             gcc_assert (first_s == edoubleprime 
+                                         || !operand_equal_p
+                                             (first_s, edoubleprime, 0));
                            }
                        }
                      /* If we can insert it, it's not the same value
@@ -1683,12 +1668,9 @@ create_value_expr_from (tree expr, basic_block block, vuse_optype vuses)
   enum tree_code code = TREE_CODE (expr);
   tree vexpr;
 
-#if defined ENABLE_CHECKING
-  if (TREE_CODE_CLASS (code) != '1'
-      && TREE_CODE_CLASS (code) != '2'
-      && TREE_CODE_CLASS (code) != 'r')
-    abort ();
-#endif
+  gcc_assert (TREE_CODE_CLASS (code) == '1'
+             || TREE_CODE_CLASS (code) == '2'
+             || TREE_CODE_CLASS (code) == 'r');
 
   if (TREE_CODE_CLASS (code) == '1')
     vexpr = pool_alloc (unary_node_pool);
@@ -1887,8 +1869,7 @@ eliminate (void)
                  && (TREE_CODE (*rhs_p) != SSA_NAME
                      || may_propagate_copy (*rhs_p, sprime)))
                {
-                 if (sprime == *rhs_p)
-                   abort ();
+                 gcc_assert (sprime != *rhs_p);
 
                  if (dump_file && (dump_flags & TDF_DETAILS))
                    {
index b72c789..8e65f64 100644 (file)
@@ -215,10 +215,8 @@ cfg_blocks_get (void)
 
   bb = VARRAY_BB (cfg_blocks, cfg_blocks_head);
 
-#ifdef ENABLE_CHECKING
-  if (cfg_blocks_empty_p () || !bb)
-    abort ();
-#endif
+  gcc_assert (!cfg_blocks_empty_p ());
+  gcc_assert (bb);
 
   cfg_blocks_head = (cfg_blocks_head + 1) % VARRAY_SIZE (cfg_blocks);
   --cfg_blocks_num;
index 36b8f33..50c5b32 100644 (file)
@@ -145,11 +145,8 @@ remove_last_stmt_and_useless_edges (basic_block bb, basic_block dest_bb)
 
   bsi = bsi_last (bb);
 
-#ifdef ENABLE_CHECKING
-  if (TREE_CODE (bsi_stmt (bsi)) != COND_EXPR
-      && TREE_CODE (bsi_stmt (bsi)) != SWITCH_EXPR)
-    abort ();
-#endif
+  gcc_assert (TREE_CODE (bsi_stmt (bsi)) == COND_EXPR
+             || TREE_CODE (bsi_stmt (bsi)) == SWITCH_EXPR);
 
   bsi_remove (&bsi);
 
index 2f07785..4d8096b 100644 (file)
@@ -845,10 +845,7 @@ walk_use_def_chains (tree var, walk_use_def_chains_fn fn, void *data,
 {
   tree def_stmt;
 
-#if defined ENABLE_CHECKING
-  if (TREE_CODE (var) != SSA_NAME)
-    abort ();
-#endif
+  gcc_assert (TREE_CODE (var) == SSA_NAME);
 
   def_stmt = SSA_NAME_DEF_STMT (var);
 
@@ -1047,8 +1044,7 @@ check_phi_redundancy (tree phi, tree *eq_to)
 
   /* At least one of the arguments should not be equal to the result, or
      something strange is happening.  */
-  if (!val)
-    abort ();
+  gcc_assert (val);
 
   if (get_eq_name (eq_to, res) == val)
     return;
index 12664bb..d138a79 100644 (file)
@@ -181,14 +181,12 @@ make_ssa_name (tree var, tree stmt)
 {
   tree t;
 
-#if defined ENABLE_CHECKING
-  if ((!DECL_P (var)
-       && TREE_CODE (var) != INDIRECT_REF)
-      || (stmt
-         && !IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (TREE_CODE (stmt)))
-         && TREE_CODE (stmt) != PHI_NODE))
-    abort ();
-#endif
+  gcc_assert (DECL_P (var)
+             || TREE_CODE (var) == INDIRECT_REF);
+
+  gcc_assert (!stmt
+             || IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (TREE_CODE (stmt)))
+             || TREE_CODE (stmt) == PHI_NODE);
 
   /* If our free list has an element, then use it.  Also reuse the
      SSA version number of the element on the free list which helps
index ee2103d..e3f491e 100644 (file)
@@ -233,8 +233,7 @@ independent_of_stmt_p (tree expr, tree at, block_stmt_iterator bsi)
       for (e = bb->pred; e; e = e->pred_next)
        if (e->src->aux)
          break;
-      if (!e)
-       abort ();
+      gcc_assert (e);
 
       expr = PHI_ARG_DEF_FROM_EDGE (at, e);
       if (TREE_CODE (expr) != SSA_NAME)
@@ -592,8 +591,7 @@ adjust_return_value (basic_block bb, tree m, tree a)
   tree ret_type = TREE_TYPE (DECL_RESULT (current_function_decl));
   block_stmt_iterator bsi = bsi_last (bb);
 
-  if (TREE_CODE (ret_stmt) != RETURN_EXPR)
-    abort ();
+  gcc_assert (TREE_CODE (ret_stmt) == RETURN_EXPR);
 
   ret_var = TREE_OPERAND (ret_stmt, 0);
   if (!ret_var)
@@ -691,8 +689,7 @@ eliminate_tail_call (struct tailcall *t)
 
   /* Replace the call by a jump to the start of function.  */
   e = redirect_edge_and_branch (t->call_block->succ, first);
-  if (!e)
-    abort ();
+  gcc_assert (e);
   PENDING_STMT (e) = NULL_TREE;
 
   /* Add phi node entries for arguments.  Not every PHI node corresponds to
@@ -751,8 +748,7 @@ eliminate_tail_call (struct tailcall *t)
          /* For all calls the same set of variables should be clobbered.  This
             means that there always should be the appropriate phi node except
             for the first time we eliminate the call.  */
-         if (first->pred->pred_next->pred_next)
-           abort ();
+         gcc_assert (!first->pred->pred_next->pred_next);
        }
 
       add_phi_arg (&phi, V_MAY_DEF_OP (v_may_defs, i), e);
index f229fd4..65214cc 100644 (file)
@@ -540,25 +540,18 @@ vect_create_index_for_array_ref (tree stmt, block_stmt_iterator *bsi)
   varray_type access_fns = DR_ACCESS_FNS (dr);
 
   /* FORNOW: handling only one dimensional arrays.  */
-  if (VARRAY_ACTIVE_SIZE (access_fns) != 1)
-    abort ();
-
-  if (!vectorization_factor)
-    abort ();
+  gcc_assert (VARRAY_ACTIVE_SIZE (access_fns) == 1);
+  gcc_assert (vectorization_factor);
 #endif
 
   access_fn = DR_ACCESS_FN (dr, 0);
   ok = vect_is_simple_iv_evolution (loopnum, access_fn, &init, &step, true)
        && vect_get_first_index (expr, &array_first_index);
 
-#ifdef ENABLE_CHECKING
-  if (!ok)
-    abort ();
+  gcc_assert (ok);
 
   /* FORNOW: Handling only constant 'init'.  */
-  if (TREE_CODE (init) != INTEGER_CST)
-    abort ();  
-#endif
+  gcc_assert (TREE_CODE (init) == INTEGER_CST);
 
   vf = build_int_cst (unsigned_type_node, vectorization_factor);
 
@@ -636,8 +629,7 @@ vect_align_data_ref (tree stmt)
 
   /* FORNOW: can't handle misaligned accesses; 
              all accesses expected to be aligned.  */
-  if (!aligned_access_p (dr))
-    abort ();
+  gcc_assert (aligned_access_p (dr));
 }
 
 
@@ -706,12 +698,9 @@ vect_create_data_ref (tree stmt, block_stmt_iterator *bsi)
                get_name (addr_ref));
   add_referenced_tmp_var (vect_ptr);
 
-#ifdef ENABLE_CHECKING
-  if (TREE_CODE (addr_ref) != VAR_DECL
-      && TREE_CODE (addr_ref) != COMPONENT_REF
-      && TREE_CODE (addr_ref) != SSA_NAME)
-    abort ();
-#endif
+  gcc_assert (TREE_CODE (addr_ref) == VAR_DECL
+             || TREE_CODE (addr_ref) == COMPONENT_REF
+             || TREE_CODE (addr_ref) == SSA_NAME);
 
   if (vect_debug_details (NULL))
     {
@@ -732,10 +721,7 @@ vect_create_data_ref (tree stmt, block_stmt_iterator *bsi)
 
   /* Handle aliasing:  */ 
   tag = STMT_VINFO_MEMTAG (stmt_info);
-#ifdef ENABLE_CHECKING
-  if (!tag)
-    abort ();
-#endif
+  gcc_assert (tag);
   get_var_ann (vect_ptr)->type_mem_tag = tag;
   
   /* Mark for renaming all aliased variables
@@ -794,10 +780,7 @@ vect_create_destination_var (tree scalar_dest, tree vectype)
   tree vec_dest;
   const char *new_name;
 
-#ifdef ENABLE_CHECKING
-  if (TREE_CODE (scalar_dest) != SSA_NAME)
-    abort ();
-#endif
+  gcc_assert (TREE_CODE (scalar_dest) == SSA_NAME);
 
   new_name = get_name (scalar_dest);
   if (!new_name)
@@ -907,10 +890,7 @@ vect_get_vec_def_for_operand (tree op, tree stmt)
       return vect_init_vector (stmt, vec_cst);
     }
 
-#ifdef ENABLE_CHECKING
-  if (TREE_CODE (op) != SSA_NAME)
-    abort ();
-#endif
+  gcc_assert (TREE_CODE (op) == SSA_NAME);
  
   /** ===> Case 2: operand is an SSA_NAME - find the stmt that defines it.  **/
 
@@ -931,10 +911,7 @@ vect_get_vec_def_for_operand (tree op, tree stmt)
       /* Get the def from the vectorized stmt.  */
 
       vec_stmt = STMT_VINFO_VEC_STMT (def_stmt_info);
-#ifdef ENABLE_CHECKING
-      if (!vec_stmt)
-        abort ();
-#endif
+      gcc_assert (vec_stmt);
       vec_oprnd = TREE_OPERAND (vec_stmt, 0);
       return vec_oprnd;
     }
@@ -948,7 +925,7 @@ vect_get_vec_def_for_operand (tree op, tree stmt)
     {
       if (vect_debug_details (NULL))
        fprintf (dump_file, "reduction/induction - unsupported.");
-      abort (); /* FORNOW no support for reduction/induction.  */
+      internal_error ("no support for reduction/induction"); /* FORNOW */
     }
 
 
@@ -965,10 +942,7 @@ vect_get_vec_def_for_operand (tree op, tree stmt)
       break;
     case NOP_EXPR:
       def = TREE_OPERAND (def_stmt, 0);
-#ifdef ENABLE_CHECKING
-      if (!IS_EMPTY_STMT (def_stmt))
-       abort ();
-#endif
+      gcc_assert (IS_EMPTY_STMT (def_stmt));
       def = op;
       break;
     default:
@@ -977,7 +951,7 @@ vect_get_vec_def_for_operand (tree op, tree stmt)
           fprintf (dump_file, "unsupported defining stmt: ");
          print_generic_expr (dump_file, def_stmt, TDF_SLIM);
        }
-      abort ();
+      internal_error ("unsupported defining stmt");
     }
 
   /* Build a tree with vector elements. Create 'vec_inv = {inv,inv,..,inv}'  */
@@ -1017,10 +991,7 @@ vect_finish_stmt_generation (tree stmt, tree vec_stmt, block_stmt_iterator *bsi)
 
   while (stmt != bsi_stmt (*bsi) && !bsi_end_p (*bsi))
     bsi_next (bsi);
-#ifdef ENABLE_CHECKING
-  if (stmt != bsi_stmt (*bsi))
-    abort ();
-#endif
+  gcc_assert (stmt == bsi_stmt (*bsi));
 }
 
 
@@ -1352,33 +1323,34 @@ vect_transform_stmt (tree stmt, block_stmt_iterator *bsi)
   bool is_store = false;
   tree vec_stmt = NULL_TREE;
   stmt_vec_info stmt_info = vinfo_for_stmt (stmt);
+  bool done;
 
   switch (STMT_VINFO_TYPE (stmt_info))
     {
     case op_vec_info_type:
-      if (!vectorizable_operation (stmt, bsi, &vec_stmt))
-        abort ();
+      done = vectorizable_operation (stmt, bsi, &vec_stmt);
+      gcc_assert (done);
       break;
 
     case assignment_vec_info_type:
-      if (!vectorizable_assignment (stmt, bsi, &vec_stmt))
-       abort ();
+      done = vectorizable_assignment (stmt, bsi, &vec_stmt);
+      gcc_assert (done);
       break;
 
     case load_vec_info_type:
-      if (!vectorizable_load (stmt, bsi, &vec_stmt))
-       abort ();
+      done = vectorizable_load (stmt, bsi, &vec_stmt);
+      gcc_assert (done);
       break;
 
     case store_vec_info_type:
-      if (!vectorizable_store (stmt, bsi, &vec_stmt))
-       abort ();
+      done = vectorizable_store (stmt, bsi, &vec_stmt);
+      gcc_assert (done);
       is_store = true;
       break;
     default:
       if (vect_debug_details (NULL))
         fprintf (dump_file, "stmt not supported.");
-      abort ();
+      gcc_unreachable ();
     }
 
   STMT_VINFO_VEC_STMT (stmt_info) = vec_stmt;
@@ -1406,27 +1378,17 @@ vect_transform_loop_bound (loop_vec_info loop_vinfo)
   tree cond;
   tree lb_type;
 
-#ifdef ENABLE_CHECKING
-  if (!LOOP_VINFO_NITERS_KNOWN_P (loop_vinfo))
-    abort ();
-#endif
+  gcc_assert (LOOP_VINFO_NITERS_KNOWN_P (loop_vinfo));
   old_N = LOOP_VINFO_NITERS (loop_vinfo);
   vf = LOOP_VINFO_VECT_FACTOR (loop_vinfo);
 
-#ifdef ENABLE_CHECKING
   /* FORNOW: 
      assuming number-of-iterations divides by the vectorization factor.  */
-  if (old_N % vf)
-    abort ();
-#endif
+  gcc_assert (!(old_N % vf));
 
   orig_cond_expr = LOOP_VINFO_EXIT_COND (loop_vinfo);
-#ifdef ENABLE_CHECKING
-  if (!orig_cond_expr)
-    abort ();
-#endif
-  if (orig_cond_expr != bsi_stmt (loop_exit_bsi))
-    abort ();
+  gcc_assert (orig_cond_expr);
+  gcc_assert (orig_cond_expr == bsi_stmt (loop_exit_bsi));
 
   create_iv (integer_zero_node, integer_one_node, NULL_TREE, loop, 
             &loop_exit_bsi, false, &indx_before_incr, &indx_after_incr);
@@ -1434,8 +1396,7 @@ vect_transform_loop_bound (loop_vec_info loop_vinfo)
   /* bsi_insert is using BSI_NEW_STMT. We need to bump it back 
      to point to the exit condition.  */
   bsi_next (&loop_exit_bsi);
-  if (bsi_stmt (loop_exit_bsi) != orig_cond_expr)
-    abort ();
+  gcc_assert (bsi_stmt (loop_exit_bsi) == orig_cond_expr);
 
   /* new loop exit test:  */
   lb_type = TREE_TYPE (TREE_OPERAND (TREE_OPERAND (orig_cond_expr, 0), 1));
@@ -1484,9 +1445,8 @@ vect_transform_loop (loop_vec_info loop_vinfo,
   /* 1) Make sure the loop header has exactly two entries
      2) Make sure we have a preheader basic block.  */
 
-  if (!loop->header->pred->pred_next
-      || loop->header->pred->pred_next->pred_next)
-    abort ();
+  gcc_assert (loop->header->pred->pred_next);
+  gcc_assert (!loop->header->pred->pred_next->pred_next);
 
   loop_split_edge_with (loop_preheader_edge (loop), NULL);
 
@@ -1515,10 +1475,7 @@ vect_transform_loop (loop_vec_info loop_vinfo,
              print_generic_expr (dump_file, stmt, TDF_SLIM);
            }   
          stmt_info = vinfo_for_stmt (stmt);
-#ifdef ENABLE_CHECKING
-         if (!stmt_info)
-           abort ();
-#endif
+         gcc_assert (stmt_info);
          if (!STMT_VINFO_RELEVANT_P (stmt_info))
            {
              bsi_next (&si);
@@ -1528,8 +1485,8 @@ vect_transform_loop (loop_vec_info loop_vinfo,
          /* FORNOW: Verify that all stmts operate on the same number of
                     units and no inner unrolling is necessary.  */
          vectype = STMT_VINFO_VECTYPE (stmt_info);
-         if (GET_MODE_NUNITS (TYPE_MODE (vectype)) != vectorization_factor)
-           abort ();
+         gcc_assert (GET_MODE_NUNITS (TYPE_MODE (vectype))
+                     == vectorization_factor);
 #endif
          /* -------- vectorize statement ------------ */
          if (vect_debug_details (NULL))
@@ -1668,10 +1625,9 @@ vect_analyze_operations (loop_vec_info loop_vinfo)
              fprintf (dump_file, "==> examining statement: ");
              print_generic_expr (dump_file, stmt, TDF_SLIM);
            }
-#ifdef ENABLE_CHECKING
-         if (!stmt_info)
-           abort ();
-#endif
+
+         gcc_assert (stmt_info);
+
          /* skip stmts which do not need to be vectorized.
             this is expected to include:
             - the COND_EXPR which is the loop exit condition
index 061a7ac..0f65c8a 100644 (file)
@@ -87,14 +87,11 @@ vn_compute (tree expr, hashval_t val, vuse_optype vuses)
 {
   size_t i;
 
-#if defined ENABLE_CHECKING
   /* EXPR must not be a statement.  We are only interested in value
      numbering expressions on the RHS of assignments.  */
-  if (expr == NULL_TREE
-      || (expr->common.ann
-         && expr->common.ann->common.type == STMT_ANN))
-    abort ();
-#endif
+  gcc_assert (expr);
+  gcc_assert (!expr->common.ann
+             || expr->common.ann->common.type != STMT_ANN);
 
   val = iterative_hash_expr (expr, val);
 
@@ -177,11 +174,9 @@ set_value_handle (tree e, tree v)
     SSA_NAME_VALUE (e) = v;
   else if (EXPR_P (e) || DECL_P (e))
     get_tree_ann (e)->common.value_handle = v;
-  else if (is_gimple_min_invariant (e))
-    /* Do nothing.  Constants are their own value handles.  */
-    ;
   else
-    abort ();
+    /* Do nothing.  Constants are their own value handles.  */
+    gcc_assert (is_gimple_min_invariant (e));
 }
 
 
@@ -284,10 +279,11 @@ get_value_handle (tree expr)
       tree_ann_t ann = tree_ann (expr);
       return ((ann) ? ann->common.value_handle : NULL_TREE);
     }
-  else if (is_gimple_min_invariant (expr))
-    return expr;
-
-  abort ();
+  else
+    {
+      gcc_assert (is_gimple_min_invariant (expr));
+      return expr;
+    }
 }
 
 
index 157d7f2..7b9c53f 100644 (file)
@@ -205,7 +205,7 @@ tree_size (tree node)
        }
 
     default:
-      abort ();
+      gcc_unreachable ();
     }
 }
 
@@ -228,8 +228,8 @@ make_node_stat (enum tree_code code MEM_STAT_DECL)
 
   /* We can't allocate a TREE_VEC, PHI_NODE, or STRING_CST
      without knowing how many elements it will have.  */
-  if (code == TREE_VEC || code == PHI_NODE)
-    abort ();
+  gcc_assert (code != TREE_VEC);
+  gcc_assert (code != PHI_NODE);
 
   TREE_SET_CODE ((tree)&ttmp, code);
   length = tree_size ((tree)&ttmp);
@@ -282,7 +282,7 @@ make_node_stat (enum tree_code code MEM_STAT_DECL)
       break;
 
     default:
-      abort ();
+      gcc_unreachable ();
     }
 
   tree_node_counts[(int) kind]++;
@@ -366,10 +366,7 @@ copy_node_stat (tree node MEM_STAT_DECL)
   enum tree_code code = TREE_CODE (node);
   size_t length;
 
-#ifdef ENABLE_CHECKING
-  if (code == STATEMENT_LIST)
-    abort ();
-#endif
+  gcc_assert (code != STATEMENT_LIST);
 
   length = tree_size (node);
   t = ggc_alloc_zone_stat (length, tree_zone PASS_MEM_STAT);
@@ -547,10 +544,9 @@ build_int_cst_wide (tree type, unsigned HOST_WIDE_INT low, HOST_WIDE_INT hi)
       if (t)
        {
          /* Make sure no one is clobbering the shared constant.  */
-         if (TREE_TYPE (t) != type)
-           abort ();
-         if (TREE_INT_CST_LOW (t) != low || TREE_INT_CST_HIGH (t) != hi)
-           abort ();
+         gcc_assert (TREE_TYPE (t) == type);
+         gcc_assert (TREE_INT_CST_LOW (t) == low);
+         gcc_assert (TREE_INT_CST_HIGH (t) == hi);
          return t;
        }
     }
@@ -840,10 +836,9 @@ integer_all_onesp (tree expr)
 
       shift_amount = prec - HOST_BITS_PER_WIDE_INT;
 
-      if (shift_amount > HOST_BITS_PER_WIDE_INT)
-       /* Can not handle precisions greater than twice the host int size.  */
-       abort ();
-      else if (shift_amount == HOST_BITS_PER_WIDE_INT)
+      /* Can not handle precisions greater than twice the host int size.  */
+      gcc_assert (shift_amount <= HOST_BITS_PER_WIDE_INT);
+      if (shift_amount == HOST_BITS_PER_WIDE_INT)
        /* Shifting by the host word size is undefined according to the ANSI
           standard, so we must handle this as a special case.  */
        high_value = -1;
@@ -1133,8 +1128,7 @@ list_length (tree t)
 #ifdef ENABLE_TREE_CHECKING
       if (len % 2)
        q = TREE_CHAIN (q);
-      if (p == q)
-       abort ();
+      gcc_assert (p != q);
 #endif
       len++;
     }
@@ -1179,8 +1173,7 @@ chainon (tree op1, tree op2)
   {
     tree t2;
     for (t2 = op2; t2; t2 = TREE_CHAIN (t2))
-      if (t2 == t1)
-       abort ();  /* Circularity created.  */
+      gcc_assert (t2 != t1);
   }
 #endif
 
@@ -1632,7 +1625,7 @@ tree_node_structure (tree t)
     case VALUE_HANDLE:         return TS_VALUE_HANDLE;
 
     default:
-      abort ();
+      gcc_unreachable ();
     }
 }
 \f
@@ -1799,7 +1792,7 @@ type_contains_placeholder_p (tree type)
       }
 
     default:
-      abort ();
+      gcc_unreachable ();
     }
 }
 
@@ -1960,12 +1953,12 @@ substitute_in_expr (tree exp, tree f, tree r)
            break;
 
          default:
-           abort ();
+           gcc_unreachable ();
          }
        break;
 
       default:
-       abort ();
+       gcc_unreachable ();
       }
 
   TREE_READONLY (new) = TREE_READONLY (exp);
@@ -2090,12 +2083,12 @@ substitute_placeholder_in_expr (tree exp, tree obj)
              return fold (build4 (code, TREE_TYPE (exp), op0, op1, op2, op3));
 
          default:
-           abort ();
+           gcc_unreachable ();
          }
        break;
 
       default:
-       abort ();
+       gcc_unreachable ();
       }
 }
 \f
@@ -2255,7 +2248,7 @@ stabilize_reference_1 (tree e)
       break;
 
     default:
-      abort ();
+      gcc_unreachable ();
     }
 
   TREE_TYPE (result) = TREE_TYPE (e);
@@ -2369,10 +2362,7 @@ build0_stat (enum tree_code code, tree tt MEM_STAT_DECL)
 {
   tree t;
 
-#ifdef ENABLE_CHECKING
-  if (TREE_CODE_LENGTH (code) != 0)
-    abort ();
-#endif
+  gcc_assert (TREE_CODE_LENGTH (code) == 0);
 
   t = make_node_stat (code PASS_MEM_STAT);
   TREE_TYPE (t) = tt;
@@ -2407,10 +2397,7 @@ build1_stat (enum tree_code code, tree type, tree node MEM_STAT_DECL)
   tree_node_sizes[(int) kind] += length;
 #endif
 
-#ifdef ENABLE_CHECKING
-  if (TREE_CODE_LENGTH (code) != 1)
-    abort ();
-#endif /* ENABLE_CHECKING */
+  gcc_assert (TREE_CODE_LENGTH (code) == 1);
 
   t = ggc_alloc_zone_stat (length, tree_zone PASS_MEM_STAT);
 
@@ -2498,10 +2485,7 @@ build2_stat (enum tree_code code, tree tt, tree arg0, tree arg1 MEM_STAT_DECL)
   tree t;
   int fro;
 
-#ifdef ENABLE_CHECKING
-  if (TREE_CODE_LENGTH (code) != 2)
-    abort ();
-#endif
+  gcc_assert (TREE_CODE_LENGTH (code) == 2);
 
   t = make_node_stat (code PASS_MEM_STAT);
   TREE_TYPE (t) = tt;
@@ -2541,10 +2525,7 @@ build3_stat (enum tree_code code, tree tt, tree arg0, tree arg1,
   tree t;
   int fro;
 
-#ifdef ENABLE_CHECKING
-  if (TREE_CODE_LENGTH (code) != 3)
-    abort ();
-#endif
+  gcc_assert (TREE_CODE_LENGTH (code) == 3);
 
   t = make_node_stat (code PASS_MEM_STAT);
   TREE_TYPE (t) = tt;
@@ -2592,10 +2573,7 @@ build4_stat (enum tree_code code, tree tt, tree arg0, tree arg1,
   tree t;
   int fro;
 
-#ifdef ENABLE_CHECKING
-  if (TREE_CODE_LENGTH (code) != 4)
-    abort ();
-#endif
+  gcc_assert (TREE_CODE_LENGTH (code) == 4);
 
   t = make_node_stat (code PASS_MEM_STAT);
   TREE_TYPE (t) = tt;
@@ -2654,7 +2632,7 @@ tree
       t = build4 (code, tt, arg0, arg1, arg2, arg3);
       break;
     default:
-      abort ();
+      gcc_unreachable ();
     }
   va_end (p);
 
@@ -2973,10 +2951,10 @@ is_attribute_p (const char *attr, tree ident)
   /* If ATTR is `__text__', IDENT must be `text'; and vice versa.  */
   if (attr[0] == '_')
     {
-      if (attr[1] != '_'
-         || attr[attr_len - 2] != '_'
-         || attr[attr_len - 1] != '_')
-       abort ();
+      gcc_assert (attr[1] == '_');
+      gcc_assert (attr[attr_len - 2] == '_');
+      gcc_assert (attr[attr_len - 1] == '_');
+      gcc_assert (attr[1] == '_');
       if (ident_len == attr_len - 4
          && strncmp (attr + 2, p, attr_len - 4) == 0)
        return 1;
@@ -3006,8 +2984,7 @@ lookup_attribute (const char *attr_name, tree list)
 
   for (l = list; l; l = TREE_CHAIN (l))
     {
-      if (TREE_CODE (TREE_PURPOSE (l)) != IDENTIFIER_NODE)
-       abort ();
+      gcc_assert (TREE_CODE (TREE_PURPOSE (l)) == IDENTIFIER_NODE);
       if (is_attribute_p (attr_name, TREE_PURPOSE (l)))
        return l;
     }
@@ -3491,8 +3468,7 @@ type_hash_canon (unsigned int hashcode, tree type)
 
   /* The hash table only contains main variants, so ensure that's what we're
      being passed.  */
-  if (TYPE_MAIN_VARIANT (type) != type)
-    abort ();
+  gcc_assert (TYPE_MAIN_VARIANT (type) == type);
 
   if (!lang_hooks.types.hash_types)
     return type;
@@ -3743,10 +3719,8 @@ host_integerp (tree t, int pos)
 HOST_WIDE_INT
 tree_low_cst (tree t, int pos)
 {
-  if (host_integerp (t, pos))
-    return TREE_INT_CST_LOW (t);
-  else
-    abort ();
+  gcc_assert (host_integerp (t, pos));
+  return TREE_INT_CST_LOW (t);
 }
 
 /* Return the most significant bit of the integer constant T.  */
@@ -4107,7 +4081,7 @@ iterative_hash_expr (tree t, hashval_t val)
              val = iterative_hash_expr (TREE_OPERAND (t, i), val);
        }
       else
-       abort ();
+       gcc_unreachable ();
       return val;
       break;
     }
@@ -4487,8 +4461,7 @@ build_method_type_directly (tree basetype,
 tree
 build_method_type (tree basetype, tree type)
 {
-  if (TREE_CODE (type) != FUNCTION_TYPE)
-    abort ();
+  gcc_assert (TREE_CODE (type) == FUNCTION_TYPE);
 
   return build_method_type_directly (basetype,
                                     TREE_TYPE (type),
@@ -5047,7 +5020,7 @@ decl_type_context (tree decl)
        break;
 
       default:
-       abort ();
+       gcc_unreachable ();
       }
 
   return NULL_TREE;
@@ -5064,8 +5037,7 @@ get_callee_fndecl (tree call)
 
   /* It's invalid to call this function with anything but a
      CALL_EXPR.  */
-  if (TREE_CODE (call) != CALL_EXPR)
-    abort ();
+  gcc_assert (TREE_CODE (call) == CALL_EXPR);
 
   /* The first operand to the CALL is the address of the function
      called.  */
@@ -5265,9 +5237,10 @@ get_set_constructor_bits (tree init, char *buffer, int bit_size)
          HOST_WIDE_INT hi_index
            = tree_low_cst (TREE_VALUE (vals), 0) - domain_min;
 
-         if (lo_index < 0 || lo_index >= bit_size
-             || hi_index < 0 || hi_index >= bit_size)
-           abort ();
+         gcc_assert (lo_index >= 0);
+         gcc_assert (lo_index < bit_size);
+         gcc_assert (hi_index >= 0);
+         gcc_assert (hi_index < bit_size);
          for (; lo_index <= hi_index; lo_index++)
            buffer[lo_index] = 1;
        }
@@ -5703,21 +5676,25 @@ build_vector_type_for_mode (tree innertype, enum machine_mode mode)
 {
   int nunits;
 
-  if (GET_MODE_CLASS (mode) == MODE_VECTOR_INT
-      || GET_MODE_CLASS (mode) == MODE_VECTOR_FLOAT)
-    nunits = GET_MODE_NUNITS (mode);
-
-  else if (GET_MODE_CLASS (mode) == MODE_INT)
+  switch (GET_MODE_CLASS (mode))
     {
+    case MODE_VECTOR_INT:
+    case MODE_VECTOR_FLOAT:
+      nunits = GET_MODE_NUNITS (mode);
+      break;
+
+    case MODE_INT:
       /* Check that there are no leftover bits.  */
-      if (GET_MODE_BITSIZE (mode) % TREE_INT_CST_LOW (TYPE_SIZE (innertype)))
-       abort ();
+      gcc_assert (GET_MODE_BITSIZE (mode)
+                 % TREE_INT_CST_LOW (TYPE_SIZE (innertype)) == 0);
 
       nunits = GET_MODE_BITSIZE (mode)
               / TREE_INT_CST_LOW (TYPE_SIZE (innertype));
+      break;
+
+    default:
+      gcc_unreachable ();
     }
-  else
-    abort ();
 
   return make_vector_type (innertype, nunits, mode);
 }
@@ -5903,8 +5880,7 @@ int_cst_value (tree x)
   unsigned HOST_WIDE_INT val = TREE_INT_CST_LOW (x);
   bool negative = ((val >> (bits - 1)) & 1) != 0;
 
-  if (bits > HOST_BITS_PER_WIDE_INT)
-    abort ();
+  gcc_assert (bits <= HOST_BITS_PER_WIDE_INT);
 
   if (negative)
     val |= (~(unsigned HOST_WIDE_INT) 0) << (bits - 1) << 1;
@@ -5923,11 +5899,8 @@ tree_fold_gcd (tree a, tree b)
   tree a_mod_b;
   tree type = TREE_TYPE (a);
 
-#if defined ENABLE_CHECKING
-  if (TREE_CODE (a) != INTEGER_CST
-      || TREE_CODE (b) != INTEGER_CST)
-    abort ();
-#endif
+  gcc_assert (TREE_CODE (a) == INTEGER_CST);
+  gcc_assert (TREE_CODE (b) == INTEGER_CST);
 
   if (integer_zerop (a))
     return b;