* 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, 105 insertions, 129 deletions

diff --git a/gcc/simplify-rtx.c b/gcc/simplify-rtx.c
index 285f898de80..eec2a5816a3 100644
--- a/gcc/simplify-rtx.c
+++ b/gcc/simplify-rtx.c
@@ -360,16 +360,15 @@ simplify_unary_operation (enum rtx_code code, enum machine_mode mode,
 
   if (code == VEC_DUPLICATE)
     {
-      if (!VECTOR_MODE_P (mode))
-	abort ();
-      if (GET_MODE (trueop) != VOIDmode
-	  && !VECTOR_MODE_P (GET_MODE (trueop))
-	  && GET_MODE_INNER (mode) != GET_MODE (trueop))
-	abort ();
-      if (GET_MODE (trueop) != VOIDmode
-	  && VECTOR_MODE_P (GET_MODE (trueop))
-	  && GET_MODE_INNER (mode) != GET_MODE_INNER (GET_MODE (trueop)))
-	abort ();
+      gcc_assert (VECTOR_MODE_P (mode));
+      if (GET_MODE (trueop) != VOIDmode)
+      {
+	if (!VECTOR_MODE_P (GET_MODE (trueop)))
+	  gcc_assert (GET_MODE_INNER (mode) == GET_MODE (trueop));
+	else
+	  gcc_assert (GET_MODE_INNER (mode) == GET_MODE_INNER
+						(GET_MODE (trueop)));
+      }
       if (GET_CODE (trueop) == CONST_INT || GET_CODE (trueop) == CONST_DOUBLE
 	  || GET_CODE (trueop) == CONST_VECTOR)
 	{
@@ -387,8 +386,8 @@ simplify_unary_operation (enum rtx_code code, enum machine_mode mode,
               int in_elt_size = GET_MODE_SIZE (GET_MODE_INNER (inmode));
               unsigned in_n_elts = (GET_MODE_SIZE (inmode) / in_elt_size);
 
-	      if (in_n_elts >= n_elts || n_elts % in_n_elts)
-		abort ();
+	      gcc_assert (in_n_elts < n_elts);
+	      gcc_assert ((n_elts % in_n_elts) == 0);
 	      for (i = 0; i < n_elts; i++)
 	        RTVEC_ELT (v, i) = CONST_VECTOR_ELT (trueop, i % in_n_elts);
 	    }
@@ -408,9 +407,7 @@ simplify_unary_operation (enum rtx_code code, enum machine_mode mode,
       rtvec v = rtvec_alloc (n_elts);
       unsigned int i;
 
-      if (op_n_elts != n_elts)
-	abort ();
-
+      gcc_assert (op_n_elts == n_elts);
       for (i = 0; i < n_elts; i++)
 	{
 	  rtx x = simplify_unary_operation (code, GET_MODE_INNER (mode),
@@ -541,15 +538,13 @@ simplify_unary_operation (enum rtx_code code, enum machine_mode mode,
 	case ZERO_EXTEND:
 	  /* When zero-extending a CONST_INT, we need to know its
              original mode.  */
-	  if (op_mode == VOIDmode)
-	    abort ();
+	  gcc_assert (op_mode != VOIDmode);
 	  if (GET_MODE_BITSIZE (op_mode) == HOST_BITS_PER_WIDE_INT)
 	    {
 	      /* If we were really extending the mode,
 		 we would have to distinguish between zero-extension
 		 and sign-extension.  */
-	      if (width != GET_MODE_BITSIZE (op_mode))
-		abort ();
+	      gcc_assert (width == GET_MODE_BITSIZE (op_mode));
 	      val = arg0;
 	    }
 	  else if (GET_MODE_BITSIZE (op_mode) < HOST_BITS_PER_WIDE_INT)
@@ -566,8 +561,7 @@ simplify_unary_operation (enum rtx_code code, enum machine_mode mode,
 	      /* If we were really extending the mode,
 		 we would have to distinguish between zero-extension
 		 and sign-extension.  */
-	      if (width != GET_MODE_BITSIZE (op_mode))
-		abort ();
+	      gcc_assert (width == GET_MODE_BITSIZE (op_mode));
 	      val = arg0;
 	    }
 	  else if (GET_MODE_BITSIZE (op_mode) < HOST_BITS_PER_WIDE_INT)
@@ -590,7 +584,7 @@ simplify_unary_operation (enum rtx_code code, enum machine_mode mode,
 	  return 0;
 
 	default:
-	  abort ();
+	  gcc_unreachable ();
 	}
 
       val = trunc_int_for_mode (val, mode);
@@ -690,8 +684,7 @@ simplify_unary_operation (enum rtx_code code, enum machine_mode mode,
 	  break;
 
 	case ZERO_EXTEND:
-	  if (op_mode == VOIDmode)
-	    abort ();
+	  gcc_assert (op_mode != VOIDmode);
 
 	  if (GET_MODE_BITSIZE (op_mode) > HOST_BITS_PER_WIDE_INT)
 	    return 0;
@@ -766,7 +759,7 @@ simplify_unary_operation (enum rtx_code code, enum machine_mode mode,
 	    real_from_target (&d, tmp, mode);
 	  }
 	default:
-	  abort ();
+	  gcc_unreachable ();
 	}
       return CONST_DOUBLE_FROM_REAL_VALUE (d, mode);
     }
@@ -864,7 +857,7 @@ simplify_unary_operation (enum rtx_code code, enum machine_mode mode,
 	  break;
 
 	default:
-	  abort ();
+	  gcc_unreachable ();
 	}
       return immed_double_const (xl, xh, mode);
     }
@@ -1175,16 +1168,12 @@ simplify_binary_operation (enum rtx_code code, enum machine_mode mode,
   rtx trueop0, trueop1;
   rtx tem;
 
-#ifdef ENABLE_CHECKING
   /* Relational operations don't work here.  We must know the mode
      of the operands in order to do the comparison correctly.
      Assuming a full word can give incorrect results.
      Consider comparing 128 with -128 in QImode.  */
-
-  if (GET_RTX_CLASS (code) == RTX_COMPARE
-      || GET_RTX_CLASS (code) == RTX_COMM_COMPARE)
-    abort ();
-#endif
+  gcc_assert (GET_RTX_CLASS (code) != RTX_COMPARE);
+  gcc_assert (GET_RTX_CLASS (code) != RTX_COMM_COMPARE);
 
   /* Make sure the constant is second.  */
   if (GET_RTX_CLASS (code) == RTX_COMM_ARITH
@@ -1211,9 +1200,8 @@ simplify_binary_operation (enum rtx_code code, enum machine_mode mode,
       rtvec v = rtvec_alloc (n_elts);
       unsigned int i;
 
-      if (op0_n_elts != n_elts || op1_n_elts != n_elts)
-	abort ();
-
+      gcc_assert (op0_n_elts == n_elts);
+      gcc_assert (op1_n_elts == n_elts);
       for (i = 0; i < n_elts; i++)
 	{
 	  rtx x = simplify_binary_operation (code, GET_MODE_INNER (mode),
@@ -1247,14 +1235,20 @@ simplify_binary_operation (enum rtx_code code, enum machine_mode mode,
 			  GET_MODE (op1));
 	  for (i = 0; i < 4; i++)
 	    {
-	      if (code == AND)
+	      switch (code)
+	      {
+	      case AND:
 		tmp0[i] &= tmp1[i];
-	      else if (code == IOR)
+		break;
+	      case IOR:
 		tmp0[i] |= tmp1[i];
-	      else if (code == XOR)
+		break;
+	      case XOR:
 		tmp0[i] ^= tmp1[i];
-	      else
-		abort ();
+		break;
+	      default:
+		gcc_unreachable ();
+	      }
 	    }
 	   real_from_target (&r, tmp0, mode);
 	   return CONST_DOUBLE_FROM_REAL_VALUE (r, mode);
@@ -2142,24 +2136,22 @@ simplify_binary_operation (enum rtx_code code, enum machine_mode mode,
 	case VEC_SELECT:
 	  if (!VECTOR_MODE_P (mode))
 	    {
-	      if (!VECTOR_MODE_P (GET_MODE (trueop0))
-		  || (mode
-		      != GET_MODE_INNER (GET_MODE (trueop0)))
-		  || GET_CODE (trueop1) != PARALLEL
-		  || XVECLEN (trueop1, 0) != 1
-		  || GET_CODE (XVECEXP (trueop1, 0, 0)) != CONST_INT)
-		abort ();
+	      gcc_assert (VECTOR_MODE_P (GET_MODE (trueop0)));
+	      gcc_assert (mode == GET_MODE_INNER (GET_MODE (trueop0)));
+	      gcc_assert (GET_CODE (trueop1) == PARALLEL);
+	      gcc_assert (XVECLEN (trueop1, 0) == 1);
+	      gcc_assert (GET_CODE (XVECEXP (trueop1, 0, 0)) == CONST_INT);
 
 	      if (GET_CODE (trueop0) == CONST_VECTOR)
-		return CONST_VECTOR_ELT (trueop0, INTVAL (XVECEXP (trueop1, 0, 0)));
+		return CONST_VECTOR_ELT (trueop0, INTVAL (XVECEXP
+							  (trueop1, 0, 0)));
 	    }
 	  else
 	    {
-	      if (!VECTOR_MODE_P (GET_MODE (trueop0))
-		  || (GET_MODE_INNER (mode)
-		      != GET_MODE_INNER (GET_MODE (trueop0)))
-		  || GET_CODE (trueop1) != PARALLEL)
-		abort ();
+	      gcc_assert (VECTOR_MODE_P (GET_MODE (trueop0)));
+	      gcc_assert (GET_MODE_INNER (mode)
+			  == GET_MODE_INNER (GET_MODE (trueop0)));
+	      gcc_assert (GET_CODE (trueop1) == PARALLEL);
 
 	      if (GET_CODE (trueop0) == CONST_VECTOR)
 		{
@@ -2168,15 +2160,14 @@ simplify_binary_operation (enum rtx_code code, enum machine_mode mode,
 		  rtvec v = rtvec_alloc (n_elts);
 		  unsigned int i;
 
-		  if (XVECLEN (trueop1, 0) != (int) n_elts)
-		    abort ();
+		  gcc_assert (XVECLEN (trueop1, 0) == (int) n_elts);
 		  for (i = 0; i < n_elts; i++)
 		    {
 		      rtx x = XVECEXP (trueop1, 0, i);
 
-		      if (GET_CODE (x) != CONST_INT)
-			abort ();
-		      RTVEC_ELT (v, i) = CONST_VECTOR_ELT (trueop0, INTVAL (x));
+		      gcc_assert (GET_CODE (x) == CONST_INT);
+		      RTVEC_ELT (v, i) = CONST_VECTOR_ELT (trueop0,
+							   INTVAL (x));
 		    }
 
 		  return gen_rtx_CONST_VECTOR (mode, v);
@@ -2192,24 +2183,21 @@ simplify_binary_operation (enum rtx_code code, enum machine_mode mode,
 					  ? GET_MODE (trueop1)
 					  : GET_MODE_INNER (mode));
 
-	    if (!VECTOR_MODE_P (mode)
-		|| (GET_MODE_SIZE (op0_mode) + GET_MODE_SIZE (op1_mode)
-		    != GET_MODE_SIZE (mode)))
-	      abort ();
-
-	    if ((VECTOR_MODE_P (op0_mode)
-		 && (GET_MODE_INNER (mode)
-		     != GET_MODE_INNER (op0_mode)))
-		|| (!VECTOR_MODE_P (op0_mode)
-		    && GET_MODE_INNER (mode) != op0_mode))
-	      abort ();
-
-	    if ((VECTOR_MODE_P (op1_mode)
-		 && (GET_MODE_INNER (mode)
-		     != GET_MODE_INNER (op1_mode)))
-		|| (!VECTOR_MODE_P (op1_mode)
-		    && GET_MODE_INNER (mode) != op1_mode))
-	      abort ();
+	    gcc_assert (VECTOR_MODE_P (mode));
+	    gcc_assert (GET_MODE_SIZE (op0_mode) + GET_MODE_SIZE (op1_mode)
+			== GET_MODE_SIZE (mode));
+
+	    if (VECTOR_MODE_P (op0_mode))
+	      gcc_assert (GET_MODE_INNER (mode)
+			  == GET_MODE_INNER (op0_mode));
+	    else
+	      gcc_assert (GET_MODE_INNER (mode) == op0_mode);
+
+	    if (VECTOR_MODE_P (op1_mode))
+	      gcc_assert (GET_MODE_INNER (mode)
+			  == GET_MODE_INNER (op1_mode));
+	    else
+	      gcc_assert (GET_MODE_INNER (mode) == op1_mode);
 
 	    if ((GET_CODE (trueop0) == CONST_VECTOR
 		 || GET_CODE (trueop0) == CONST_INT
@@ -2251,7 +2239,7 @@ simplify_binary_operation (enum rtx_code code, enum machine_mode mode,
 	  return 0;
 
 	default:
-	  abort ();
+	  gcc_unreachable ();
 	}
 
       return 0;
@@ -2413,7 +2401,7 @@ simplify_binary_operation (enum rtx_code code, enum machine_mode mode,
       return 0;
 
     default:
-      abort ();
+      gcc_unreachable ();
     }
 
   val = trunc_int_for_mode (val, mode);
@@ -2799,10 +2787,9 @@ simplify_const_relational_operation (enum rtx_code code,
   rtx trueop0;
   rtx trueop1;
 
-  if (mode == VOIDmode
-      && (GET_MODE (op0) != VOIDmode
-	  || GET_MODE (op1) != VOIDmode))
-    abort ();
+  gcc_assert (mode != VOIDmode
+	      || (GET_MODE (op0) == VOIDmode
+		  && GET_MODE (op1) == VOIDmode));
 
   /* If op0 is a compare, extract the comparison arguments from it.  */
   if (GET_CODE (op0) == COMPARE && op1 == const0_rtx)
@@ -3101,7 +3088,7 @@ simplify_const_relational_operation (enum rtx_code code,
     case UNORDERED:
       return const0_rtx;
     default:
-      abort ();
+      gcc_unreachable ();
     }
 }
 
@@ -3240,10 +3227,9 @@ simplify_ternary_operation (enum rtx_code code, enum machine_mode mode,
       break;
 
     case VEC_MERGE:
-      if (GET_MODE (op0) != mode
-	  || GET_MODE (op1) != mode
-	  || !VECTOR_MODE_P (mode))
-	abort ();
+      gcc_assert (GET_MODE (op0) == mode);
+      gcc_assert (GET_MODE (op1) == mode);
+      gcc_assert (VECTOR_MODE_P (mode));
       op2 = avoid_constant_pool_reference (op2);
       if (GET_CODE (op2) == CONST_INT)
 	{
@@ -3274,7 +3260,7 @@ simplify_ternary_operation (enum rtx_code code, enum machine_mode mode,
       break;
 
     default:
-      abort ();
+      gcc_unreachable ();
     }
 
   return 0;
@@ -3328,11 +3314,10 @@ simplify_immed_subreg (enum machine_mode outermode, rtx op,
       elems = &op;
       elem_bitsize = max_bitsize;
     }
-
-  if (BITS_PER_UNIT % value_bit != 0)
-    abort ();  /* Too complicated; reducing value_bit may help.  */
-  if (elem_bitsize % BITS_PER_UNIT != 0)
-    abort ();  /* I don't know how to handle endianness of sub-units.  */
+  /* If this asserts, it is too complicated; reducing value_bit may help.  */
+  gcc_assert (BITS_PER_UNIT % value_bit == 0);
+  /* I don't know how to handle endianness of sub-units.  */
+  gcc_assert (elem_bitsize % BITS_PER_UNIT == 0);
   
   for (elem = 0; elem < num_elem; elem++)
     {
@@ -3369,8 +3354,7 @@ simplify_immed_subreg (enum machine_mode outermode, rtx op,
 	    {
 	      /* If this triggers, someone should have generated a
 		 CONST_INT instead.  */
-	      if (elem_bitsize <= HOST_BITS_PER_WIDE_INT)
-		abort ();
+	      gcc_assert (elem_bitsize > HOST_BITS_PER_WIDE_INT);
 
 	      for (i = 0; i < HOST_BITS_PER_WIDE_INT; i += value_bit)
 		*vp++ = CONST_DOUBLE_LOW (el) >> i;
@@ -3385,15 +3369,14 @@ simplify_immed_subreg (enum machine_mode outermode, rtx op,
 	      for (; i < max_bitsize; i += value_bit)
 		*vp++ = 0;
 	    }
-	  else if (GET_MODE_CLASS (GET_MODE (el)) == MODE_FLOAT)
+	  else
 	    {
 	      long tmp[max_bitsize / 32];
 	      int bitsize = GET_MODE_BITSIZE (GET_MODE (el));
-	      
-	      if (bitsize > elem_bitsize)
-		abort ();
-	      if (bitsize % value_bit != 0)
-		abort ();
+
+	      gcc_assert (GET_MODE_CLASS (GET_MODE (el)) == MODE_FLOAT);
+	      gcc_assert (bitsize <= elem_bitsize);
+	      gcc_assert (bitsize % value_bit == 0);
 
 	      real_to_target (tmp, CONST_DOUBLE_REAL_VALUE (el),
 			      GET_MODE (el));
@@ -3417,12 +3400,10 @@ simplify_immed_subreg (enum machine_mode outermode, rtx op,
 	      for (; i < elem_bitsize; i += value_bit)
 		*vp++ = 0;
 	    }
-	  else
-	    abort ();
 	  break;
 	  
 	default:
-	  abort ();
+	  gcc_unreachable ();
 	}
     }
 
@@ -3442,8 +3423,7 @@ simplify_immed_subreg (enum machine_mode outermode, rtx op,
 
   /* BYTE should still be inside OP.  (Note that BYTE is unsigned,
      so if it's become negative it will instead be very large.)  */
-  if (byte >= GET_MODE_SIZE (innermode))
-    abort ();
+  gcc_assert (byte < GET_MODE_SIZE (innermode));
 
   /* Convert from bytes to chunks of size value_bit.  */
   value_start = byte * (BITS_PER_UNIT / value_bit);
@@ -3467,10 +3447,8 @@ simplify_immed_subreg (enum machine_mode outermode, rtx op,
   outer_class = GET_MODE_CLASS (outer_submode);
   elem_bitsize = GET_MODE_BITSIZE (outer_submode);
 
-  if (elem_bitsize % value_bit != 0)
-    abort ();
-  if (elem_bitsize + value_start * value_bit > max_bitsize)
-    abort ();
+  gcc_assert (elem_bitsize % value_bit == 0);
+  gcc_assert (elem_bitsize + value_start * value_bit <= max_bitsize);
 
   for (elem = 0; elem < num_elem; elem++)
     {
@@ -3540,7 +3518,7 @@ simplify_immed_subreg (enum machine_mode outermode, rtx op,
 	  break;
 	    
 	default:
-	  abort ();
+	  gcc_unreachable ();
 	}
     }
   if (VECTOR_MODE_P (outermode))
@@ -3556,17 +3534,16 @@ simplify_subreg (enum machine_mode outermode, rtx op,
 		 enum machine_mode innermode, unsigned int byte)
 {
   /* Little bit of sanity checking.  */
-  if (innermode == VOIDmode || outermode == VOIDmode
-      || innermode == BLKmode || outermode == BLKmode)
-    abort ();
+  gcc_assert (innermode != VOIDmode);
+  gcc_assert (outermode != VOIDmode);
+  gcc_assert (innermode != BLKmode);
+  gcc_assert (outermode != BLKmode);
 
-  if (GET_MODE (op) != innermode
-      && GET_MODE (op) != VOIDmode)
-    abort ();
+  gcc_assert (GET_MODE (op) == innermode
+	      || GET_MODE (op) == VOIDmode);
 
-  if (byte % GET_MODE_SIZE (outermode)
-      || byte >= GET_MODE_SIZE (innermode))
-    abort ();
+  gcc_assert ((byte % GET_MODE_SIZE (outermode)) == 0);
+  gcc_assert (byte < GET_MODE_SIZE (innermode));
 
   if (outermode == innermode && !byte)
     return op;
@@ -3772,17 +3749,16 @@ simplify_gen_subreg (enum machine_mode outermode, rtx op,
 {
   rtx newx;
   /* Little bit of sanity checking.  */
-  if (innermode == VOIDmode || outermode == VOIDmode
-      || innermode == BLKmode || outermode == BLKmode)
-    abort ();
+  gcc_assert (innermode != VOIDmode);
+  gcc_assert (outermode != VOIDmode);
+  gcc_assert (innermode != BLKmode);
+  gcc_assert (outermode != BLKmode);
 
-  if (GET_MODE (op) != innermode
-      && GET_MODE (op) != VOIDmode)
-    abort ();
+  gcc_assert (GET_MODE (op) == innermode
+	      || GET_MODE (op) == VOIDmode);
 
-  if (byte % GET_MODE_SIZE (outermode)
-      || byte >= GET_MODE_SIZE (innermode))
-    abort ();
+  gcc_assert ((byte % GET_MODE_SIZE (outermode)) == 0);
+  gcc_assert (byte < GET_MODE_SIZE (innermode));
 
   newx = simplify_subreg (outermode, op, innermode, byte);
   if (newx)