* ra-build.c (copy_insn_p, remember_move, defuse_overlap_p_1,

	live_out_1, prune_hardregs_for_mode, init_one_web_common,
	reinit_one_web, add_subweb, add_subweb_2, init_web_parts,
	record_conflict, compare_and_free_webs, init_webs_defs_uses,
	parts_to_webs_1, parts_to_webs, reset_conflicts,
	check_conflict_numbers, remember_web_was_spilled, handle_asm_insn,
	ra_build_free): Use gcc_assert and gcc_unreachable instead of abort.
	* ra-colorize.c (push_list, put_web, reset_lists, put_web_at_end,
	put_move, remove_move, combine, select_spill, colorize_one_web,
	try_recolor_web, insert_coalesced_conflicts, check_colors,
	break_precolored_alias, restore_conflicts_from_coalesce,
	sort_and_combine_web_pairs, check_uncoalesced_moves): Likewise.
	* ra-rewrite.c (spill_coalescing, slots_overlap_p, emit_loads,
	reloads_to_loads, rewrite_program2, emit_colors): Likewise.
	* ra.c (first_hard_reg, create_insn_info, find_subweb, init_ra,
	check_df): Likewise.
	* real.c (do_add, do_multiply, do_divide, do_compare, do_fix_trunc,
	real_arithmetic, real_compare, real_exponent, real_ldexp,
	real_identical, real_to_integer, real_to_integer2, real_to_decimal,
	real_to_hexadecimal, real_from_integer, ten_to_ptwo, ten_to_mptwo,
	real_digit, real_nan, real_maxval, round_for_format, real_convert,
	real_to_target, real_from_target, real_hash, encode_ieee_single,
	encode_ieee_double, encode_ieee_extended, encode_ieee_quad,
	encode_vax_f, encode_vax_d, encode_vax_g, encode_i370_single,
	encode_i370_double, encode_c4x_single, encode_c4x_extended): Likewise.
	* recog.c (validate_change, validate_replace_rtx_1, asm_operand_ok,
	extract_insn, peep2_next_insn, peep2_reg_dead_p,
	peep2_find_free_register, peephole2_optimize, store_data_bypass_p,
	if_test_bypass_p): Likewise.
	* reg-stack.c (record_label_references, get_asm_operand_n_inputs,
	stack_result, remove_regno_note, get_hard_regnum, emit_pop_insn,
	emit_swap_insn, swap_to_top, move_for_stack_reg,
	subst_stack_regs_pat, subst_asm_stack_regs, change_stack,
	compensate_edge, convert_regs_1): Likewise.
	* regclass.c (init_reg_sets, init_reg_sets_1,
	memory_move_secondary_cost): Likewise.
	* regrename.c (note_sets, clear_dead_regs, scan_rtx_reg, scan_rtx):
	Likewise.
	* reload.c (push_secondary_reload, find_valid_class, push_reload,
	operands_match_p, decompose, immune_p, find_reloads,
	find_reloads_toplev, find_reloads_address_1, subst_reloads,
	copy_replacements, refers_to_regno_for_reload_p,
	reg_overlap_mentioned_for_reload_p): Likewise.
	* reload1.c (compute_use_by_pseudos, replace_pseudos_in, reload,
	count_pseudo, find_reg, eliminate_regs, eliminate_regs_in_insn,
	verify_initial_elim_offsets, finish_spills, clear_reload_reg_in_use,
	reload_reg_free_p, reload_reg_reaches_end_p, reloads_conflict,
	choose_reload_regs, merge_assigned_reloads, emit_input_reload_insns,
	do_output_reload, fixup_abnormal_edges): Likewise.
	* reorg.c (stop_search_p, emit_delay_sequence, get_jump_flags,
	fill_slots_from_thread, relax_delay_slots): Likewise.
	* resource.c (mark_referenced_resources, mark_set_resources):
	Likewise.
	* rtl.c (copy_rtx, rtx_equal_p): Likewise.
	* rtlanal.c (insn_dependent_p, reg_overlap_mentioned_p,
	dead_or_set_p, find_reg_fusage, remove_note, replace_rtx,
	subreg_lsb_1, subreg_regno_offset, subreg_offset_representable_p,
	find_first_parameter_load, can_hoist_insn_p, hoist_update_store,
	hoist_insn_after, hoist_insn_to_edge, nonzero_bits1): Likewise.
	* rtlhooks.c (gen_lowpart_general): Likewise.
	* sbitmap.c (sbitmap_difference): Likewise.
	* sched-deps.c (add_dependence, sched_analyze_1, sched_analyze_2,
	sched_analyze, add_forward_dependence): Likewise.
	* sched-ebb.c (fix_basic_block_boundaries, schedule_ebb): Likewise.
	* sched-rgn.c (debug_regions, compute_trg_info, schedule_region,
	schedule_insns): Likewise.
	* sched-vis.c (print_pattern): Likewise.
	* sdbout.c (sdbout_symbol, sdbout_toplevel_data): Likewise.
	* simplify-rtx.c (simplify_unary_operation, simplify_binary_operation,
	simplify_const_relational_operation, simplify_ternary_operation,
	simplify_immed_subreg, simplify_subreg, simplify_gen_subreg):
	Likewise.
	* sreal.c (copy, sreal_sub, sreal_div): Likewise.
	* stmt.c (force_label_rtx, expand_goto, expand_asm_operands,
	resolve_operand_name_1, expand_return, expand_decl,
	expand_anon_union_decl, emit_case_bit_tests, expand_case): Likewise.
	* stor-layout.c (put_pending_size, smallest_mode_for_size,
	int_mode_for_mode, layout_decl, finish_builtin_struct, layout_type,
	set_sizetype, get_mode_bounds): Likewise.


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

