final.c (shorten_branches, [...]): Use gcc_assert and gcc_unreachable.

	* final.c (shorten_branches, final, get_insn_template,
	output_alternate_entry_point, final_scan_insn, alter_subreg,
	alter_cond, output_operand, asm_fprintf, final_forward_branch_p,
	leaf_renumber_regs_insn): Use gcc_assert and gcc_unreachable.
	* fix-header.c (lookup_std_proto): Likewise.
	* flow.c (first_insn_after_basic_block_note, verify_wide_reg,
	verify_local_live_at_start, update_life_info, mark_reg,
	calculate_global_regs_live, allocate_reg_life_data,
	init_propagate_block_info, mark_set_regs, flush_reg_cond_reg_1,
	ior_reg_cond, not_reg_cond, and_reg_cond, elim_reg_cond,
	attempt_auto_inc, mark_used_reg, mark_used_regs): Likewise.
	* fold-const.c (force_fit_type, div_and_round_double,
	may_negate_without_overflow_p, int_const_binop, const_binop,
	size_binop, size_diffop, fold_convert_const, fold_convert,
	invert_tree_comparison, swap_tree_comparison,
	comparison_to_compcode, compcode_to_comparison, invert_truthvalue,
	range_binop, make_range, fold_cond_expr_with_comparison,
	fold_div_compare, fold, fold_checksum_tree, fold_negate_const,
	fold_abs_const, fold_not_const, fold_relational_const, round_up,
	round_down): Likewise.
	* function.c (find_function_data, assign_stack_temp_for_type,
	instantiate_virtual_regs_lossage, aggregate_value_p,
	assign_parm_find_entry_rtl, assign_parm_setup_block,
	expand_function_start, expand_function_end, keep_stack_depressed,
	handle_epilogue_set, thread_prologue_and_epilogue_insns): Likewise.

From-SVN: r87192

gcc/ChangeLog

+2004-09-08  Nathan Sidwell  <nathan@codesourcery.com>
+
+	* final.c (shorten_branches, final, get_insn_template,
+	output_alternate_entry_point, final_scan_insn, alter_subreg,
+	alter_cond, output_operand, asm_fprintf, final_forward_branch_p,
+	leaf_renumber_regs_insn): Use gcc_assert and gcc_unreachable.
+	* fix-header.c (lookup_std_proto): Likewise.
+	* flow.c (first_insn_after_basic_block_note, verify_wide_reg,
+	verify_local_live_at_start, update_life_info, mark_reg,
+	calculate_global_regs_live, allocate_reg_life_data,
+	init_propagate_block_info, mark_set_regs, flush_reg_cond_reg_1,
+	ior_reg_cond, not_reg_cond, and_reg_cond, elim_reg_cond,
+	attempt_auto_inc, mark_used_reg, mark_used_regs): Likewise.
+	* fold-const.c (force_fit_type, div_and_round_double,
+	may_negate_without_overflow_p, int_const_binop, const_binop,
+	size_binop, size_diffop, fold_convert_const, fold_convert,
+	invert_tree_comparison, swap_tree_comparison,
+	comparison_to_compcode, compcode_to_comparison, invert_truthvalue,
+	range_binop, make_range, fold_cond_expr_with_comparison,
+	fold_div_compare, fold, fold_checksum_tree, fold_negate_const,
+	fold_abs_const, fold_not_const, fold_relational_const, round_up,
+	round_down): Likewise.
+	* function.c (find_function_data, assign_stack_temp_for_type,
+	instantiate_virtual_regs_lossage, aggregate_value_p,
+	assign_parm_find_entry_rtl, assign_parm_setup_block,
+	expand_function_start, expand_function_end, keep_stack_depressed,
+	handle_epilogue_set, thread_prologue_and_epilogue_insns): Likewise.
+
 2004-09-08  Daniel Berlin  <dberlin@dberlin.org>
 
 	* Makefile.in (tree-loop-linear.o): Added.

gcc/final.c

@@ -788,8 +788,7 @@ shorten_branches (rtx first ATTRIBUTE_UNUSED)
 
       /* Range of labels grows monotonically in the function.  Abort here
          means that the initialization of array got lost.  */
