* 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.


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

1 files changed, 39 insertions, 83 deletions

diff --git a/gcc/tree-vectorizer.c b/gcc/tree-vectorizer.c
index f229fd45452..65214cc7ebe 100644
--- a/gcc/tree-vectorizer.c
+++ b/gcc/tree-vectorizer.c
@@ -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