1 files changed, 79 insertions, 117 deletions

diff --git a/gcc/reg-stack.c b/gcc/reg-stack.c
index fc13759af49..f8fca7322cd 100644
--- a/gcc/reg-stack.c
+++ b/gcc/reg-stack.c
@@ -506,8 +506,7 @@ record_label_references (rtx insn, rtx pat)
       rtx label = XEXP (pat, 0);
       rtx ref;
 
-      if (!LABEL_P (label))
-	abort ();
+      gcc_assert (LABEL_P (label));
 
       /* If this is an undefined label, LABEL_REFS (label) contains
          garbage.  */
@@ -782,21 +781,21 @@ check_asm_stack_operands (rtx insn)
 static int
 get_asm_operand_n_inputs (rtx body)
 {
-  if (GET_CODE (body) == SET && GET_CODE (SET_SRC (body)) == ASM_OPERANDS)
-    return ASM_OPERANDS_INPUT_LENGTH (SET_SRC (body));
-
-  else if (GET_CODE (body) == ASM_OPERANDS)
-    return ASM_OPERANDS_INPUT_LENGTH (body);
-
-  else if (GET_CODE (body) == PARALLEL
-	   && GET_CODE (XVECEXP (body, 0, 0)) == SET)
-    return ASM_OPERANDS_INPUT_LENGTH (SET_SRC (XVECEXP (body, 0, 0)));
-
-  else if (GET_CODE (body) == PARALLEL
-	   && GET_CODE (XVECEXP (body, 0, 0)) == ASM_OPERANDS)
-    return ASM_OPERANDS_INPUT_LENGTH (XVECEXP (body, 0, 0));
-
-  abort ();
+  switch (GET_CODE (body))
+    {
+    case SET:
+      gcc_assert (GET_CODE (SET_SRC (body)) == ASM_OPERANDS);
+      return ASM_OPERANDS_INPUT_LENGTH (SET_SRC (body));
+      
+    case ASM_OPERANDS:
+      return ASM_OPERANDS_INPUT_LENGTH (body);
+      
+    case PARALLEL:
+      return get_asm_operand_n_inputs (XVECEXP (body, 0, 0));
+      
+    default:
+      gcc_unreachable ();
+    }
 }
 
 /* If current function returns its result in an fp stack register,
@@ -838,16 +837,12 @@ stack_result (tree decl)
 static void
 replace_reg (rtx *reg, int regno)
 {
-  if (regno < FIRST_STACK_REG || regno > LAST_STACK_REG
-      || ! STACK_REG_P (*reg))
-    abort ();
+  gcc_assert (regno >= FIRST_STACK_REG);
+  gcc_assert (regno <= LAST_STACK_REG);
+  gcc_assert (STACK_REG_P (*reg));
 
-  switch (GET_MODE_CLASS (GET_MODE (*reg)))
-    {
-    default: abort ();
-    case MODE_FLOAT:
-    case MODE_COMPLEX_FLOAT:;
-    }
+  gcc_assert (GET_MODE_CLASS (GET_MODE (*reg)) == MODE_FLOAT
+	      || GET_MODE_CLASS (GET_MODE (*reg)) == MODE_COMPLEX_FLOAT);
 
   *reg = FP_MODE_REG (regno, GET_MODE (*reg));
 }
@@ -871,7 +866,7 @@ remove_regno_note (rtx insn, enum reg_note note, unsigned int regno)
     else
       note_link = &XEXP (this, 1);
 
-  abort ();
+  gcc_unreachable ();
 }
 
 /* Find the hard register number of virtual register REG in REGSTACK.
@@ -883,8 +878,7 @@ get_hard_regnum (stack regstack, rtx reg)
 {
   int i;
 
-  if (! STACK_REG_P (reg))
-    abort ();
+  gcc_assert (STACK_REG_P (reg));
 
   for (i = regstack->top; i >= 0; i--)
     if (regstack->reg[i] == REGNO (reg))
@@ -918,15 +912,13 @@ emit_pop_insn (rtx insn, stack regstack, rtx reg, enum emit_where where)
 	pop_insn = emit_pop_insn (insn, regstack, reg1, where);
       if (get_hard_regnum (regstack, reg2) >= 0)
 	pop_insn = emit_pop_insn (insn, regstack, reg2, where);
-      if (!pop_insn)
-	abort ();
+      gcc_assert (pop_insn);
       return pop_insn;
     }
 
   hard_regno = get_hard_regnum (regstack, reg);
 
-  if (hard_regno < FIRST_STACK_REG)
-    abort ();
+  gcc_assert (hard_regno >= FIRST_STACK_REG);
 
   pop_rtx = gen_rtx_SET (VOIDmode, FP_MODE_REG (hard_regno, DFmode),
 			 FP_MODE_REG (FIRST_STACK_REG, DFmode));
@@ -966,8 +958,7 @@ emit_swap_insn (rtx insn, stack regstack, rtx reg)
 
   hard_regno = get_hard_regnum (regstack, reg);
 
-  if (hard_regno < FIRST_STACK_REG)
-    abort ();
+  gcc_assert (hard_regno >= FIRST_STACK_REG);
   if (hard_regno == FIRST_STACK_REG)
     return;
 
@@ -1055,8 +1046,7 @@ swap_to_top (rtx insn, stack regstack, rtx src1, rtx src2)
 
   /* Place operand 1 at the top of stack.  */
   regno = get_hard_regnum (&temp_stack, src1);
