dbxout.c (dbxout_type, [...]): Use gcc_assert and gcc_unreachable.

	* dbxout.c (dbxout_type, dbxout_type_name, dbxout_symbol): Use
	gcc_assert and gcc_unreachable.
	* ddg.c (create_ddg_dependence, add_deps_for_def,
	add_deps_for_use, create_ddg, add_edge_to_ddg): Likewise.
	* df.c (df_ref_unlink, df_ref_record, df_uses_record,
	df_reg_def_chain_create, df_reg_use_chain_create, df_analyze,
	df_insn_delete, df_refs_reg_replace, df_ref_reg_replace,
	df_insns_modify, df_pattern_emit_before, df_bb_reg_live_start_p,
	df_bb_reg_live_end_p, df_bb_regs_lives_compare,
	df_bb_single_def_use_insn_find, dataflow_set_a_op_b,
	dataflow_set_copy, hybrid_search, diagnostic.c,
	diagnostic_build_prefix, diagnostic_count_diagnostic): Likewise.
	* dojump.c (do_jump): Likewise.
	* dominance.c (calc_dfs_tree_nonrec, calc_dfs_tree,
	compute_dom_fast_query, calculate_dominance_info,
	free_dominance_info, get_immediate_dominator,
	set_immediate_dominator, get_dominated_by,
	redirect_immediate_dominators, nearest_common_dominator,
	dominated_by_p, verify_dominators, recount_dominator,
	iterate_fix_dominators, add_to_dominance_info,
	delete_from_dominance_info): Likewise.
	* dwarf2asm.c (size_of_encoded_value, eh_data_format_name,
	dw2_asm_output_delta_uleb128, dw2_asm_output_delta_sleb128,
	dw2_force_const_mem, dw2_asm_output_encoded_addr_rtx): Likewise.
	* dwarf2out.c (expand_builtin_init_dwarf_reg_sizes, reg_save,
	initial_return_save, stack_adjust_offset, dwarf2out_stack_adjust,
	flush_queued_reg_saves, dwarf2out_frame_debug_expr,
	dwarf2out_frame_debug, dw_cfi_oprnd1_desc, output_cfi,
	output_call_frame_info, output_loc_operands, build_cfa_loc,
	decl_ultimate_origin, AT_flag, AT_int, AT_unsigned, AT_string,
	AT_string_form, add_AT_specification, AT_ref, set_AT_ref_external,
	AT_loc, AT_loc_list, AT_addr, AT_lbl, add_child_die,
	splice_child_die, attr_checksum, same_dw_val_p,
	break_out_includes, build_abbrev_table, size_of_die, mark_dies,
	unmark_dies, value_format, output_loc_list, output_die,
	output_pubnames, output_aranges, base_type_die, is_base_type,
	modified_type_die, dbx_reg_number, multiple_reg_loc_descriptor,
	mem_loc_descriptor, loc_descriptor, loc_descriptor_from_tree_1,
	field_byte_offset, add_data_member_location_attribute,
	add_const_value_attribute, rtl_for_decl_location,
	add_location_or_const_value_attribute, add_byte_size_attribute,
	add_bit_offset_attribute, add_bit_size_attribute,
	add_abstract_origin_attribute, pop_decl_scope, scope_die_for,
	decl_start_label, gen_formal_parameter_die,
	gen_type_die_for_member, gen_subprogram_die, gen_label_die,
	gen_typedef_die, gen_type_die, gen_tagged_type_instantiation_die,
	force_decl_die, force_type_die, gen_decl_die,
	dwarf2out_imported_module_or_decl, prune_unused_types_prune,
	dwarf2out_finish): Likewise.

From-SVN: r87176

gcc/ChangeLog

