1 files changed, 47 insertions, 58 deletions

diff --git a/gcc/reload1.c b/gcc/reload1.c
index 4dd1153dfd8..63f829fff77 100644
--- a/gcc/reload1.c
+++ b/gcc/reload1.c
@@ -536,8 +536,7 @@ compute_use_by_pseudos (HARD_REG_SET *to, regset from)
 	      BASIC_BLOCK->global_live_at_start, which might still
 	      contain registers that have not actually been allocated
 	      since they have an equivalence.  */
-	   if (! reload_completed)
-	     abort ();
+	   gcc_assert (reload_completed);
 	 }
        else
 	 {
@@ -584,11 +583,12 @@ replace_pseudos_in (rtx *loc, enum machine_mode mem_mode, rtx usage)
 	*loc = reg_equiv_mem[regno];
       else if (reg_equiv_address[regno])
 	*loc = gen_rtx_MEM (GET_MODE (x), reg_equiv_address[regno]);
-      else if (!REG_P (regno_reg_rtx[regno])
-	       || REGNO (regno_reg_rtx[regno]) != regno)
-	*loc = regno_reg_rtx[regno];
       else
-	abort ();
+	{
+	  gcc_assert (!REG_P (regno_reg_rtx[regno])
+		      || REGNO (regno_reg_rtx[regno]) != regno);
+	  *loc = regno_reg_rtx[regno];
+	}
 
       return;
     }
@@ -1071,8 +1071,7 @@ reload (rtx first, int global)
 
       reload_as_needed (global);
 
-      if (old_frame_size != get_frame_size ())
-	abort ();
+      gcc_assert (old_frame_size == get_frame_size ());
 
       if (num_eliminable)
 	verify_initial_elim_offsets ();
@@ -1576,8 +1575,7 @@ count_pseudo (int reg)
 
   SET_REGNO_REG_SET (&pseudos_counted, reg);
 
-  if (r < 0)
-    abort ();
+  gcc_assert (r >= 0);
 
   spill_add_cost[r] += freq;
 
@@ -1750,9 +1748,8 @@ find_reg (struct insn_chain *chain, int order)
 
   for (i = 0; i < rl->nregs; i++)
     {
-      if (spill_cost[best_reg + i] != 0
-	  || spill_add_cost[best_reg + i] != 0)
-	abort ();
+      gcc_assert (spill_cost[best_reg + i] == 0);
+      gcc_assert (spill_add_cost[best_reg + i] == 0);
       SET_HARD_REG_BIT (used_spill_regs_local, best_reg + i);
     }
   return 1;
@@ -2555,7 +2552,7 @@ eliminate_regs (rtx x, enum machine_mode mem_mode, rtx insn)
     case CLOBBER:
     case ASM_OPERANDS:
     case SET:
-      abort ();
+      gcc_unreachable ();
 
     default:
       break;
@@ -2867,13 +2864,12 @@ eliminate_regs_in_insn (rtx insn, int replace)
 
   if (! insn_is_asm && icode < 0)
     {
-      if (GET_CODE (PATTERN (insn)) == USE
-	  || GET_CODE (PATTERN (insn)) == CLOBBER
-	  || GET_CODE (PATTERN (insn)) == ADDR_VEC
-	  || GET_CODE (PATTERN (insn)) == ADDR_DIFF_VEC
-	  || GET_CODE (PATTERN (insn)) == ASM_INPUT)
-	return 0;
-      abort ();
+      gcc_assert (GET_CODE (PATTERN (insn)) == USE
+		  || GET_CODE (PATTERN (insn)) == CLOBBER
+		  || GET_CODE (PATTERN (insn)) == ADDR_VEC
+		  || GET_CODE (PATTERN (insn)) == ADDR_DIFF_VEC
+		  || GET_CODE (PATTERN (insn)) == ASM_INPUT);
+      return 0;
     }
 
   if (old_set != 0 && REG_P (SET_DEST (old_set))
@@ -3027,8 +3023,7 @@ eliminate_regs_in_insn (rtx insn, int replace)
 		    PATTERN (insn) = gen_rtx_PARALLEL (VOIDmode, vec);
 		    add_clobbers (PATTERN (insn), INSN_CODE (insn));
 		  }