-  if (regno < 0)
-    abort ();
+  gcc_assert (regno >= 0);
   if (regno != FIRST_STACK_REG)
     {
       k = temp_stack.top - (regno - FIRST_STACK_REG);
@@ -1069,8 +1059,7 @@ swap_to_top (rtx insn, stack regstack, rtx src1, rtx src2)
 
   /* Place operand 2 next on the stack.  */
   regno = get_hard_regnum (&temp_stack, src2);
-  if (regno < 0)
-    abort ();
+  gcc_assert (regno >= 0);
   if (regno != FIRST_STACK_REG + 1)
     {
       k = temp_stack.top - (regno - FIRST_STACK_REG);
@@ -1110,16 +1099,15 @@ move_for_stack_reg (rtx insn, stack regstack, rtx pat)
 	  int i;
 
 	  /* If this is a no-op move, there must not be a REG_DEAD note.  */
-	  if (REGNO (src) == REGNO (dest))
-	    abort ();
+	  gcc_assert (REGNO (src) != REGNO (dest));
 
 	  for (i = regstack->top; i >= 0; i--)
 	    if (regstack->reg[i] == REGNO (src))
 	      break;
 
 	  /* The source must be live, and the dest must be dead.  */
-	  if (i < 0 || get_hard_regnum (regstack, dest) >= FIRST_STACK_REG)
-	    abort ();
+	  gcc_assert (i >= 0);
+	  gcc_assert (get_hard_regnum (regstack, dest) < FIRST_STACK_REG);
 
 	  /* It is possible that the dest is unused after this insn.
 	     If so, just pop the src.  */
@@ -1156,8 +1144,7 @@ move_for_stack_reg (rtx insn, stack regstack, rtx pat)
 	}
 
       /* The destination ought to be dead.  */
-      if (get_hard_regnum (regstack, dest) >= FIRST_STACK_REG)
-	abort ();
+      gcc_assert (get_hard_regnum (regstack, dest) < FIRST_STACK_REG);
 
       replace_reg (psrc, get_hard_regnum (regstack, src));
 
@@ -1201,26 +1188,24 @@ move_for_stack_reg (rtx insn, stack regstack, rtx pat)
 
       replace_reg (psrc, FIRST_STACK_REG);
     }