-      if (n_old_labels > n_labels)
-	abort ();
+      gcc_assert (n_old_labels <= n_labels);
 
       memset (label_align + n_old_labels, 0,
 	      (n_labels - n_old_labels) * sizeof (struct label_alignment));
@@ -933,8 +932,7 @@ shorten_branches (rtx first ATTRIBUTE_UNUSED)
 	    continue;
 	  pat = PATTERN (insn);
 	  len = XVECLEN (pat, 1);
-	  if (len <= 0)
-	    abort ();
+	  gcc_assert (len > 0);
 	  min_align = MAX_CODE_ALIGN;
 	  for (min = max_shuid, max = min_shuid, i = len - 1; i >= 0; i--)
 	    {
@@ -1566,10 +1564,8 @@ final (rtx first, FILE *file, int optimize, int prescan)
 	{
 	  /* This can be triggered by bugs elsewhere in the compiler if
 	     new insns are created after init_insn_lengths is called.  */
-	  if (NOTE_P (insn))
+	  gcc_assert (NOTE_P (insn));
 	  insn_current_address = -1;
-	  else
-	    abort ();
 	}
       else
 	insn_current_address = INSN_ADDRESSES (INSN_UID (insn));
@@ -1589,12 +1585,11 @@ get_insn_template (int code, rtx insn)
     case INSN_OUTPUT_FORMAT_MULTI:
       return insn_data[code].output.multi[which_alternative];
     case INSN_OUTPUT_FORMAT_FUNCTION:
-      if (insn == NULL)
-	abort ();
+      gcc_assert (insn);
       return (*insn_data[code].output.function) (recog_data.operand, insn);
 
     default:
-      abort ();
+      gcc_unreachable ();
     }
 }
 
@@ -1625,7 +1620,7 @@ output_alternate_entry_point (FILE *file, rtx insn)
 
     case LABEL_NORMAL:
     default:
-      abort ();
+      gcc_unreachable ();
     }
 }
 
@@ -1822,8 +1817,7 @@ final_scan_insn (rtx insn, FILE *file, int optimize ATTRIBUTE_UNUSED,
 
 	      /* End of a symbol-block.  */
 	      --block_depth;
-	      if (block_depth < 0)
-		abort ();
+	      gcc_assert (block_depth >= 0);
 
 	      (*debug_hooks->end_block) (high_block_linenum, n);
 	    }
@@ -1844,8 +1838,7 @@ final_scan_insn (rtx insn, FILE *file, int optimize ATTRIBUTE_UNUSED,
 	  break;
 
 	default:
-	  if (NOTE_LINE_NUMBER (insn) <= 0)
-	    abort ();
+	  gcc_assert (NOTE_LINE_NUMBER (insn) > 0);
 	  break;
 	}
       break;
@@ -2039,7 +2032,7 @@ final_scan_insn (rtx insn, FILE *file, int optimize ATTRIBUTE_UNUSED,
 #ifdef ASM_OUTPUT_ADDR_VEC
 		ASM_OUTPUT_ADDR_VEC (PREV_INSN (insn), body);
 #else
-		abort ();
+		gcc_unreachable ();
 #endif
 	      }
 	    else
@@ -2047,7 +2040,7 @@ final_scan_insn (rtx insn, FILE *file, int optimize ATTRIBUTE_UNUSED,
 #ifdef ASM_OUTPUT_ADDR_DIFF_VEC
 		ASM_OUTPUT_ADDR_DIFF_VEC (PREV_INSN (insn), body);
 #else
-		abort ();
+		gcc_unreachable ();
 #endif
 	      }
 #else
@@ -2060,7 +2053,7 @@ final_scan_insn (rtx insn, FILE *file, int optimize ATTRIBUTE_UNUSED,
 		    ASM_OUTPUT_ADDR_VEC_ELT
 		      (file, CODE_LABEL_NUMBER (XEXP (XVECEXP (body, 0, idx), 0)));
 #else
-		    abort ();
+		    gcc_unreachable ();
 #endif
 		  }
 		else