-		if (INSN_CODE (insn) < 0)
-		  abort ();
+		gcc_assert (INSN_CODE (insn) >= 0);
 	      }
 	    /* If we have a nonzero offset, and the source is already
 	       a simple REG, the following transformation would
@@ -3299,13 +3294,11 @@ verify_initial_elim_offsets (void)
   for (ep = reg_eliminate; ep < &reg_eliminate[NUM_ELIMINABLE_REGS]; ep++)
     {
       INITIAL_ELIMINATION_OFFSET (ep->from, ep->to, t);
-      if (t != ep->initial_offset)
-	abort ();
+      gcc_assert (t == ep->initial_offset);
     }
 #else
   INITIAL_FRAME_POINTER_OFFSET (t);
-  if (t != reg_eliminate[0].initial_offset)
-    abort ();
+  gcc_assert (t == reg_eliminate[0].initial_offset);
 #endif
 }
 
@@ -3590,8 +3583,7 @@ finish_spills (int global)
        /* Record the current hard register the pseudo is allocated to in
 	  pseudo_previous_regs so we avoid reallocating it to the same
 	  hard reg in a later pass.  */
-       if (reg_renumber[i] < 0)
-	 abort ();
+       gcc_assert (reg_renumber[i] >= 0);
 
        SET_HARD_REG_BIT (pseudo_previous_regs[i], reg_renumber[i]);
        /* Mark it as no longer having a hard register home.  */
@@ -3670,7 +3662,7 @@ finish_spills (int global)
 
 	  /* Make sure we only enlarge the set.  */
 	  GO_IF_HARD_REG_SUBSET (used_by_pseudos2, chain->used_spill_regs, ok);
-	  abort ();
+	  gcc_unreachable ();
 	ok:;
 	}
     }
@@ -4265,7 +4257,7 @@ clear_reload_reg_in_use (unsigned int regno, int opnum,
       used_in_set = &reload_reg_used_in_insn;
       break;
     default:
-      abort ();
+      gcc_unreachable ();
     }
   /* We resolve conflicts with remaining reloads of the same type by
      excluding the intervals of reload registers by them from the
@@ -4461,8 +4453,10 @@ reload_reg_free_p (unsigned int regno, int opnum, enum reload_type type)
 
     case RELOAD_FOR_OTHER_ADDRESS:
       return ! TEST_HARD_REG_BIT (reload_reg_used_in_other_addr, regno);
+
+    default:
+      gcc_unreachable ();
     }
-  abort ();
 }
 
 /* Return 1 if the value in reload reg REGNO, as used by a reload
@@ -4594,9 +4588,10 @@ reload_reg_reaches_end_p (unsigned int regno, int opnum, enum reload_type type)
 	  return 0;
 
       return 1;
-    }
 
-  abort ();
+    default:
+      gcc_unreachable ();
+    }
 }
 
 /* Return 1 if the reloads denoted by R1 and R2 cannot share a register.
@@ -4671,7 +4666,7 @@ reloads_conflict (int r1, int r2)
       return 1;
 
     default:
-      abort ();
+      gcc_unreachable ();
     }
 }
 
@@ -5591,17 +5586,16 @@ choose_reload_regs (struct insn_chain *chain)
 		{
 		  if (REG_P (equiv))
 		    regno = REGNO (equiv);
-		  else if (GET_CODE (equiv) == SUBREG)
+		  else
 		    {
 		      /* This must be a SUBREG of a hard register.
 			 Make a new REG since this might be used in an
 			 address and not all machines support SUBREGs
 			 there.  */
+		      gcc_assert (GET_CODE (equiv) == SUBREG);
 		      regno = subreg_regno (equiv);
 		      equiv = gen_rtx_REG (rld[r].mode, regno);
 		    }