+2004-09-08  Nathan Sidwell  <nathan@codesourcery.com>
+
+	* dbxout.c (dbxout_type, dbxout_type_name, dbxout_symbol): Use
+	gcc_assert and gcc_unreachable.
+	* ddg.c (create_ddg_dependence, add_deps_for_def,
+	add_deps_for_use, create_ddg, add_edge_to_ddg): Likewise.
+	* df.c (df_ref_unlink, df_ref_record, df_uses_record,
+	df_reg_def_chain_create, df_reg_use_chain_create, df_analyze,
+	df_insn_delete, df_refs_reg_replace, df_ref_reg_replace,
+	df_insns_modify, df_pattern_emit_before, df_bb_reg_live_start_p,
+	df_bb_reg_live_end_p, df_bb_regs_lives_compare,
+	df_bb_single_def_use_insn_find, dataflow_set_a_op_b,
+	dataflow_set_copy, hybrid_search, diagnostic.c,
+	diagnostic_build_prefix, diagnostic_count_diagnostic): Likewise.
+	* dojump.c (do_jump): Likewise.
+	* dominance.c (calc_dfs_tree_nonrec, calc_dfs_tree,
+	compute_dom_fast_query, calculate_dominance_info,
+	free_dominance_info, get_immediate_dominator,
+	set_immediate_dominator, get_dominated_by,
+	redirect_immediate_dominators, nearest_common_dominator,
+	dominated_by_p, verify_dominators, recount_dominator,
+	iterate_fix_dominators, add_to_dominance_info,
+	delete_from_dominance_info): Likewise.
+	* dwarf2asm.c (size_of_encoded_value, eh_data_format_name,
+	dw2_asm_output_delta_uleb128, dw2_asm_output_delta_sleb128,
+	dw2_force_const_mem, dw2_asm_output_encoded_addr_rtx): Likewise.
+	* dwarf2out.c (expand_builtin_init_dwarf_reg_sizes, reg_save,
+	initial_return_save, stack_adjust_offset, dwarf2out_stack_adjust,
+	flush_queued_reg_saves, dwarf2out_frame_debug_expr,
+	dwarf2out_frame_debug, dw_cfi_oprnd1_desc, output_cfi,
+	output_call_frame_info, output_loc_operands, build_cfa_loc,
+	decl_ultimate_origin, AT_flag, AT_int, AT_unsigned, AT_string,
+	AT_string_form, add_AT_specification, AT_ref, set_AT_ref_external,
+	AT_loc, AT_loc_list, AT_addr, AT_lbl, add_child_die,
+	splice_child_die, attr_checksum, same_dw_val_p,
+	break_out_includes, build_abbrev_table, size_of_die, mark_dies,
+	unmark_dies, value_format, output_loc_list, output_die,
+	output_pubnames, output_aranges, base_type_die, is_base_type,
+	modified_type_die, dbx_reg_number, multiple_reg_loc_descriptor,
+	mem_loc_descriptor, loc_descriptor, loc_descriptor_from_tree_1,
+	field_byte_offset, add_data_member_location_attribute,
+	add_const_value_attribute, rtl_for_decl_location,
+	add_location_or_const_value_attribute, add_byte_size_attribute,
+	add_bit_offset_attribute, add_bit_size_attribute,
+	add_abstract_origin_attribute, pop_decl_scope, scope_die_for,
+	decl_start_label, gen_formal_parameter_die,
+	gen_type_die_for_member, gen_subprogram_die, gen_label_die,
+	gen_typedef_die, gen_type_die, gen_tagged_type_instantiation_die,
+	force_decl_die, force_type_die, gen_decl_die,
+	dwarf2out_imported_module_or_decl, prune_unused_types_prune,
+	dwarf2out_finish): Likewise.
+
 2004-09-08  Andreas Tobler  <toa@pop.agri.ch>
 
 	* Makefile.in (builtins.o): Depend on tree-mudflap.h.
@@ -6014,7 +6066,7 @@
 	* config/i386/xmmintrin.h: Include <mm_malloc.h>.
 
 2004-08-03  H.J. Lu  <hongjiu.lu@intel.com>
-	    Tanguy Fautr  <tfautre@pandora.be>
+	    Tanguy Fautrà <tfautre@pandora.be>
 
 	* config/i386/pmm_malloc.h: New file.
 

gcc/dbxout.c

@@ -1683,8 +1683,7 @@ dbxout_type (tree type, int full)
 	    /* We shouldn't be outputting a reference to a type before its
 	       definition unless the type has a tag name.
 	       A typedef name without a tag name should be impossible.  */
-	    if (TREE_CODE (TYPE_NAME (type)) != IDENTIFIER_NODE)
-	      abort ();
+	    gcc_assert (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE);
 #endif
 	    if (TYPE_NAME (type) != 0)
 	      dbxout_type_name (type);
@@ -1919,7 +1918,7 @@ dbxout_type (tree type, int full)
       break;
 
     default:
-      abort ();
+      gcc_unreachable ();
     }
 }
 
@@ -2040,19 +2039,19 @@ print_wide_int (HOST_WIDE_INT c)
 static void
 dbxout_type_name (tree type)
 {
-  tree t;
-  if (TYPE_NAME (type) == 0)
-    abort ();
-  if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
-    {
-      t = TYPE_NAME (type);
-    }
-  else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL)
+  tree t = TYPE_NAME (type);
+  
+  gcc_assert (t);
+  switch (TREE_CODE (t))
     {
-      t = DECL_NAME (TYPE_NAME (type));
+    case IDENTIFIER_NODE:
+      break;
+    case TYPE_DECL:
+      t = DECL_NAME (t);
+      break;
+    default:
+      gcc_unreachable ();
     }