@@ -2072,7 +2065,7 @@ final_scan_insn (rtx insn, FILE *file, int optimize ATTRIBUTE_UNUSED,
 		       CODE_LABEL_NUMBER (XEXP (XVECEXP (body, 1, idx), 0)),
 		       CODE_LABEL_NUMBER (XEXP (XEXP (body, 0), 0)));
 #else
-		    abort ();
+		    gcc_unreachable ();
 #endif
 		  }
 	      }
@@ -2478,8 +2471,7 @@ final_scan_insn (rtx insn, FILE *file, int optimize ATTRIBUTE_UNUSED,
 	  {
 	    rtx prev;
 
-	    if (prev_nonnote_insn (insn) != last_ignored_compare)
-	      abort ();
+	    gcc_assert (prev_nonnote_insn (insn) == last_ignored_compare);
 
 	    /* We have already processed the notes between the setter and
 	       the user.  Make sure we don't process them again, this is
@@ -2510,7 +2502,7 @@ final_scan_insn (rtx insn, FILE *file, int optimize ATTRIBUTE_UNUSED,
 	    /* This instruction should have been split in shorten_branches,
 	       to ensure that we would have valid length info for the
 	       splitees.  */
-	    abort ();
+	    gcc_unreachable ();
 #endif
 
 	    return new;
@@ -2622,14 +2614,14 @@ alter_subreg (rtx *xp)
 
       if (new != 0)
 	*xp = new;
-      /* Simplify_subreg can't handle some REG cases, but we have to.  */
-      else if (REG_P (y))
+      else
 	{
+	  /* Simplify_subreg can't handle some REG cases, but we have to.  */
 	  unsigned int regno = subreg_hard_regno (x, 1);
+	  
+	  gcc_assert (REG_P (y));
 	  *xp = gen_rtx_REG_offset (y, GET_MODE (x), regno, SUBREG_BYTE (x));
 	}
-      else
-	abort ();
     }
 
   return *xp;
@@ -2780,7 +2772,7 @@ alter_cond (rtx cond)
     switch (GET_CODE (cond))
       {
       default:
-	abort ();
+	gcc_unreachable ();
 
       case NE:
 	PUT_CODE (cond, cc_status.flags & CC_Z_IN_N ? GE : LT);
@@ -3209,9 +3201,7 @@ output_operand (rtx x, int code ATTRIBUTE_UNUSED)
 
   /* If X is a pseudo-register, abort now rather than writing trash to the
      assembler file.  */
-
-  if (x && REG_P (x) && REGNO (x) >= FIRST_PSEUDO_REGISTER)
-    abort ();
+  gcc_assert (!x || !REG_P (x) || REGNO (x) < FIRST_PSEUDO_REGISTER);
 
   PRINT_OPERAND (asm_out_file, x, code);
 }
@@ -3510,7 +3500,7 @@ asm_fprintf (FILE *file, const char *p, ...)
 	  ASM_FPRINTF_EXTENSIONS (file, argptr, p)
 #endif
 	  default:
-	    abort ();
+	    gcc_unreachable ();
 	  }
 	break;
 
@@ -3711,13 +3701,12 @@ int
 final_forward_branch_p (rtx insn)
 {
   int insn_id, label_id;
-  if (!uid_shuid)
-    abort ();
+  
+  gcc_assert (uid_shuid);
   insn_id = INSN_SHUID (insn);
   label_id = INSN_SHUID (JUMP_LABEL (insn));
   /* We've hit some insns that does not have id information available.  */
-  if (!insn_id || !label_id)
-    abort ();
+  gcc_assert (insn_id && label_id);
   return insn_id < label_id;
 }
 
@@ -3809,8 +3798,7 @@ leaf_renumber_regs_insn (rtx in_rtx)
 	  return;
 	}
       newreg = LEAF_REG_REMAP (newreg);
-      if (newreg < 0)
-	abort ();
+      gcc_assert (newreg >= 0);
       regs_ever_live[REGNO (in_rtx)] = 0;
       regs_ever_live[newreg] = 1;
       REGNO (in_rtx) = newreg;
@@ -3853,7 +3841,7 @@ leaf_renumber_regs_insn (rtx in_rtx)
 	break;
 
       default:
-	abort ();
+	gcc_unreachable ();
       }
 }
 #endif

gcc/fix-header.c

@@ -397,8 +397,7 @@ lookup_std_proto (const char *name, int name_length)
 	  && strncmp (fn->fname, name, name_length) == 0)
 	return fn;
       i = (i+1) % HASH_SIZE;
-      if (i == i0)
-	abort ();
+      gcc_assert (i != i0);
     }
 }
 

gcc/flow.c

@@ -346,8 +346,7 @@ first_insn_after_basic_block_note (basic_block block)
     return NULL_RTX;
   if (LABEL_P (insn))
     insn = NEXT_INSN (insn);
-  if (!NOTE_INSN_BASIC_BLOCK_P (insn))
-    abort ();
+  gcc_assert (NOTE_INSN_BASIC_BLOCK_P (insn));
 
   return NEXT_INSN (insn);
 }
@@ -487,13 +486,12 @@ verify_wide_reg (int regno, basic_block bb)
 	break;
       head = NEXT_INSN (head);
     }
-
   if (dump_file)
     {
       fprintf (dump_file, "Register %d died unexpectedly.\n", regno);
       dump_bb (bb, dump_file, 0);
     }
-  abort ();
+  fatal_error ("internal consistency failure");
 }
 
 /* A subroutine of update_life_info.  Verify that there are no untoward
@@ -517,7 +515,7 @@ verify_local_live_at_start (regset new_live_at_start, basic_block bb)
 	      fputs ("Old:\n", dump_file);
 	      dump_bb (bb, dump_file, 0);
 	    }
-	  abort ();
+	  fatal_error ("internal consistency failure");
 	}
     }
   else
@@ -538,9 +536,8 @@ verify_local_live_at_start (regset new_live_at_start, basic_block bb)
 			   "Register %d died unexpectedly.\n", i);
 		  dump_bb (bb, dump_file, 0);
 		}
-	      abort ();
+	      fatal_error ("internal consistency failure");
 	    }
-
 	  /* Verify that the now-live register is wider than word_mode.  */
 	  verify_wide_reg (i, bb);
 	});
@@ -587,9 +584,8 @@ update_life_info (sbitmap blocks, enum update_life_extent extent, int prop_flags
 
   /* Changes to the CFG are only allowed when
      doing a global update for the entire CFG.  */
-  if ((prop_flags & PROP_ALLOW_CFG_CHANGES)
-      && (extent == UPDATE_LIFE_LOCAL || blocks))
-    abort ();
+  gcc_assert (!(prop_flags & PROP_ALLOW_CFG_CHANGES)
+	      || (extent != UPDATE_LIFE_LOCAL && !blocks));
 
   /* For a global update, we go through the relaxation process again.  */
   if (extent != UPDATE_LIFE_LOCAL)
@@ -901,8 +897,7 @@ mark_reg (rtx reg, void *xset)
   regset set = (regset) xset;
   int regno = REGNO (reg);
 
-  if (GET_MODE (reg) == BLKmode)
-    abort ();
+  gcc_assert (GET_MODE (reg) != BLKmode);
 
   SET_REGNO_REG_SET (set, regno);
   if (regno < FIRST_PSEUDO_REGISTER)
@@ -1025,8 +1020,7 @@ calculate_global_regs_live (sbitmap blocks_in, sbitmap blocks_out, int flags)
      sick behavior here.  */
 #ifdef ENABLE_CHECKING
   FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR, NULL, next_bb)
-    if (bb->aux)
-      abort ();
+    gcc_assert (!bb->aux);
 #endif
 
   tmp = INITIALIZE_REG_SET (tmp_head);
@@ -1436,8 +1430,7 @@ allocate_reg_life_data (void)
   int i;
 
   max_regno = max_reg_num ();
-  if (reg_deaths)
-    abort ();
+  gcc_assert (!reg_deaths);
   reg_deaths = xcalloc (sizeof (*reg_deaths), max_regno);
 
   /* Recalculate the register space, in case it has grown.  Old style
@@ -1845,14 +1838,13 @@ init_propagate_block_info (basic_block bb, regset live, regset local_set,
 	      bb_false = bb_true;
 	      bb_true = t;
 	    }
-	  else if (! (bb->succ->succ_next->flags & EDGE_FALLTHRU))
-	    abort ();
+	  else
+	    gcc_assert (bb->succ->succ_next->flags & EDGE_FALLTHRU);
 	}
       else
 	{
 	  /* This can happen with a conditional jump to the next insn.  */