-  else if (STACK_REG_P (dest))
+  else
     {
+      gcc_assert (STACK_REG_P (dest));
+
       /* Load from MEM, or possibly integer REG or constant, into the
 	 stack regs.  The actual target is always the top of the
 	 stack. The stack mapping is changed to reflect that DEST is
 	 now at top of stack.  */
 
       /* The destination ought to be dead.  */
-      if (get_hard_regnum (regstack, dest) >= FIRST_STACK_REG)
-	abort ();
+      gcc_assert (get_hard_regnum (regstack, dest) < FIRST_STACK_REG);
 
-      if (regstack->top >= REG_STACK_SIZE)
-	abort ();
+      gcc_assert (regstack->top < REG_STACK_SIZE);
 
       regstack->reg[++regstack->top] = REGNO (dest);
       SET_HARD_REG_BIT (regstack->reg_set, REGNO (dest));
       replace_reg (pdest, FIRST_STACK_REG);
     }
-  else
-    abort ();
 
   return control_flow_insn_deleted;
 }
@@ -1456,8 +1441,8 @@ subst_stack_regs_pat (rtx insn, stack regstack, rtx pat)
 	  return control_flow_insn_deleted;
 	}
       /* ??? Uninitialized USE should not happen.  */
-      else if (get_hard_regnum (regstack, *src) == -1)
-	abort ();
+      else
+	gcc_assert (get_hard_regnum (regstack, *src) != -1);
       break;
 
     case CLOBBER:
@@ -1483,8 +1468,7 @@ subst_stack_regs_pat (rtx insn, stack regstack, rtx pat)
 		else
 		  {
 		    note = find_reg_note (insn, REG_UNUSED, *dest);
-		    if (!note)
-		      abort ();
+		    gcc_assert (note);
 		  }
 		remove_note (insn, note);
 		replace_reg (dest, FIRST_STACK_REG + 1);
@@ -1560,8 +1544,7 @@ subst_stack_regs_pat (rtx insn, stack regstack, rtx pat)
 
 	  case REG:
 	    /* This is a `tstM2' case.  */
-	    if (*dest != cc0_rtx)
-	      abort ();
+	    gcc_assert (*dest == cc0_rtx);
 	    src1 = src;
 
 	    /* Fall through.  */