-  else
-    abort ();
 
   fprintf (asmfile, "%s", IDENTIFIER_POINTER (t));
   CHARS (IDENTIFIER_LENGTH (t));
@@ -2386,7 +2385,7 @@ dbxout_symbol (tree decl, int local ATTRIBUTE_UNUSED)
     case PARM_DECL:
       /* Parm decls go in their own separate chains
 	 and are output by dbxout_reg_parms and dbxout_parms.  */
-      abort ();
+      gcc_unreachable ();
 
     case RESULT_DECL:
       /* Named return value, treat like a VAR_DECL.  */

gcc/ddg.c

@@ -164,8 +164,7 @@ create_ddg_dependence (ddg_ptr g, ddg_node_ptr src_node,
   if (interloop)
      distance = 1;
 
-  if (!link)
-    abort ();
+  gcc_assert (link);
 
   /* Note: REG_DEP_ANTI applies to MEM ANTI_DEP as well!!  */
   if (REG_NOTE_KIND (link) == REG_DEP_ANTI)
@@ -240,8 +239,7 @@ add_deps_for_def (ddg_ptr g, struct df *df, struct ref *rd)
 	  rtx use_insn = DF_REF_INSN (r_use->ref);
 	  ddg_node_ptr dest_node = get_node_of_insn (g, use_insn);
 
-	  if (!src_node || !dest_node)
-	    abort ();
+	  gcc_assert (src_node && dest_node);
 
 	  /* Any such upwards exposed use appears before the rd def.  */
 	  use_before_def = true;
@@ -296,8 +294,7 @@ add_deps_for_use (ddg_ptr g, struct df *df, struct ref *use)
   use_node = get_node_of_insn (g, use->insn);
   def_node = get_node_of_insn (g, first_def->insn);
 
-  if (!use_node || !def_node)
-    abort ();
+  gcc_assert (use_node && def_node);
 
   /* Make sure there are no defs after USE.  */
   for (i = use_node->cuid + 1; i < g->num_nodes; i++)
@@ -484,10 +481,8 @@ create_ddg (basic_block bb, struct df *df, int closing_branch_deps)
 	}
       if (JUMP_P (insn))
 	{
-	  if (g->closing_branch)
-	    abort (); /* Found two branches in DDG.  */
-	  else
-	    g->closing_branch = &g->nodes[i];
+	  gcc_assert (!g->closing_branch);
+	  g->closing_branch = &g->nodes[i];
 	}
       else if (GET_CODE (PATTERN (insn)) == USE)
 	{
@@ -505,9 +500,10 @@ create_ddg (basic_block bb, struct df *df, int closing_branch_deps)
       g->nodes[i++].insn = insn;
       first_note = NULL_RTX;
     }
-
-  if (!g->closing_branch)
-    abort ();  /* Found no branch in DDG.  */
+  
+  /* We must have found a branch in DDG.  */
+  gcc_assert (g->closing_branch);
+  
 
   /* Build the data dependency graph.  */
   build_intra_loop_deps (g);
@@ -646,8 +642,8 @@ add_edge_to_ddg (ddg_ptr g ATTRIBUTE_UNUSED, ddg_edge_ptr e)
   ddg_node_ptr src = e->src;
   ddg_node_ptr dest = e->dest;
 
-  if (!src->successors || !dest->predecessors)
-    abort (); /* Should have allocated the sbitmaps.  */
+  /* Should have allocated the sbitmaps.  */
+  gcc_assert (src->successors && dest->predecessors);
 
   SET_BIT (src->successors, dest->cuid);
   SET_BIT (dest->predecessors, src->cuid);

gcc/df.c

@@ -648,8 +648,8 @@ df_ref_unlink (struct df_link **phead, struct ref *ref)
 	  /* Only a single ref.  It must be the one we want.
 	     If not, the def-use and use-def chains are likely to
 	     be inconsistent.  */
-	  if (link->ref != ref)
-	    abort ();
+	  gcc_assert (link->ref == ref);
+	  
 	  /* Now have an empty chain.  */
 	  *phead = NULL;
 	}