-	  if (JUMP_LABEL (BB_END (bb)) != BB_HEAD (bb_true))
-	    abort ();
+	  gcc_assert (JUMP_LABEL (BB_END (bb)) == BB_HEAD (bb_true));
 
 	  /* Simplest way to do nothing.  */
 	  bb_false = bb_true;
@@ -2468,8 +2460,7 @@ mark_set_regs (struct propagate_block_info *pbi, rtx x, rtx insn)
 	    switch (code = GET_CODE (sub))
 	      {
 	      case COND_EXEC:
-		if (cond != NULL_RTX)
-		  abort ();
+		gcc_assert (!cond);
 
 		cond = COND_EXEC_TEST (sub);
 		sub = COND_EXEC_CODE (sub);
@@ -2958,8 +2949,8 @@ flush_reg_cond_reg_1 (splay_tree_node node, void *data)
       xdata[1] = node->key;
       return -1;
     }
-  else if (rcli->condition == const1_rtx)
-    abort ();
+  else
+    gcc_assert (rcli->condition != const1_rtx);
 
   return 0;
 }
@@ -3073,7 +3064,7 @@ ior_reg_cond (rtx old, rtx x, int add)
       return gen_rtx_IOR (0, old, x);
 
     default:
-      abort ();
+      gcc_unreachable ();
     }
 }
 
@@ -3089,8 +3080,7 @@ not_reg_cond (rtx x)
   if (COMPARISON_P (x)
       && REG_P (XEXP (x, 0)))
     {
-      if (XEXP (x, 1) != const0_rtx)
-	abort ();
+      gcc_assert (XEXP (x, 1) == const0_rtx);
 
       return gen_rtx_fmt_ee (reversed_comparison_code (x, NULL),
 			     VOIDmode, XEXP (x, 0), const0_rtx);
@@ -3182,7 +3172,7 @@ and_reg_cond (rtx old, rtx x, int add)
       return gen_rtx_AND (0, old, x);
 
     default:
-      abort ();
+      gcc_unreachable ();
     }
 }
 
@@ -3242,7 +3232,7 @@ elim_reg_cond (rtx x, unsigned int regno)
       return x;
 
     default:
-      abort ();
+      gcc_unreachable ();
     }
 }
 #endif /* HAVE_conditional_execution */