-		  else
-		    abort ();
 		}
 
 	      /* If we found a spill reg, reject it unless it is free
@@ -5805,15 +5799,13 @@ choose_reload_regs (struct insn_chain *chain)
 
       /* Some sanity tests to verify that the reloads found in the first
 	 pass are identical to the ones we have now.  */
-      if (chain->n_reloads != n_reloads)
-	abort ();
+      gcc_assert (chain->n_reloads == n_reloads);
 
       for (i = 0; i < n_reloads; i++)
 	{
 	  if (chain->rld[i].regno < 0 || chain->rld[i].reg_rtx != 0)
 	    continue;
-	  if (chain->rld[i].when_needed != rld[i].when_needed)
-	    abort ();
+	  gcc_assert (chain->rld[i].when_needed == rld[i].when_needed);
 	  for (j = 0; j < n_spills; j++)
 	    if (spill_regs[j] == chain->rld[i].regno)
 	      if (! set_reload_reg (j, i))
@@ -5926,10 +5918,9 @@ choose_reload_regs (struct insn_chain *chain)
 		SET_HARD_REG_BIT (reg_is_output_reload, i + nr);
 	    }
 
-	  if (rld[r].when_needed != RELOAD_OTHER
-	      && rld[r].when_needed != RELOAD_FOR_OUTPUT
-	      && rld[r].when_needed != RELOAD_FOR_INSN)
-	    abort ();
+	  gcc_assert (rld[r].when_needed == RELOAD_OTHER
+		      || rld[r].when_needed == RELOAD_FOR_OUTPUT
+		      || rld[r].when_needed == RELOAD_FOR_INSN);
 	}
     }
 }
@@ -6075,11 +6066,12 @@ merge_assigned_reloads (rtx insn)
 		     so abort.  */
 		  if (rld[j].reg_rtx)
 		    for (k = 0; k < j; k++)
-		      if (rld[k].in != 0 && rld[k].reg_rtx != 0
-			  && rld[k].when_needed == rld[j].when_needed
-			  && rtx_equal_p (rld[k].reg_rtx, rld[j].reg_rtx)
-			  && ! rtx_equal_p (rld[k].in, rld[j].in))
-			abort ();
+		      gcc_assert (rld[k].in == 0 || rld[k].reg_rtx == 0
+				  || rld[k].when_needed != rld[j].when_needed
+				  || !rtx_equal_p (rld[k].reg_rtx,
+						   rld[j].reg_rtx)
+				  || rtx_equal_p (rld[k].in,
+						  rld[j].in));
 		}
 	}
     }
@@ -6293,7 +6285,7 @@ emit_input_reload_insns (struct insn_chain *chain, struct reload *rl,
       where = &other_input_address_reload_insns;
       break;
     default:
-      abort ();
+      gcc_unreachable ();
     }
 
   push_to_sequence (*where);
@@ -6304,8 +6296,7 @@ emit_input_reload_insns (struct insn_chain *chain, struct reload *rl,
       /* We are not going to bother supporting the case where a
 	 incremented register can't be copied directly from
 	 OLDEQUIV since this seems highly unlikely.  */
-      if (rl->secondary_in_reload >= 0)
-	abort ();
+      gcc_assert (rl->secondary_in_reload < 0);
 
       if (reload_inherited[j])
 	oldequiv = reloadreg;
@@ -6921,8 +6912,7 @@ do_output_reload (struct insn_chain *chain, struct reload *rl, int j)
     return;
 
   /* If is a JUMP_INSN, we can't support output reloads yet.  */
-  if (JUMP_P (insn))
-    abort ();
+  gcc_assert (!JUMP_P (insn));
 
   emit_output_reload_insns (chain, rld + j, j);
 }
@@ -8066,8 +8056,7 @@ fixup_abnormal_edges (void)
 		 && !can_throw_internal (insn)
 		 && insn != BB_HEAD (bb))
 	    insn = PREV_INSN (insn);
-	  if (!CALL_P (insn) && !can_throw_internal (insn))
-	    abort ();
+	  gcc_assert (CALL_P (insn) || can_throw_internal (insn));
 	  BB_END (bb) = insn;
 	  inserted = true;
 	  insn = NEXT_INSN (insn);