@@ -808,8 +808,7 @@ df_ref_record (struct df *df, rtx reg, rtx *loc, rtx insn,
 {
   unsigned int regno;
 
-  if (!REG_P (reg) && GET_CODE (reg) != SUBREG)
-    abort ();
+  gcc_assert (REG_P (reg) || GET_CODE (reg) == SUBREG);
 
   /* For the reg allocator we are interested in some SUBREG rtx's, but not
      all.  Notably only those representing a word extraction from a multi-word
@@ -1040,10 +1039,10 @@ df_uses_record (struct df *df, rtx *loc, enum df_ref_type ref_type,
 			      bb, insn, 0);
 	      break;
 	    case STRICT_LOW_PART:
-	      /* A strict_low_part uses the whole REG and not just the SUBREG.  */
+	      /* A strict_low_part uses the whole REG and not just the
+		 SUBREG.  */
 	      dst = XEXP (dst, 0);
-	      if (GET_CODE (dst) != SUBREG)
-		abort ();
+	      gcc_assert (GET_CODE (dst) == SUBREG);
 	      df_uses_record (df, &SUBREG_REG (dst), DF_REF_REG_USE, bb,
 			     insn, DF_REF_READ_WRITE);
 	      break;
@@ -1056,7 +1055,7 @@ df_uses_record (struct df *df, rtx *loc, enum df_ref_type ref_type,
 	      dst = XEXP (dst, 0);
 	      break;
 	    default:
-	      abort ();
+	      gcc_unreachable ();
 	  }
 	return;
       }
@@ -1311,8 +1310,7 @@ df_reg_def_chain_create (struct df *df, bitmap blocks, bool redo)
     {
 #ifdef ENABLE_CHECKING
       for (regno = 0; regno < df->n_regs; regno++)
-	if (df->regs[regno].defs)
-	  abort ();
+	gcc_assert (!df->regs[regno].defs);
 #endif
 
       /* Pretend that all defs are new.  */
@@ -1393,8 +1391,7 @@ df_reg_use_chain_create (struct df *df, bitmap blocks, bool redo)
     {
 #ifdef ENABLE_CHECKING
       for (regno = 0; regno < df->n_regs; regno++)
-	if (df->regs[regno].uses)
-	  abort ();
+	gcc_assert (!df->regs[regno].uses);
 #endif
 
       /* Pretend that all uses are new.  */
@@ -2298,8 +2295,7 @@ df_analyze (struct df *df, bitmap blocks, int flags)
 
   /* We could deal with additional basic blocks being created by
      rescanning everything again.  */
-  if (df->n_bbs && df->n_bbs != (unsigned int) last_basic_block)
-    abort ();
+  gcc_assert (!df->n_bbs || df->n_bbs == (unsigned int) last_basic_block);
 
   update = df_modified_p (df, blocks);
   if (update || (flags != df->flags))
@@ -2321,8 +2317,7 @@ df_analyze (struct df *df, bitmap blocks, int flags)
 	  if (blocks == (bitmap) -1)
 	    blocks = df->bbs_modified;
 
-	  if (! df->n_bbs)
-	    abort ();
+	  gcc_assert (df->n_bbs);
 
 	  df_analyze_1 (df, blocks, flags, 1);
 	  bitmap_zero (df->bbs_modified);
@@ -2631,8 +2626,7 @@ df_insn_delete (struct df *df, basic_block bb ATTRIBUTE_UNUSED, rtx insn)
      handle the JUMP_LABEL?  */
 
   /* We should not be deleting the NOTE_INSN_BASIC_BLOCK or label.  */
-  if (insn == BB_HEAD (bb))
-    abort ();
+  gcc_assert (insn != BB_HEAD (bb));
 
   /* Delete the insn.  */
   delete_insn (insn);
@@ -2796,24 +2790,17 @@ df_refs_reg_replace (struct df *df, bitmap blocks, struct df_link *chain, rtx ol
       if (! INSN_P (insn))
 	continue;
 
-      if (bitmap_bit_p (blocks, DF_REF_BBNO (ref)))
-	{
-	  df_ref_reg_replace (df, ref, oldreg, newreg);
+      gcc_assert (bitmap_bit_p (blocks, DF_REF_BBNO (ref)));
+      
+      df_ref_reg_replace (df, ref, oldreg, newreg);
 
-	  /* Replace occurrences of the reg within the REG_NOTES.  */
-	  if ((! link->next || DF_REF_INSN (ref)
-	      != DF_REF_INSN (link->next->ref))
-	      && REG_NOTES (insn))
-	    {
-	      args.insn = insn;
-	      for_each_rtx (&REG_NOTES (insn), df_rtx_reg_replace, &args);
-	    }
-	}
-      else
+      /* Replace occurrences of the reg within the REG_NOTES.  */
+      if ((! link->next || DF_REF_INSN (ref)
+	   != DF_REF_INSN (link->next->ref))
+	  && REG_NOTES (insn))
 	{
-	  /* Temporary check to ensure that we have a grip on which
-	     regs should be replaced.  */
-	  abort ();
+	  args.insn = insn;
+	  for_each_rtx (&REG_NOTES (insn), df_rtx_reg_replace, &args);
 	}
     }
 }
@@ -2844,8 +2831,7 @@ df_ref_reg_replace (struct df *df, struct ref *ref, rtx oldreg, rtx newreg)
   if (! INSN_P (DF_REF_INSN (ref)))
     return 0;
 
-  if (oldreg && oldreg != DF_REF_REG (ref))
-    abort ();
+  gcc_assert (!oldreg || oldreg == DF_REF_REG (ref));
 
   if (! validate_change (DF_REF_INSN (ref), DF_REF_LOC (ref), newreg, 1))
     return 0;
@@ -2911,10 +2897,8 @@ df_insns_modify (struct df *df, basic_block bb, rtx first_insn, rtx last_insn)
       /* A non-const call should not have slipped through the net.  If
 	 it does, we need to create a new basic block.  Ouch.  The
 	 same applies for a label.  */
-      if ((CALL_P (insn)
-	   && ! CONST_OR_PURE_CALL_P (insn))
-	  || LABEL_P (insn))
-	abort ();
+      gcc_assert ((!CALL_P (insn) || CONST_OR_PURE_CALL_P (insn))
+		  && !LABEL_P (insn));
 
       uid = INSN_UID (insn);
 
@@ -2937,8 +2921,7 @@ df_pattern_emit_before (struct df *df, rtx pattern, basic_block bb, rtx insn)
   rtx prev_insn = PREV_INSN (insn);
 
   /* We should not be inserting before the start of the block.  */
-  if (insn == BB_HEAD (bb))
-    abort ();
+  gcc_assert (insn != BB_HEAD (bb));
   ret_insn = emit_insn_before (pattern, insn);
   if (ret_insn == insn)
     return ret_insn;
@@ -3196,10 +3179,7 @@ df_bb_reg_live_start_p (struct df *df, basic_block bb, rtx reg)
 {
   struct bb_info *bb_info = DF_BB_INFO (df, bb);
 
-#ifdef ENABLE_CHECKING
-  if (! bb_info->lr_in)
-    abort ();
-#endif
+  gcc_assert (bb_info->lr_in);
 
   return bitmap_bit_p (bb_info->lr_in, REGNO (reg));
 }
@@ -3211,10 +3191,7 @@ df_bb_reg_live_end_p (struct df *df, basic_block bb, rtx reg)
 {
   struct bb_info *bb_info = DF_BB_INFO (df, bb);
 
-#ifdef ENABLE_CHECKING
-  if (! bb_info->lr_in)
-    abort ();
-#endif
+  gcc_assert (bb_info->lr_in);
 
   return bitmap_bit_p (bb_info->lr_out, REGNO (reg));
 }
@@ -3234,9 +3211,8 @@ df_bb_regs_lives_compare (struct df *df, basic_block bb, rtx reg1, rtx reg2)
 
 
   /* The regs must be local to BB.  */
-  if (df_regno_bb (df, regno1) != bb
-      || df_regno_bb (df, regno2) != bb)
-    abort ();
+  gcc_assert (df_regno_bb (df, regno1) == bb
+	      && df_regno_bb (df, regno2) == bb);
 
   def2 = df_bb_regno_first_def_find (df, bb, regno2);
   use1 = df_bb_regno_last_use_find (df, bb, regno1);
@@ -3380,8 +3356,7 @@ df_bb_single_def_use_insn_find (struct df *df, basic_block bb, rtx insn, rtx reg
 
   def = df_bb_insn_regno_first_def_find (df, bb, insn, REGNO (reg));
 
-  if (! def)
-    abort ();
+  gcc_assert (def);
 
   du_link = DF_REF_CHAIN (def);
 
@@ -3761,7 +3736,7 @@ dataflow_set_a_op_b (enum set_representation repr,
 	  break;
 
     	default:
-	  abort ();
+	  gcc_unreachable ();
 	}
       break;
 
@@ -3777,12 +3752,12 @@ dataflow_set_a_op_b (enum set_representation repr,
 	  break;
 
     	default:
-	  abort ();
+	  gcc_unreachable ();
 	}
       break;
 
     default:
-      abort ();
+      gcc_unreachable ();
     }
 }
 
@@ -3800,7 +3775,7 @@ dataflow_set_copy (enum set_representation repr, void *dest, void *src)
       break;
 
     default:
-      abort ();
+      gcc_unreachable ();
     }
 }
 