@@ -1636,8 +1619,8 @@ subst_stack_regs_pat (rtx insn, stack regstack, rtx pat)
 
 		src1_hard_regnum = get_hard_regnum (regstack, *src1);
 		src2_hard_regnum = get_hard_regnum (regstack, *src2);
-		if (src1_hard_regnum == -1 || src2_hard_regnum == -1)
-		  abort ();
+		gcc_assert (src1_hard_regnum != -1);
+		gcc_assert (src2_hard_regnum != -1);
 
 		if (src1_hard_regnum != FIRST_STACK_REG
 		    && src2_hard_regnum != FIRST_STACK_REG)
@@ -1743,8 +1726,7 @@ subst_stack_regs_pat (rtx insn, stack regstack, rtx pat)
 		/* Input should never die, it is
 		   replaced with output.  */
 		src1_note = find_regno_note (insn, REG_DEAD, REGNO (*src1));
-		if (src1_note)
-		  abort();
+		gcc_assert (!src1_note);
 
 		if (STACK_REG_P (*dest))
 		  replace_reg (dest, FIRST_STACK_REG);
@@ -1800,8 +1782,8 @@ subst_stack_regs_pat (rtx insn, stack regstack, rtx pat)
 
 		/* Inputs should never die, they are
 		   replaced with outputs.  */
-		if ((src1_note) || (src2_note))
-		  abort();
+		gcc_assert (!src1_note);
+		gcc_assert (!src2_note);
 
 		swap_to_top (insn, regstack, *src1, *src2);
 
@@ -1831,8 +1813,8 @@ subst_stack_regs_pat (rtx insn, stack regstack, rtx pat)
 
 		/* Inputs should never die, they are
 		   replaced with outputs.  */
-		if ((src1_note) || (src2_note))
-		  abort();
+		gcc_assert (!src1_note);
+		gcc_assert (!src2_note);
 
 		swap_to_top (insn, regstack, *src1, *src2);
 
@@ -1861,8 +1843,7 @@ subst_stack_regs_pat (rtx insn, stack regstack, rtx pat)
 		/* Input should never die, it is
 		   replaced with output.  */
 		src1_note = find_regno_note (insn, REG_DEAD, REGNO (*src1));
-		if (src1_note)
-		  abort();
+		gcc_assert (!src1_note);
 
 		/* Push the result back onto stack. Empty stack slot
 		   will be filled in second part of insn.  */
@@ -1888,8 +1869,7 @@ subst_stack_regs_pat (rtx insn, stack regstack, rtx pat)
 		/* Input should never die, it is
 		   replaced with output.  */
 		src1_note = find_regno_note (insn, REG_DEAD, REGNO (*src1));
-		if (src1_note)
-		  abort();
+		gcc_assert (!src1_note);
 
 		/* Push the result back onto stack. Fill empty slot from
 		   first part of insn and fix top of stack pointer.  */
@@ -1909,9 +1889,8 @@ subst_stack_regs_pat (rtx insn, stack regstack, rtx pat)
 		   The combination matches the PPRO fcomi instruction.  */
 
 		pat_src = XVECEXP (pat_src, 0, 0);
-		if (GET_CODE (pat_src) != UNSPEC
-		    || XINT (pat_src, 1) != UNSPEC_FNSTSW)
-		  abort ();
+		gcc_assert (GET_CODE (pat_src) == UNSPEC);
+		gcc_assert (XINT (pat_src, 1) == UNSPEC_FNSTSW);
 		/* Fall through.  */
 
 	      case UNSPEC_FNSTSW:
@@ -1920,14 +1899,13 @@ subst_stack_regs_pat (rtx insn, stack regstack, rtx pat)
 		   up before now.  */
 
 		pat_src = XVECEXP (pat_src, 0, 0);
-		if (GET_CODE (pat_src) != COMPARE)
-		  abort ();
+		gcc_assert (GET_CODE (pat_src) == COMPARE);
 
 		compare_for_stack_reg (insn, regstack, pat_src);
 		break;
 
 	      default:
-		abort ();
+		gcc_unreachable ();
 	      }
 	    break;
 
@@ -1994,17 +1972,13 @@ subst_stack_regs_pat (rtx insn, stack regstack, rtx pat)
 		    int regno = REGNO (XEXP (src_note[i], 0));
 
 		    /* If the register that dies is not at the top of
-		       stack, then move the top of stack to the dead reg */
-		    if (regno != regstack->reg[regstack->top])
-		      {
-			remove_regno_note (insn, REG_DEAD, regno);
-			emit_pop_insn (insn, regstack, XEXP (src_note[i], 0),
-				       EMIT_AFTER);
-		      }
-		    else
-		      /* Top of stack never dies, as it is the
-			 destination.  */
-		      abort ();
+		       stack, then move the top of stack to the dead reg.
+		       Top of stack should never die, as it is the
+		       destination.  */
+		    gcc_assert (regno != regstack->reg[regstack->top]);
+		    remove_regno_note (insn, REG_DEAD, regno);
+		    emit_pop_insn (insn, regstack, XEXP (src_note[i], 0),
+				    EMIT_AFTER);
 		  }
 	    }
 
@@ -2017,7 +1991,7 @@ subst_stack_regs_pat (rtx insn, stack regstack, rtx pat)
 	    break;
 
 	  default:
-	    abort ();
+	    gcc_unreachable ();
 	  }
 	break;
       }
@@ -2074,8 +2048,7 @@ subst_asm_stack_regs (rtx insn, stack regstack)
   n_inputs = get_asm_operand_n_inputs (body);
   n_outputs = recog_data.n_operands - n_inputs;
 
-  if (alt < 0)
-    abort ();
+  gcc_assert (alt >= 0);
 
   /* Strip SUBREGs here to make the following code simpler.  */
   for (i = 0; i < recog_data.n_operands; i++)
@@ -2168,8 +2141,7 @@ subst_asm_stack_regs (rtx insn, stack regstack)
 
 	int regno = get_hard_regnum (&temp_stack, recog_data.operand[i]);
 