@@ -3264,6 +3254,7 @@ attempt_auto_inc (struct propagate_block_info *pbi, rtx inc, rtx insn,
   rtx q = SET_DEST (set);
   rtx y = SET_SRC (set);
   int opnum = XEXP (y, 0) == incr_reg ? 0 : 1;
+  int changed;
 
   /* Make sure this reg appears only once in this insn.  */
   if (count_occurrences (PATTERN (insn), incr_reg, 1) != 1)
@@ -3363,8 +3354,8 @@ attempt_auto_inc (struct propagate_block_info *pbi, rtx inc, rtx insn,
 
   /* Modify the old increment-insn to simply copy
      the already-incremented value of our register.  */
-  if (! validate_change (incr, &SET_SRC (set), incr_reg, 0))
-    abort ();
+  changed = validate_change (incr, &SET_SRC (set), incr_reg, 0);
+  gcc_assert (changed);
 
   /* If that makes it a no-op (copying the register into itself) delete
      it so it won't appear to be a "use" and a "set" of this
@@ -3570,10 +3561,7 @@ mark_used_reg (struct propagate_block_info *pbi, rtx reg,
       for (i = regno_first; i <= regno_last; ++i)
 	if (! REGNO_REG_SET_P (pbi->reg_live, i))
 	  {
-#ifdef ENABLE_CHECKING
-	    if (reg_deaths[i])
-	      abort ();
-#endif
+	    gcc_assert (!reg_deaths[i]);
 	    reg_deaths[i] = pbi->insn_num;
 	  }
     }
@@ -3925,8 +3913,7 @@ mark_used_regs (struct propagate_block_info *pbi, rtx x, rtx cond, rtx insn)
       }
 
     case COND_EXEC:
-      if (cond != NULL_RTX)
-	abort ();
+      gcc_assert (!cond);
 
       mark_used_regs (pbi, COND_EXEC_TEST (x), NULL_RTX, insn);
 

gcc/function.c

@@ -230,7 +230,7 @@ find_function_data (tree decl)
     if (p->decl == decl)
       return p;
 
-  abort ();
+  gcc_unreachable ();
 }
 
 /* Save the current context for compilation of a nested function.
@@ -604,12 +604,10 @@ assign_stack_temp_for_type (enum machine_mode mode, HOST_WIDE_INT size, int keep
 
   /* If SIZE is -1 it means that somebody tried to allocate a temporary
      of a variable size.  */
-  if (size == -1)
-    abort ();
+  gcc_assert (size != -1);
 
   /* These are now unused.  */
-  if (keep > 1)
-    abort ();
+  gcc_assert (keep <= 1);
 
   if (mode == BLKmode)
     align = BIGGEST_ALIGNMENT;
@@ -695,8 +693,7 @@ assign_stack_temp_for_type (enum machine_mode mode, HOST_WIDE_INT size, int keep
 	 So for requests which depended on the rounding of SIZE, we go ahead
 	 and round it now.  We also make sure ALIGNMENT is at least
 	 BIGGEST_ALIGNMENT.  */
-      if (mode == BLKmode && align < BIGGEST_ALIGNMENT)
-	abort ();
+      gcc_assert (mode != BLKmode || align == BIGGEST_ALIGNMENT);
       p->slot = assign_stack_local (mode,
 				    (mode == BLKmode
 				     ? CEIL_ROUND (size, (int) align / BITS_PER_UNIT)
@@ -1434,13 +1431,9 @@ instantiate_new_reg (rtx x, HOST_WIDE_INT *poffset)
 static void
 instantiate_virtual_regs_lossage (rtx insn)
 {
-  if (asm_noperands (PATTERN (insn)) >= 0)
-    {
+  gcc_assert (asm_noperands (PATTERN (insn)) >= 0);
   error_for_asm (insn, "impossible constraint in `asm'");
   delete_insn (insn);
-    }
-  else
-    abort ();
 }
 /* Given a pointer to a piece of rtx and an optional pointer to the
    containing object, instantiate any virtual registers present in it.
@@ -1862,7 +1855,7 @@ aggregate_value_p (tree exp, tree fntype)
 	break;
       default:
 	/* We don't expect other rtl types here.  */
-	abort();
+	gcc_unreachable ();
       }
 
   if (TREE_CODE (type) == VOID_TYPE)
@@ -2309,8 +2302,7 @@ assign_parm_find_entry_rtl (struct assign_parm_data_all *all,
 
 	  /* We assume at most one partial arg, and it must be the first
 	     argument on the stack.  */
-	  if (all->extra_pretend_bytes || all->pretend_args_size)
-	    abort ();
+	  gcc_assert (!all->extra_pretend_bytes && !all->pretend_args_size);
 
 	  pretend_bytes = partial * UNITS_PER_WORD;
 	  all->pretend_args_size = CEIL_ROUND (pretend_bytes, STACK_BYTES);
@@ -2567,8 +2559,8 @@ assign_parm_setup_block (tree parm, struct assign_parm_data_one *data)
 	}
       else if (GET_CODE (entry_parm) == PARALLEL)
 	;
-      else if (size != 0 && PARM_BOUNDARY % BITS_PER_WORD != 0)
-	abort ();
+      else
+	gcc_assert (!size || !(PARM_BOUNDARY % BITS_PER_WORD));
 
       mem = validize_mem (stack_parm);
 
@@ -4029,10 +4021,11 @@ expand_function_start (tree subr)
 	 so we may see a PARALLEL or a REG.  */
       if (REG_P (hard_reg))
 	SET_DECL_RTL (DECL_RESULT (subr), gen_reg_rtx (GET_MODE (hard_reg)));
-      else if (GET_CODE (hard_reg) == PARALLEL)
-	SET_DECL_RTL (DECL_RESULT (subr), gen_group_rtx (hard_reg));
       else
-	abort ();
+	{
+	  gcc_assert (GET_CODE (hard_reg) == PARALLEL);
+	  SET_DECL_RTL (DECL_RESULT (subr), gen_group_rtx (hard_reg));
+	}
 
       /* Set DECL_REGISTER flag so that expand_function_end will copy the
 	 result to the real return register(s).  */
@@ -4321,8 +4314,7 @@ expand_function_end (void)
 	  rtx real_decl_rtl = current_function_return_rtx;
 
 	  /* This should be set in assign_parms.  */
-	  if (! REG_FUNCTION_VALUE_P (real_decl_rtl))
-	    abort ();
+	  gcc_assert (REG_FUNCTION_VALUE_P (real_decl_rtl));
 
 	  /* If this is a BLKmode structure being returned in registers,
 	     then use the mode computed in expand_return.  Note that if
@@ -4680,19 +4672,27 @@ keep_stack_depressed (rtx insns)
 	      insn = next;
 	      continue;
 	    }
-	  else if (MEM_P (retaddr)
-		   && REG_P (XEXP (retaddr, 0)))
-	    base = gen_rtx_REG (Pmode, REGNO (XEXP (retaddr, 0))), offset = 0;
-	  else if (MEM_P (retaddr)
-		   && GET_CODE (XEXP (retaddr, 0)) == PLUS
-		   && REG_P (XEXP (XEXP (retaddr, 0), 0))
-		   && GET_CODE (XEXP (XEXP (retaddr, 0), 1)) == CONST_INT)
+	  else
+	    {
+	      rtx ret_ptr;
+	      gcc_assert (MEM_P (retaddr));
+
+	      ret_ptr = XEXP (retaddr, 0);
+	      
+	      if (REG_P (ret_ptr))
 		{
-	      base = gen_rtx_REG (Pmode, REGNO (XEXP (XEXP (retaddr, 0), 0)));
-	      offset = INTVAL (XEXP (XEXP (retaddr, 0), 1));
+		  base = gen_rtx_REG (Pmode, REGNO (ret_ptr));
+		  offset = 0;
 		}
 	      else
-	    abort ();
+		{
+		  gcc_assert (GET_CODE (ret_ptr) == PLUS
+			      && REG_P (XEXP (ret_ptr, 0))
+			      && GET_CODE (XEXP (ret_ptr, 1)) == CONST_INT);
+		  base = gen_rtx_REG (Pmode, REGNO (XEXP (ret_ptr, 0)));
+		  offset = INTVAL (XEXP (ret_ptr, 1));
+		}
+	    }
 
 	  /* If the base of the location containing the return pointer
 	     is SP, we must update it with the replacement address.  Otherwise,
@@ -4727,8 +4727,7 @@ keep_stack_depressed (rtx insns)
 		    && info.const_equiv[regno] == 0)
 		  break;
 
-	      if (regno == FIRST_PSEUDO_REGISTER)
-		abort ();
+	      gcc_assert (regno < FIRST_PSEUDO_REGISTER);
 
 	      reg = gen_rtx_REG (Pmode, regno);
 	      emit_move_insn (reg, retaddr);
@@ -4740,9 +4739,7 @@ keep_stack_depressed (rtx insns)
 
 	  /* Show the SET in the above insn is a RETURN.  */
 	  jump_set = single_set (jump_insn);
-	  if (jump_set == 0)
-	    abort ();
-	  else
+	  gcc_assert (jump_set);
 	  SET_IS_RETURN_P (jump_set) = 1;
 	}
 
@@ -4758,11 +4755,13 @@ keep_stack_depressed (rtx insns)
 	       && (info.sp_equiv_reg == stack_pointer_rtx
 		   || !reg_set_p (info.sp_equiv_reg, insn)))
 	{
-	  if (! validate_replace_rtx (stack_pointer_rtx,
+	  int changed;
+
+	  changed = validate_replace_rtx (stack_pointer_rtx,
 					  plus_constant (info.sp_equiv_reg,
 							 info.sp_offset),
-				      insn))
-	    abort ();
+					  insn);
+	  gcc_assert (changed);
 
 	  add_insn (insn);
 	}
@@ -4802,21 +4801,22 @@ handle_epilogue_set (rtx set, struct epi_info *p)
      set from.  If unknown, abort.  */
   if (reg_set_p (stack_pointer_rtx, set))
     {
-      if (SET_DEST (set) != stack_pointer_rtx)
-	abort ();
+      gcc_assert (SET_DEST (set) == stack_pointer_rtx);
 
       if (GET_CODE (SET_SRC (set)) == PLUS)
 	{
 	  p->new_sp_equiv_reg = XEXP (SET_SRC (set), 0);
 	  if (GET_CODE (XEXP (SET_SRC (set), 1)) == CONST_INT)
 	    p->new_sp_offset = INTVAL (XEXP (SET_SRC (set), 1));
-	  else if (REG_P (XEXP (SET_SRC (set), 1))
-		   && REGNO (XEXP (SET_SRC (set), 1)) < FIRST_PSEUDO_REGISTER
-		   && p->const_equiv[REGNO (XEXP (SET_SRC (set), 1))] != 0)
+	  else
+	    {
+	      gcc_assert (REG_P (XEXP (SET_SRC (set), 1))
+			  && (REGNO (XEXP (SET_SRC (set), 1))
+			      < FIRST_PSEUDO_REGISTER)
+			  && p->const_equiv[REGNO (XEXP (SET_SRC (set), 1))]);
 	      p->new_sp_offset
 		= INTVAL (p->const_equiv[REGNO (XEXP (SET_SRC (set), 1))]);
-	  else
-	    abort ();
+	    }
 	}
       else
 	p->new_sp_equiv_reg = SET_SRC (set), p->new_sp_offset = 0;
@@ -4828,8 +4828,7 @@ handle_epilogue_set (rtx set, struct epi_info *p)
 	  p->new_sp_offset += p->sp_offset;
 	}
 
-      if (p->new_sp_equiv_reg == 0 || !REG_P (p->new_sp_equiv_reg))
-	abort ();
+      gcc_assert (p->new_sp_equiv_reg && REG_P (p->new_sp_equiv_reg));
 
       return;
     }
@@ -4844,13 +4843,12 @@ handle_epilogue_set (rtx set, struct epi_info *p)
      Pmode).  */
   else if (p->new_sp_equiv_reg != 0 && reg_set_p (p->new_sp_equiv_reg, set))
     {
-      if (p->equiv_reg_src != 0
-	  || !REG_P (p->new_sp_equiv_reg)
-	  || !REG_P (SET_DEST (set))
-	  || GET_MODE_BITSIZE (GET_MODE (SET_DEST (set))) > BITS_PER_WORD
-	  || REGNO (p->new_sp_equiv_reg) != REGNO (SET_DEST (set)))
-	abort ();
-      else
+      gcc_assert (!p->equiv_reg_src
+		  && REG_P (p->new_sp_equiv_reg)
+		  && REG_P (SET_DEST (set))
+		  && (GET_MODE_BITSIZE (GET_MODE (SET_DEST (set)))
+		      <= BITS_PER_WORD)
+		  && REGNO (p->new_sp_equiv_reg) == REGNO (SET_DEST (set)));
       p->equiv_reg_src
 	= simplify_replace_rtx (SET_SRC (set), stack_pointer_rtx,
 				plus_constant (p->sp_equiv_reg,
@@ -4966,8 +4964,7 @@ thread_prologue_and_epilogue_insns (rtx f ATTRIBUTE_UNUSED)
       /* Can't deal with multiple successors of the entry block
          at the moment.  Function should always have at least one
          entry point.  */
-      if (!ENTRY_BLOCK_PTR->succ || ENTRY_BLOCK_PTR->succ->succ_next)
-	abort ();
+      gcc_assert (ENTRY_BLOCK_PTR->succ && !ENTRY_BLOCK_PTR->succ->succ_next);
 
       insert_insn_on_edge (seq, ENTRY_BLOCK_PTR->succ);
       inserted = 1;