@@ -3816,8 +3791,7 @@ hybrid_search (basic_block bb, struct dataflow *dataflow,
   edge e;
 
   SET_BIT (visited, bb->index);
-  if (!TEST_BIT (pending, bb->index))
-    abort ();
+  gcc_assert (TEST_BIT (pending, bb->index));
   RESET_BIT (pending, i);
 
 #define HS(E_ANTI, E_ANTI_NEXT, E_ANTI_BB, E_ANTI_START_BB, IN_SET,	\

gcc/diagnostic.c

@@ -174,8 +174,7 @@ diagnostic_build_prefix (diagnostic_info *diagnostic)
     "must-not-happen"
   };
   expanded_location s = expand_location (diagnostic->location);
-  if (diagnostic->kind >= DK_LAST_DIAGNOSTIC_KIND)
-    abort();
+  gcc_assert (diagnostic->kind < DK_LAST_DIAGNOSTIC_KIND);
 
   return s.file
     ? build_message_string ("%s:%d: %s",
@@ -194,8 +193,7 @@ diagnostic_count_diagnostic (diagnostic_context *context,
   switch (kind)
     {
     default:
-      abort();
-      break;
+      gcc_unreachable ();
 
     case DK_ICE:
 #ifndef ENABLE_CHECKING

gcc/dojump.c

@@ -265,7 +265,7 @@ do_jump (tree exp, rtx if_false_label, rtx if_true_label)
     case COMPOUND_EXPR:
     case COND_EXPR:
       /* Lowered by gimplify.c.  */
-      abort ();
+      gcc_unreachable ();
 
     case COMPONENT_REF:
     case BIT_FIELD_REF:
@@ -301,10 +301,12 @@ do_jump (tree exp, rtx if_false_label, rtx if_true_label)
       {
         tree inner_type = TREE_TYPE (TREE_OPERAND (exp, 0));
 
-        if (GET_MODE_CLASS (TYPE_MODE (inner_type)) == MODE_COMPLEX_FLOAT
-            || GET_MODE_CLASS (TYPE_MODE (inner_type)) == MODE_COMPLEX_INT)
-	  abort ();
-        else if (integer_zerop (TREE_OPERAND (exp, 1)))
+        gcc_assert (GET_MODE_CLASS (TYPE_MODE (inner_type))
+		    != MODE_COMPLEX_FLOAT);
+	gcc_assert (GET_MODE_CLASS (TYPE_MODE (inner_type))
+		    != MODE_COMPLEX_INT);
+	
+        if (integer_zerop (TREE_OPERAND (exp, 1)))
           do_jump (TREE_OPERAND (exp, 0), if_true_label, if_false_label);
         else if (GET_MODE_CLASS (TYPE_MODE (inner_type)) == MODE_INT
                  && !can_compare_p (EQ, TYPE_MODE (inner_type), ccp_jump))
@@ -318,10 +320,12 @@ do_jump (tree exp, rtx if_false_label, rtx if_true_label)
       {
         tree inner_type = TREE_TYPE (TREE_OPERAND (exp, 0));
 
-        if (GET_MODE_CLASS (TYPE_MODE (inner_type)) == MODE_COMPLEX_FLOAT
-            || GET_MODE_CLASS (TYPE_MODE (inner_type)) == MODE_COMPLEX_INT)
-	  abort ();
-        else if (integer_zerop (TREE_OPERAND (exp, 1)))
+        gcc_assert (GET_MODE_CLASS (TYPE_MODE (inner_type))
+		    != MODE_COMPLEX_FLOAT);
+	gcc_assert (GET_MODE_CLASS (TYPE_MODE (inner_type))
+		    != MODE_COMPLEX_INT);
+	
+        if (integer_zerop (TREE_OPERAND (exp, 1)))
           do_jump (TREE_OPERAND (exp, 0), if_false_label, if_true_label);
         else if (GET_MODE_CLASS (TYPE_MODE (inner_type)) == MODE_INT
            && !can_compare_p (NE, TYPE_MODE (inner_type), ccp_jump))
@@ -511,8 +515,10 @@ do_jump (tree exp, rtx if_false_label, rtx if_true_label)
                && ! can_compare_p (NE, GET_MODE (temp), ccp_jump))
         /* Note swapping the labels gives us not-equal.  */
         do_jump_by_parts_equality_rtx (temp, if_true_label, if_false_label);
-      else if (GET_MODE (temp) != VOIDmode)
+      else
 	{
+	  gcc_assert (GET_MODE (temp) != VOIDmode);
+	  
 	  /* The RTL optimizers prefer comparisons against pseudos.  */
 	  if (GET_CODE (temp) == SUBREG)
 	    {
@@ -528,8 +534,6 @@ do_jump (tree exp, rtx if_false_label, rtx if_true_label)
 				   GET_MODE (temp), NULL_RTX,
 				   if_false_label, if_true_label);
 	}
-      else
-        abort ();
     }
 }
 

gcc/dominance.c

@@ -271,8 +271,7 @@ calc_dfs_tree_nonrec (struct dom_info *di, basic_block bb,
 	      e_next = bn->succ;
 	    }
 
-	  if (bn == en_block)
-	    abort ();
+	  gcc_assert (bn != en_block);
 
 	  /* Fill the DFS tree info calculatable _before_ recursing.  */
 	  if (bb != en_block)
@@ -375,8 +374,7 @@ calc_dfs_tree (struct dom_info *di, enum cdi_direction reverse)
   di->nodes = di->dfsnum - 1;
 
   /* This aborts e.g. when there is _no_ path from ENTRY to EXIT at all.  */
-  if (di->nodes != (unsigned int) n_basic_blocks + 1)
-    abort ();
+  gcc_assert (di->nodes == (unsigned int) n_basic_blocks + 1);
 }
 
 /* Compress the path from V to the root of its set and update path_min at the
@@ -597,8 +595,7 @@ compute_dom_fast_query (enum cdi_direction dir)
   int num = 0;
   basic_block bb;
 
-  if (dom_computed[dir] < DOM_NO_FAST_QUERY)
-    abort ();
+  gcc_assert (dom_computed[dir] >= DOM_NO_FAST_QUERY);
 
   if (dom_computed[dir] == DOM_OK)
     return;
@@ -629,8 +626,7 @@ calculate_dominance_info (enum cdi_direction dir)
       if (dom_computed[dir] != DOM_NONE)
 	free_dominance_info (dir);
 
-      if (n_bbs_in_dom_tree[dir])
-	abort ();
+      gcc_assert (!n_bbs_in_dom_tree[dir]);
 
       FOR_ALL_BB (b)
 	{
@@ -672,8 +668,7 @@ free_dominance_info (enum cdi_direction dir)
     }
 
   /* If there are any nodes left, something is wrong.  */
-  if (n_bbs_in_dom_tree[dir])
-    abort ();
+  gcc_assert (!n_bbs_in_dom_tree[dir]);
 
   dom_computed[dir] = DOM_NONE;
 }