-	if (regno < 0)
-	  abort ();
+	gcc_assert (regno >= 0);
 
 	if ((unsigned int) regno != REGNO (recog_data.operand[i]))
 	  {
@@ -2202,8 +2174,7 @@ subst_asm_stack_regs (rtx insn, stack regstack)
       {
 	int regnum = get_hard_regnum (regstack, recog_data.operand[i]);
 
-	if (regnum < 0)
-	  abort ();
+	gcc_assert (regnum >= 0);
 
 	replace_reg (recog_data.operand_loc[i], regnum);
       }
@@ -2213,8 +2184,7 @@ subst_asm_stack_regs (rtx insn, stack regstack)
       {
 	int regnum = get_hard_regnum (regstack, note_reg[i]);
 
-	if (regnum < 0)
-	  abort ();
+	gcc_assert (regnum >= 0);
 
 	replace_reg (note_loc[i], regnum);
       }
@@ -2228,7 +2198,7 @@ subst_asm_stack_regs (rtx insn, stack regstack)
       if (regnum >= 0)
 	{
 	  /* Sigh - clobbers always have QImode.  But replace_reg knows
-	     that these regs can't be MODE_INT and will abort.  Just put
+	     that these regs can't be MODE_INT and will assert.  Just put
 	     the right reg there without calling replace_reg.  */
 
 	  *clobber_loc[i] = FP_MODE_REG (regnum, DFmode);
@@ -2469,10 +2439,9 @@ change_stack (rtx insn, stack old, stack new, enum emit_where where)
 	 not their depth or liveliness.  */
 
       GO_IF_HARD_REG_EQUAL (old->reg_set, new->reg_set, win);
-      abort ();
+      gcc_unreachable ();
     win:
-      if (old->top != new->top)
-	abort ();
+      gcc_assert (old->top == new->top);
 
       /* If the stack is not empty (new->top != -1), loop here emitting
 	 swaps until the stack is correct.
@@ -2495,8 +2464,7 @@ change_stack (rtx insn, stack old, stack new, enum emit_where where)
 		  if (new->reg[reg] == old->reg[old->top])
 		    break;
 
-		if (reg == -1)
-		  abort ();
+		gcc_assert (reg != -1);
 
 		emit_swap_insn (insn, old,
 				FP_MODE_REG (old->reg[reg], DFmode));
@@ -2518,8 +2486,7 @@ change_stack (rtx insn, stack old, stack new, enum emit_where where)
       /* At this point there must be no differences.  */
 
       for (reg = old->top; reg >= 0; reg--)
-	if (old->reg[reg] != new->reg[reg])
-	  abort ();
+	gcc_assert (old->reg[reg] == new->reg[reg]);
     }
 
   if (update_end)
@@ -2731,7 +2698,7 @@ compensate_edge (edge e, FILE *file)
 
       CLEAR_HARD_REG_SET (tmp);
       GO_IF_HARD_REG_EQUAL (target_stack->reg_set, tmp, eh1);
-      abort ();
+      gcc_unreachable ();
     eh1:
 
       /* We are sure that there is st(0) live, otherwise we won't compensate.
@@ -2740,7 +2707,7 @@ compensate_edge (edge e, FILE *file)
       if (TEST_HARD_REG_BIT (regstack.reg_set, FIRST_STACK_REG + 1))
         SET_HARD_REG_BIT (tmp, FIRST_STACK_REG + 1);
       GO_IF_HARD_REG_EQUAL (regstack.reg_set, tmp, eh2);
-      abort ();
+      gcc_unreachable ();
     eh2:
 
       target_stack->top = -1;
@@ -2766,8 +2733,7 @@ compensate_edge (edge e, FILE *file)
       /* We don't support abnormal edges.  Global takes care to
          avoid any live register across them, so we should never
          have to insert instructions on such edges.  */
-      if (e->flags & EDGE_ABNORMAL)
-	abort ();
+      gcc_assert (!(e->flags & EDGE_ABNORMAL));
 
       current_block = NULL;
       start_sequence ();
@@ -2870,8 +2836,7 @@ convert_regs_1 (FILE *file, basic_block block)
       next = NEXT_INSN (insn);
 
       /* Ensure we have not missed a block boundary.  */
-      if (next == NULL)
-	abort ();
+      gcc_assert (next);
       if (insn == BB_END (block))
 	next = NULL;
 
@@ -2953,8 +2918,7 @@ convert_regs_1 (FILE *file, basic_block block)
      asms, we zapped the instruction itself, but that didn't produce the
      same pattern of register kills as before.  */
   GO_IF_HARD_REG_EQUAL (regstack.reg_set, bi->out_reg_set, win);
-  if (!any_malformed_asm)
-    abort ();
+  gcc_assert (any_malformed_asm);
  win:
   bi->stack_out = regstack;
 
@@ -2964,9 +2928,8 @@ convert_regs_1 (FILE *file, basic_block block)
       if (e->flags & EDGE_DFS_BACK
 	  || (e->dest == EXIT_BLOCK_PTR))
 	{
-	  if (!BLOCK_INFO (e->dest)->done
-	      && e->dest != block)
-	    abort ();
+	  gcc_assert (BLOCK_INFO (e->dest)->done
+		      || e->dest == block);
 	  inserted |= compensate_edge (e, file);
 	}
     }
@@ -2975,8 +2938,7 @@ convert_regs_1 (FILE *file, basic_block block)
       if (e != beste && !(e->flags & EDGE_DFS_BACK)
 	  && e->src != ENTRY_BLOCK_PTR)
 	{
-	  if (!BLOCK_INFO (e->src)->done)
-	    abort ();
+	  gcc_assert (BLOCK_INFO (e->src)->done);
 	  inserted |= compensate_edge (e, file);
 	}
     }