@@ -684,8 +679,7 @@ get_immediate_dominator (enum cdi_direction dir, basic_block bb)
 {
   struct et_node *node = bb->dom[dir];
 
-  if (!dom_computed[dir])
-    abort ();
+  gcc_assert (dom_computed[dir]);
 
   if (!node->father)
     return NULL;
@@ -701,8 +695,7 @@ set_immediate_dominator (enum cdi_direction dir, basic_block bb,
 {
   struct et_node *node = bb->dom[dir];
 
-  if (!dom_computed[dir])
-    abort ();
+  gcc_assert (dom_computed[dir]);
 
   if (node->father)
     {
@@ -726,8 +719,7 @@ get_dominated_by (enum cdi_direction dir, basic_block bb, basic_block **bbs)
   int n;
   struct et_node *node = bb->dom[dir], *son = node->son, *ason;
 
-  if (!dom_computed[dir])
-    abort ();
+  gcc_assert (dom_computed[dir]);
 
   if (!son)
     {
@@ -753,8 +745,7 @@ redirect_immediate_dominators (enum cdi_direction dir, basic_block bb,
 {
   struct et_node *bb_node = bb->dom[dir], *to_node = to->dom[dir], *son;
 
-  if (!dom_computed[dir])
-    abort ();
+  gcc_assert (dom_computed[dir]);
 
   if (!bb_node->son)
     return;
@@ -775,8 +766,7 @@ redirect_immediate_dominators (enum cdi_direction dir, basic_block bb,
 basic_block
 nearest_common_dominator (enum cdi_direction dir, basic_block bb1, basic_block bb2)
 {
-  if (!dom_computed[dir])
-    abort ();
+  gcc_assert (dom_computed[dir]);
 
   if (!bb1)
     return bb2;
@@ -792,8 +782,7 @@ dominated_by_p (enum cdi_direction dir, basic_block bb1, basic_block bb2)
 { 
   struct et_node *n1 = bb1->dom[dir], *n2 = bb2->dom[dir];
 
-  if (!dom_computed[dir])
-    abort ();
+  gcc_assert (dom_computed[dir]);
 
   if (dom_computed[dir] == DOM_OK)
     return (n1->dfs_num_in >= n2->dfs_num_in
@@ -809,8 +798,7 @@ verify_dominators (enum cdi_direction dir)
   int err = 0;
   basic_block bb;
 
-  if (!dom_computed[dir])
-    abort ();
+  gcc_assert (dom_computed[dir]);
 
   FOR_EACH_BB (bb)
     {
@@ -838,8 +826,7 @@ verify_dominators (enum cdi_direction dir)
 	}
     }
 
-  if (err)
-    abort ();
+  gcc_assert (!err);
 }
 
 /* Determine immediate dominator (or postdominator, according to DIR) of BB,
@@ -853,8 +840,7 @@ recount_dominator (enum cdi_direction dir, basic_block bb)
   basic_block dom_bb = NULL;
   edge e;
 
-  if (!dom_computed[dir])
-    abort ();
+  gcc_assert (dom_computed[dir]);
 
   if (dir == CDI_DOMINATORS)
     {
@@ -889,8 +875,7 @@ iterate_fix_dominators (enum cdi_direction dir, basic_block *bbs, int n)
   int i, changed = 1;
   basic_block old_dom, new_dom;
 
-  if (!dom_computed[dir])
-    abort ();
+  gcc_assert (dom_computed[dir]);
 
   for (i = 0; i < n; i++)
     set_immediate_dominator (dir, bbs[i], NULL);
@@ -911,18 +896,14 @@ iterate_fix_dominators (enum cdi_direction dir, basic_block *bbs, int n)
     }
 
   for (i = 0; i < n; i++)
-    if (!get_immediate_dominator (dir, bbs[i]))
-      abort ();
+    gcc_assert (get_immediate_dominator (dir, bbs[i]));
 }
 
 void
 add_to_dominance_info (enum cdi_direction dir, basic_block bb)
 {
-  if (!dom_computed[dir])
-    abort ();
-
-  if (bb->dom[dir])
-    abort ();
+  gcc_assert (dom_computed[dir]);
+  gcc_assert (!bb->dom[dir]);
 
   n_bbs_in_dom_tree[dir]++;
   
@@ -935,8 +916,7 @@ add_to_dominance_info (enum cdi_direction dir, basic_block bb)
 void
 delete_from_dominance_info (enum cdi_direction dir, basic_block bb)
 {
-  if (!dom_computed[dir])
-    abort ();
+  gcc_assert (dom_computed[dir]);
 
   et_free_tree (bb->dom[dir]);
   bb->dom[dir] = NULL;

gcc/dwarf2asm.c

@@ -333,8 +333,9 @@ size_of_encoded_value (int encoding)
       return 4;
     case DW_EH_PE_udata8:
       return 8;
+    default:
+      gcc_unreachable ();
     }
-  abort ();
 }
 
 /* Yield a name for a given pointer encoding.  */
@@ -486,12 +487,12 @@ eh_data_format_name (int format)
 #if HAVE_DESIGNATED_INITIALIZERS
   };
 
-  if (format < 0 || format > 0xff || format_names[format] == NULL)
-    abort ();
+  gcc_assert (format >= 0 && format < 0x100 && format_names[format]);
+  
   return format_names[format];
 #else
   }
-  abort ();
+  gcc_unreachable ();
 #endif
 }
 
@@ -635,7 +636,7 @@ dw2_asm_output_delta_uleb128 (const char *lab1 ATTRIBUTE_UNUSED,
   fputc ('-', asm_out_file);
   assemble_name (asm_out_file, lab2);
 #else
-  abort ();
+  gcc_unreachable ();
 #endif
 
   if (flag_debug_asm && comment)
@@ -663,7 +664,7 @@ dw2_asm_output_delta_sleb128 (const char *lab1 ATTRIBUTE_UNUSED,
   fputc ('-', asm_out_file);
   assemble_name (asm_out_file, lab2);
 #else
-  abort ();
+  gcc_unreachable ();
 #endif
 
   if (flag_debug_asm && comment)
@@ -704,8 +705,7 @@ dw2_force_const_mem (rtx x)
   if (! indirect_pool)
     indirect_pool = splay_tree_new_ggc (splay_tree_compare_pointers);
 
-  if (GET_CODE (x) != SYMBOL_REF)
-    abort ();
+  gcc_assert (GET_CODE (x) == SYMBOL_REF);
 
   str = targetm.strip_name_encoding (XSTR (x, 0));
   node = splay_tree_lookup (indirect_pool, (splay_tree_key) str);
@@ -836,8 +836,7 @@ dw2_asm_output_encoded_addr_rtx (int encoding, rtx addr,
 	  break;
 
 	case DW_EH_PE_pcrel:
-	  if (GET_CODE (addr) != SYMBOL_REF)
-	    abort ();
+	  gcc_assert (GET_CODE (addr) == SYMBOL_REF);
 #ifdef ASM_OUTPUT_DWARF_PCREL
 	  ASM_OUTPUT_DWARF_PCREL (asm_out_file, size, XSTR (addr, 0));
 #else
@@ -848,7 +847,7 @@ dw2_asm_output_encoded_addr_rtx (int encoding, rtx addr,
 	default:
 	  /* Other encodings should have been handled by
 	     ASM_MAYBE_OUTPUT_ENCODED_ADDR_RTX.  */
-	  abort ();
+	  gcc_unreachable ();
 	}
 
 #ifdef ASM_MAYBE_OUTPUT_ENCODED_ADDR_RTX