pa.c (legitimize_pic_address): Use gcc_assert and gcc_unreachable as appropriate.

	* config/pa/pa.c (legitimize_pic_address): Use gcc_assert and
	gcc_unreachable as appropriate.
	(force_mode, emit_move_sequence, singlemove_string,
	output_move_double, output_fp_move_double, find_addr_reg,
	output_block_move, output_block_clear, output_and,
	output_64bit_and, output_ior, output_64bit_ior, store_reg_modify,
	pa_adjust_cost, pa_issue_rate, print_operand,
	output_global_address, output_arg_descriptor, output_cbranch,
	output_lbranch, output_bb, output_bvb, output_dbra, output_movb,
	output_call): Likewise.
	* config/pa/pa.md (call, call_value, sibcall, sibcall_value,
	prefetch, prefetch_cc, prefetch_nocc): Likewise.

From-SVN: r98559

3 files changed, 187 insertions, 204 deletions

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index ee63957..cede561 100644
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,18 @@
+2005-04-22  Nathan Sidwell  <nathan@codesourcery.com>
+
+	* config/pa/pa.c (legitimize_pic_address): Use gcc_assert and
+	gcc_unreachable as appropriate.
+	(force_mode, emit_move_sequence, singlemove_string,
+	output_move_double, output_fp_move_double, find_addr_reg,
+	output_block_move, output_block_clear, output_and,
+	output_64bit_and, output_ior, output_64bit_ior, store_reg_modify,
+	pa_adjust_cost, pa_issue_rate, print_operand,
+	output_global_address, output_arg_descriptor, output_cbranch,
+	output_lbranch, output_bb, output_bvb, output_dbra, output_movb,
+	output_call): Likewise.
+	* config/pa/pa.md (call, call_value, sibcall, sibcall_value,
+	prefetch, prefetch_cc, prefetch_nocc): Likewise.
+
 2005-04-22  Zdenek Dvorak  <dvorakz@suse.cz>
 
 	* Makefile.in (LIBGCOV): Add _gcov_interval_profiler,
diff --git a/gcc/config/pa/pa.c b/gcc/config/pa/pa.c
index 3e92a16..e77a6ed 100644
--- a/gcc/config/pa/pa.c
+++ b/gcc/config/pa/pa.c
@@ -652,8 +652,7 @@ legitimize_pic_address (rtx orig, enum machine_mode mode, rtx reg)
     {
       rtx insn, tmp_reg;
 
-      if (reg == 0)
-	abort ();
+      gcc_assert (reg);
 
       /* Before reload, allocate a temporary register for the intermediate
 	 result.  This allows the sequence to be deleted when the final
@@ -688,17 +687,12 @@ legitimize_pic_address (rtx orig, enum machine_mode mode, rtx reg)
 	  && XEXP (XEXP (orig, 0), 0) == pic_offset_table_rtx)
 	return orig;
 
-      if (reg == 0)
-	abort ();
-
-      if (GET_CODE (XEXP (orig, 0)) == PLUS)
-	{
-	  base = legitimize_pic_address (XEXP (XEXP (orig, 0), 0), Pmode, reg);
-	  orig = legitimize_pic_address (XEXP (XEXP (orig, 0), 1), Pmode,
-					 base == reg ? 0 : reg);
-	}
-      else
-	abort ();
+      gcc_assert (reg);
+      gcc_assert (GET_CODE (XEXP (orig, 0)) == PLUS);
+      
+      base = legitimize_pic_address (XEXP (XEXP (orig, 0), 0), Pmode, reg);
+      orig = legitimize_pic_address (XEXP (XEXP (orig, 0), 1), Pmode,
+				     base == reg ? 0 : reg);
 
       if (GET_CODE (orig) == CONST_INT)
 	{
@@ -1227,8 +1221,7 @@ force_mode (enum machine_mode mode, rtx orig)
   if (mode == GET_MODE (orig))
     return orig;
 
-  if (REGNO (orig) >= FIRST_PSEUDO_REGISTER)
-    abort ();
+  gcc_assert (REGNO (orig) < FIRST_PSEUDO_REGISTER);
 
   return gen_rtx_REG (mode, REGNO (orig));
 }
@@ -1256,8 +1249,7 @@ emit_move_sequence (rtx *operands, enum machine_mode mode, rtx scratch_reg)
   if (GET_CODE (operand0) == MEM && IS_INDEX_ADDR_P (XEXP (operand0, 0)))
     {
       /* This is only safe up to the beginning of life analysis.  */
-      if (no_new_pseudos)
-	abort ();
+      gcc_assert (!no_new_pseudos);
 
       tem = copy_to_mode_reg (Pmode, XEXP (operand0, 0));
       operand0 = replace_equiv_address (operand0, tem);
@@ -1631,8 +1623,7 @@ emit_move_sequence (rtx *operands, enum machine_mode mode, rtx scratch_reg)
 		{
 		  /* Save away the constant part of the expression.  */
 		  const_part = XEXP (XEXP (operand1, 0), 1);
-		  if (GET_CODE (const_part) != CONST_INT)
-		    abort ();
+		  gcc_assert (GET_CODE (const_part) == CONST_INT);
 
 		  /* Force the function label into memory.  */
 		  temp = force_const_mem (mode, XEXP (XEXP (operand1, 0), 0));
@@ -1974,8 +1965,7 @@ singlemove_string (rtx *operands)
       long i;
       REAL_VALUE_TYPE d;
 
-      if (GET_MODE (operands[1]) != SFmode)
-	abort ();
+      gcc_assert (GET_MODE (operands[1]) == SFmode);
 
       /* Translate the CONST_DOUBLE to a CONST_INT with the same target
 	 bit pattern.  */
@@ -2110,11 +2100,8 @@ output_move_double (rtx *operands)
     optype1 = RNDOP;
 
   /* Check for the cases that the operand constraints are not
-     supposed to allow to happen.  Abort if we get one,
-     because generating code for these cases is painful.  */
-
-  if (optype0 != REGOP && optype1 != REGOP)
-    abort ();
+     supposed to allow to happen.  */
+  gcc_assert (optype0 == REGOP || optype1 == REGOP);
 
    /* Handle auto decrementing and incrementing loads and stores
      specifically, since the structure of the function doesn't work
@@ -2133,40 +2120,33 @@ output_move_double (rtx *operands)
 	  rtx high_reg = gen_rtx_SUBREG (SImode, operands[1], 0);
 
 	  operands[0] = XEXP (addr, 0);
-	  if (GET_CODE (operands[1]) != REG || GET_CODE (operands[0]) != REG)
-	    abort ();
+	  gcc_assert (GET_CODE (operands[1]) == REG
+		      && GET_CODE (operands[0]) == REG);
 
-	  if (!reg_overlap_mentioned_p (high_reg, addr))
-	    {
-	      /* No overlap between high target register and address
-		 register.  (We do this in a non-obvious way to
-		 save a register file writeback)  */
-	      if (GET_CODE (addr) == POST_INC)
-		return "{stws|stw},ma %1,8(%0)\n\tstw %R1,-4(%0)";
-	      return "{stws|stw},ma %1,-8(%0)\n\tstw %R1,12(%0)";
-	    }
-	  else
-	    abort ();
+	  gcc_assert (!reg_overlap_mentioned_p (high_reg, addr));
+	  
+	  /* No overlap between high target register and address
+	     register.  (We do this in a non-obvious way to
+	     save a register file writeback)  */
+	  if (GET_CODE (addr) == POST_INC)
+	    return "{stws|stw},ma %1,8(%0)\n\tstw %R1,-4(%0)";
+	  return "{stws|stw},ma %1,-8(%0)\n\tstw %R1,12(%0)";
 	}
       else if (GET_CODE (addr) == PRE_INC || GET_CODE (addr) == PRE_DEC)
 	{
 	  rtx high_reg = gen_rtx_SUBREG (SImode, operands[1], 0);
 
 	  operands[0] = XEXP (addr, 0);
-	  if (GET_CODE (operands[1]) != REG || GET_CODE (operands[0]) != REG)
-	    abort ();
-
-	  if (!reg_overlap_mentioned_p (high_reg, addr))
-	    {
-	      /* No overlap between high target register and address
-		 register.  (We do this in a non-obvious way to
-		 save a register file writeback)  */
-	      if (GET_CODE (addr) == PRE_INC)
-		return "{stws|stw},mb %1,8(%0)\n\tstw %R1,4(%0)";
-	      return "{stws|stw},mb %1,-8(%0)\n\tstw %R1,4(%0)";
-	    }
-	  else
-	    abort ();
+	  gcc_assert (GET_CODE (operands[1]) == REG
+		      && GET_CODE (operands[0]) == REG);
+	  
+	  gcc_assert (!reg_overlap_mentioned_p (high_reg, addr));
+	  /* No overlap between high target register and address
+	     register.  (We do this in a non-obvious way to save a
+	     register file writeback)  */
+	  if (GET_CODE (addr) == PRE_INC)
+	    return "{stws|stw},mb %1,8(%0)\n\tstw %R1,4(%0)";
+	  return "{stws|stw},mb %1,-8(%0)\n\tstw %R1,4(%0)";
 	}
     }
   if (optype1 == MEMOP)
@@ -2180,8 +2160,8 @@ output_move_double (rtx *operands)
 	  rtx high_reg = gen_rtx_SUBREG (SImode, operands[0], 0);
 
 	  operands[1] = XEXP (addr, 0);
-	  if (GET_CODE (operands[0]) != REG || GET_CODE (operands[1]) != REG)
-	    abort ();
+	  gcc_assert (GET_CODE (operands[0]) == REG
+		      && GET_CODE (operands[1]) == REG);
 
 	  if (!reg_overlap_mentioned_p (high_reg, addr))
 	    {
@@ -2207,8 +2187,8 @@ output_move_double (rtx *operands)
 	  rtx high_reg = gen_rtx_SUBREG (SImode, operands[0], 0);
 
 	  operands[1] = XEXP (addr, 0);
-	  if (GET_CODE (operands[0]) != REG || GET_CODE (operands[1]) != REG)
-	    abort ();
+	  gcc_assert (GET_CODE (operands[0]) == REG
+		      && GET_CODE (operands[1]) == REG);
 
 	  if (!reg_overlap_mentioned_p (high_reg, addr))
 	    {
@@ -2370,23 +2350,22 @@ output_fp_move_double (rtx *operands)
     {
       output_asm_insn ("fstd%F0 %1,%0", operands);
     }
-  else if (operands[1] == CONST0_RTX (GET_MODE (operands[0])))
+  else
     {
-      if (GET_CODE (operands[0]) == REG)
-	{
-	  rtx xoperands[2];
-	  xoperands[1] = gen_rtx_REG (SImode, REGNO (operands[0]) + 1);
-	  xoperands[0] = operands[0];
-	  output_asm_insn ("copy %%r0,%0\n\tcopy %%r0,%1", xoperands);
-	}
+      rtx xoperands[2];
+      
+      gcc_assert (operands[1] == CONST0_RTX (GET_MODE (operands[0])));
+      
       /* This is a pain.  You have to be prepared to deal with an
 	 arbitrary address here including pre/post increment/decrement.
 
 	 so avoid this in the MD.  */
-      else
-	abort ();
+      gcc_assert (GET_CODE (operands[0]) == REG);
+      
+      xoperands[1] = gen_rtx_REG (SImode, REGNO (operands[0]) + 1);
+      xoperands[0] = operands[0];
+      output_asm_insn ("copy %%r0,%0\n\tcopy %%r0,%1", xoperands);
     }
-  else abort ();
   return "";
 }
 
@@ -2407,11 +2386,10 @@ find_addr_reg (rtx addr)
       else if (CONSTANT_P (XEXP (addr, 1)))
 	addr = XEXP (addr, 0);
       else
-	abort ();
+	gcc_unreachable ();
     }
-  if (GET_CODE (addr) == REG)
-    return addr;
-  abort ();
+  gcc_assert (GET_CODE (addr) == REG);
+  return addr;
 }
 
 /* Emit code to perform a block move.
@@ -2542,7 +2520,7 @@ output_block_move (rtx *operands, int size_is_constant ATTRIBUTE_UNUSED)
 	return "";
 
       default:
-	abort ();
+	gcc_unreachable ();
     }
 }
 
@@ -2684,7 +2662,7 @@ output_block_clear (rtx *operands, int size_is_constant ATTRIBUTE_UNUSED)
 	return "";
 
       default:
-	abort ();
+	gcc_unreachable ();
     }
 }
 
@@ -2744,15 +2722,13 @@ output_and (rtx *operands)
 	if ((mask & (1 << ms0)) == 0)
 	  break;
 
-      if (ms0 != 32)
-	abort ();
+      gcc_assert (ms0 == 32);
 
       if (ls1 == 32)
 	{
 	  len = ls0;
 
-	  if (len == 0)
-	    abort ();
+	  gcc_assert (len);
 
 	  operands[2] = GEN_INT (len);
 	  return "{extru|extrw,u} %1,31,%2,%0";
@@ -2796,15 +2772,13 @@ output_64bit_and (rtx *operands)
 	if ((mask & ((unsigned HOST_WIDE_INT) 1 << ms0)) == 0)
 	  break;
 
-      if (ms0 != HOST_BITS_PER_WIDE_INT)
-	abort ();
+      gcc_assert (ms0 == HOST_BITS_PER_WIDE_INT);
 
       if (ls1 == HOST_BITS_PER_WIDE_INT)
 	{
 	  len = ls0;
 
-	  if (len == 0)
-	    abort ();
+	  gcc_assert (len);
 
 	  operands[2] = GEN_INT (len);
 	  return "extrd,u %1,63,%2,%0";
@@ -2843,8 +2817,7 @@ output_ior (rtx *operands)
     if ((mask & (1 << bs1)) == 0)
       break;
 
-  if (bs1 != 32 && ((unsigned HOST_WIDE_INT) 1 << bs1) <= mask)
-    abort ();
+  gcc_assert (bs1 == 32 || ((unsigned HOST_WIDE_INT) 1 << bs1) > mask);
 
   p = 31 - bs0;
   len = bs1 - bs0;
@@ -2873,9 +2846,8 @@ output_64bit_ior (rtx *operands)
     if ((mask & ((unsigned HOST_WIDE_INT) 1 << bs1)) == 0)
       break;
 
-  if (bs1 != HOST_BITS_PER_WIDE_INT
-      && ((unsigned HOST_WIDE_INT) 1 << bs1) <= mask)
-    abort ();
+  gcc_assert (bs1 == HOST_BITS_PER_WIDE_INT
+	      || ((unsigned HOST_WIDE_INT) 1 << bs1) > mask);
 
   p = 63 - bs0;
   len = bs1 - bs0;
@@ -3250,8 +3222,7 @@ store_reg_modify (int base, int reg, HOST_WIDE_INT mod)
 {
   rtx insn, basereg, srcreg, delta;
 
-  if (!VAL_14_BITS_P (mod))
-    abort ();
+  gcc_assert (VAL_14_BITS_P (mod));
 
   basereg = gen_rtx_REG (Pmode, base);
   srcreg = gen_rtx_REG (word_mode, reg);
@@ -4305,8 +4276,9 @@ pa_adjust_cost (rtx insn, rtx link, rtx dep_insn, int cost)
 
   attr_type = get_attr_type (insn);
 
-  if (REG_NOTE_KIND (link) == REG_DEP_ANTI)
+  switch (REG_NOTE_KIND (link))
     {
+    case REG_DEP_ANTI:
       /* Anti dependency; DEP_INSN reads a register that INSN writes some
 	 cycles later.  */
 
@@ -4386,9 +4358,8 @@ pa_adjust_cost (rtx insn, rtx link, rtx dep_insn, int cost)
 
       /* For other anti dependencies, the cost is 0.  */
       return 0;
-    }
-  else if (REG_NOTE_KIND (link) == REG_DEP_OUTPUT)
-    {
+
+    case REG_DEP_OUTPUT:
       /* Output dependency; DEP_INSN writes a register that INSN writes some
 	 cycles later.  */
       if (attr_type == TYPE_FPLOAD)
@@ -4471,9 +4442,10 @@ pa_adjust_cost (rtx insn, rtx link, rtx dep_insn, int cost)
 
       /* For other output dependencies, the cost is 0.  */
       return 0;
+
+    default:
+      gcc_unreachable ();
     }
-  else
-    abort ();
 }
 
 /* Adjust scheduling priorities.  We use this to try and keep addil
@@ -4523,7 +4495,7 @@ pa_issue_rate (void)
     case PROCESSOR_8000:	return 4;
 
     default:
-      abort ();
+      gcc_unreachable ();
     }
 }
 
@@ -4686,7 +4658,7 @@ print_operand (FILE *file, rtx x, int code)
 	case LTU:
 	  fputs ("<<", file);  break;
 	default:
-	  abort ();
+	  gcc_unreachable ();
 	}
       return;
     case 'N':			/* Condition, (N)egated */
@@ -4713,7 +4685,7 @@ print_operand (FILE *file, rtx x, int code)
 	case LTU:
 	  fputs (">>=", file);  break;
 	default:
-	  abort ();
+	  gcc_unreachable ();
 	}
       return;
     /* For floating point comparisons.  Note that the output
@@ -4753,7 +4725,7 @@ print_operand (FILE *file, rtx x, int code)
 	case ORDERED:
 	  fputs ("?", file);  break;
 	default:
-	  abort ();
+	  gcc_unreachable ();
 	}
       return;
     case 'S':			/* Condition, operands are (S)wapped.  */
@@ -4780,7 +4752,7 @@ print_operand (FILE *file, rtx x, int code)
 	case LTU:
 	  fputs (">>", file);  break;
 	default:
-	  abort ();
+	  gcc_unreachable ();
 	}
       return;
     case 'B':			/* Condition, (B)oth swapped and negate.  */
@@ -4807,51 +4779,33 @@ print_operand (FILE *file, rtx x, int code)
 	case LTU:
 	  fputs ("<<=", file);  break;
 	default:
-	  abort ();
+	  gcc_unreachable ();
 	}
       return;
     case 'k':
-      if (GET_CODE (x) == CONST_INT)
-	{
-	  fprintf (file, HOST_WIDE_INT_PRINT_DEC, ~INTVAL (x));
-	  return;
-	}
-      abort ();
+      gcc_assert (GET_CODE (x) == CONST_INT);
+      fprintf (file, HOST_WIDE_INT_PRINT_DEC, ~INTVAL (x));
+      return;
     case 'Q':
-      if (GET_CODE (x) == CONST_INT)
-	{
-	  fprintf (file, HOST_WIDE_INT_PRINT_DEC, 64 - (INTVAL (x) & 63));
-	  return;
-	}
-      abort ();
+      gcc_assert (GET_CODE (x) == CONST_INT);
+      fprintf (file, HOST_WIDE_INT_PRINT_DEC, 64 - (INTVAL (x) & 63));
+      return;
     case 'L':
-      if (GET_CODE (x) == CONST_INT)
-	{
-	  fprintf (file, HOST_WIDE_INT_PRINT_DEC, 32 - (INTVAL (x) & 31));
-	  return;
-	}
-      abort ();
+      gcc_assert (GET_CODE (x) == CONST_INT);
+      fprintf (file, HOST_WIDE_INT_PRINT_DEC, 32 - (INTVAL (x) & 31));
+      return;
     case 'O':
-      if (GET_CODE (x) == CONST_INT && exact_log2 (INTVAL (x)) >= 0)
-	{
-	  fprintf (file, "%d", exact_log2 (INTVAL (x)));
-	  return;
-	}
-      abort ();
+      gcc_assert (GET_CODE (x) == CONST_INT && exact_log2 (INTVAL (x)) >= 0);
+      fprintf (file, "%d", exact_log2 (INTVAL (x)));
+      return;
     case 'p':
-      if (GET_CODE (x) == CONST_INT)
-	{
-	  fprintf (file, HOST_WIDE_INT_PRINT_DEC, 63 - (INTVAL (x) & 63));
-	  return;
-	}
-      abort ();
+      gcc_assert (GET_CODE (x) == CONST_INT);
+      fprintf (file, HOST_WIDE_INT_PRINT_DEC, 63 - (INTVAL (x) & 63));
+      return;
     case 'P':
-      if (GET_CODE (x) == CONST_INT)
-	{
-	  fprintf (file, HOST_WIDE_INT_PRINT_DEC, 31 - (INTVAL (x) & 31));
-	  return;
-	}
-      abort ();
+      gcc_assert (GET_CODE (x) == CONST_INT);
+      fprintf (file, HOST_WIDE_INT_PRINT_DEC, 31 - (INTVAL (x) & 31));
+      return;
     case 'I':
       if (GET_CODE (x) == CONST_INT)
 	fputs ("i", file);
@@ -4926,7 +4880,7 @@ print_operand (FILE *file, rtx x, int code)
 	 addresses.  */
       break;
     default:
-      abort ();
+      gcc_unreachable ();
     }
   if (GET_CODE (x) == REG)
     {
@@ -5013,23 +4967,31 @@ output_global_address (FILE *file, rtx x, int round_constant)
       int offset = 0;		/* assembler wants -$global$ at end */
       rtx base = NULL_RTX;
 
-      if (GET_CODE (XEXP (XEXP (x, 0), 0)) == SYMBOL_REF)
+      switch (GET_CODE (XEXP (XEXP (x, 0), 0)))
 	{
+	case SYMBOL_REF:
 	  base = XEXP (XEXP (x, 0), 0);
 	  output_addr_const (file, base);
+	  break;
+	case CONST_INT:
+	  offset = INTVAL (XEXP (XEXP (x, 0), 0));
+	  break;
+	default:
+	  gcc_unreachable ();
 	}
-      else if (GET_CODE (XEXP (XEXP (x, 0), 0)) == CONST_INT)
-	offset = INTVAL (XEXP (XEXP (x, 0), 0));
-      else abort ();
 
-      if (GET_CODE (XEXP (XEXP (x, 0), 1)) == SYMBOL_REF)
+      switch (GET_CODE (XEXP (XEXP (x, 0), 1)))
 	{
+	case SYMBOL_REF:
 	  base = XEXP (XEXP (x, 0), 1);
 	  output_addr_const (file, base);
+	  break;
+	case CONST_INT:
+	  offset = INTVAL (XEXP (XEXP (x, 0), 1));
+	  break;
+	default:
+	  gcc_unreachable ();
 	}
-      else if (GET_CODE (XEXP (XEXP (x, 0), 1)) == CONST_INT)
-	offset = INTVAL (XEXP (XEXP (x, 0), 1));
-      else abort ();
 
       /* How bogus.  The compiler is apparently responsible for
 	 rounding the constant if it uses an LR field selector.
@@ -5043,8 +5005,9 @@ output_global_address (FILE *file, rtx x, int round_constant)
       if (round_constant)
 	offset = ((offset + 0x1000) & ~0x1fff);
 
-      if (GET_CODE (XEXP (x, 0)) == PLUS)
+      switch (GET_CODE (XEXP (x, 0)))
 	{
+	case PLUS:
 	  if (offset < 0)
 	    {
 	      offset = -offset;
@@ -5052,12 +5015,17 @@ output_global_address (FILE *file, rtx x, int round_constant)
 	    }
 	  else
 	    sep = "+";
-	}
-      else if (GET_CODE (XEXP (x, 0)) == MINUS
-	       && (GET_CODE (XEXP (XEXP (x, 0), 0)) == SYMBOL_REF))
-	sep = "-";
-      else abort ();
+	  break;
+
+	case MINUS:
+	  gcc_assert (GET_CODE (XEXP (XEXP (x, 0), 0)) == SYMBOL_REF);
+	  sep = "-";
+	  break;
 
+	default:
+	  gcc_unreachable ();
+	}
+      
       if (!read_only_operand (base, VOIDmode) && !flag_pic)
 	fputs ("-$global$", file);
       if (offset)
@@ -5441,9 +5409,9 @@ output_arg_descriptor (rtx call_insn)
       return;
     }
 
-  if (GET_CODE (call_insn) != CALL_INSN)
-    abort ();
-  for (link = CALL_INSN_FUNCTION_USAGE (call_insn); link; link = XEXP (link, 1))
+  gcc_assert (GET_CODE (call_insn) == CALL_INSN);
+  for (link = CALL_INSN_FUNCTION_USAGE (call_insn);
+       link; link = XEXP (link, 1))
     {
       rtx use = XEXP (link, 0);
 
@@ -6021,7 +5989,7 @@ output_cbranch (rtx *operands, int nullify, int length, int negated, rtx insn)
 	return output_lbranch (operands[0], insn);
 
       default:
-	abort ();
+	gcc_unreachable ();
     }
   return buf;
 }
@@ -6040,8 +6008,7 @@ output_lbranch (rtx dest, rtx insn)
   if (dbr_sequence_length () != 0)
     {
       /* We can't handle a jump in the delay slot.  */
-      if (GET_CODE (NEXT_INSN (insn)) == JUMP_INSN)
-	abort ();
+      gcc_assert (GET_CODE (NEXT_INSN (insn)) != JUMP_INSN);
 
       final_scan_insn (NEXT_INSN (insn), asm_out_file,
 		       optimize, 0, NULL);
@@ -6281,7 +6248,7 @@ output_bb (rtx *operands ATTRIBUTE_UNUSED, int nullify, int length,
 	break;
 
       default:
-	abort ();
+	gcc_unreachable ();
     }
   return buf;
 }
@@ -6426,7 +6393,7 @@ output_bvb (rtx *operands ATTRIBUTE_UNUSED, int nullify, int length,
 	break;
 
       default:
-	abort ();
+	gcc_unreachable ();
     }
   return buf;
 }
@@ -6475,13 +6442,15 @@ output_dbra (rtx *operands, rtx insn, int which_alternative)
       if (! nullify && length == 4 && dbr_sequence_length () == 0)
 	nullify = forward_branch_p (insn);
 
-      /* Handle short versions first.  */
-      if (length == 4 && nullify)
-	return "addib,%C2,n %1,%0,%3";
-      else if (length == 4 && ! nullify)
-	return "addib,%C2 %1,%0,%3";
-      else if (length == 8)
+      switch (length)
 	{
+	case 4:
+	  if (nullify)
+	    return "addib,%C2,n %1,%0,%3";
+	  else
+	    return "addib,%C2 %1,%0,%3";
+      
+	case 8:
 	  /* Handle weird backwards branch with a fulled delay slot
 	     which is nullified.  */
 	  if (dbr_sequence_length () != 0
@@ -6503,9 +6472,11 @@ output_dbra (rtx *operands, rtx insn, int which_alternative)
 	    return "addi,%N2 %1,%0,%0\n\tb,n %3";
 	  else
 	    return "addi,%N2 %1,%0,%0\n\tb %3";
+
+	default:
+	  gcc_unreachable ();
 	}
-      else
-	abort ();
+      
     }
   /* Deal with gross reload from FP register case.  */
   else if (which_alternative == 1)
@@ -6580,13 +6551,15 @@ output_movb (rtx *operands, rtx insn, int which_alternative,
       if (! nullify && length == 4 && dbr_sequence_length () == 0)
 	nullify = forward_branch_p (insn);
 
-      /* Handle short versions first.  */
-      if (length == 4 && nullify)
-	return "movb,%C2,n %1,%0,%3";
-      else if (length == 4 && ! nullify)
-	return "movb,%C2 %1,%0,%3";
-      else if (length == 8)
+      switch (length)
 	{
+	case 4:
+	  if (nullify)
+	    return "movb,%C2,n %1,%0,%3";
+	  else
+	    return "movb,%C2 %1,%0,%3";
+
+	case 8:
 	  /* Handle weird backwards branch with a filled delay slot
 	     which is nullified.  */
 	  if (dbr_sequence_length () != 0
@@ -6608,9 +6581,10 @@ output_movb (rtx *operands, rtx insn, int which_alternative,
 	    return "or,%N2 %1,%%r0,%0\n\tb,n %3";
 	  else
 	    return "or,%N2 %1,%%r0,%0\n\tb %3";
+
+	default:
+	  gcc_unreachable ();
 	}
-      else
-	abort ();
     }
   /* Deal with gross reload from FP register case.  */
   else if (which_alternative == 1)
@@ -7261,8 +7235,7 @@ output_call (rtx insn, rtx call_dest, int sibcall)
     return "";
 
   /* A sibcall should never have a branch in the delay slot.  */
-  if (sibcall)
-    abort ();
+  gcc_assert (!sibcall);
 
   /* This call has an unconditional jump in its delay slot.  */
   xoperands[0] = XEXP (PATTERN (NEXT_INSN (insn)), 1);
diff --git a/gcc/config/pa/pa.md b/gcc/config/pa/pa.md
index 6b8c77b..5e4faad 100644
--- a/gcc/config/pa/pa.md
+++ b/gcc/config/pa/pa.md
@@ -2814,9 +2814,9 @@
   "!is_function_label_plus_const (operands[2])"
   "*
 {
-  if (flag_pic && symbolic_operand (operands[2], Pmode))
-    abort ();
-  else if (symbolic_operand (operands[2], Pmode))
+  gcc_assert (!flag_pic || !symbolic_operand (operands[2], Pmode));
+  
+  if (symbolic_operand (operands[2], Pmode))
     return \"ldo RR'%G2(%1),%0\";
   else
     return \"ldo R'%G2(%1),%0\";
@@ -4070,8 +4070,9 @@
   rtx op0 = operands[0];
   rtx op1 = operands[1];
 
-  if (GET_CODE (op1) == CONST_INT)
+  switch (GET_CODE (op1))
     {
+    case CONST_INT:
       operands[0] = operand_subword (op0, 1, 0, DImode);
       output_asm_insn (\"ldil L'%1,%0\", operands);
 
@@ -4080,10 +4081,9 @@
 	output_asm_insn (\"ldi -1,%0\", operands);
       else
 	output_asm_insn (\"ldi 0,%0\", operands);
-      return \"\";
-    }
-  else if (GET_CODE (op1) == CONST_DOUBLE)
-    {
+      break;
+
+    case CONST_DOUBLE:
       operands[0] = operand_subword (op0, 1, 0, DImode);
       operands[1] = GEN_INT (CONST_DOUBLE_LOW (op1));
       output_asm_insn (\"ldil L'%1,%0\", operands);
@@ -4091,10 +4091,12 @@
       operands[0] = operand_subword (op0, 0, 0, DImode);
       operands[1] = GEN_INT (CONST_DOUBLE_HIGH (op1));
       output_asm_insn (singlemove_string (operands), operands);
-      return \"\";
+      break;
+
+    default:
+      gcc_unreachable ();
     }
-  else
-    abort ();
+  return \"\";
 }"
   [(set_attr "type" "move")
    (set_attr "length" "8")])
@@ -7070,8 +7072,7 @@ add,l %2,%3,%3\;bv,n %%r0(%3)"
 	     the only method that we have for doing DImode multiplication
 	     is with a libcall.  This could be trouble if we haven't
 	     allocated enough space for the outgoing arguments.  */
-	  if (INTVAL (nb) > current_function_outgoing_args_size)
-	    abort ();
+	  gcc_assert (INTVAL (nb) <= current_function_outgoing_args_size);
 
 	  emit_move_insn (arg_pointer_rtx,
 			  gen_rtx_PLUS (word_mode, stack_pointer_rtx,
@@ -7570,8 +7571,7 @@ add,l %2,%3,%3\;bv,n %%r0(%3)"
 	     the only method that we have for doing DImode multiplication
 	     is with a libcall.  This could be trouble if we haven't
 	     allocated enough space for the outgoing arguments.  */
-	  if (INTVAL (nb) > current_function_outgoing_args_size)
-	    abort ();
+	  gcc_assert (INTVAL (nb) <= current_function_outgoing_args_size);
 
 	  emit_move_insn (arg_pointer_rtx,
 			  gen_rtx_PLUS (word_mode, stack_pointer_rtx,
@@ -8089,8 +8089,7 @@ add,l %2,%3,%3\;bv,n %%r0(%3)"
 	     the only method that we have for doing DImode multiplication
 	     is with a libcall.  This could be trouble if we haven't
 	     allocated enough space for the outgoing arguments.  */
-	  if (INTVAL (nb) > current_function_outgoing_args_size)
-	    abort ();
+	  gcc_assert (INTVAL (nb) <= current_function_outgoing_args_size);
 
 	  emit_move_insn (arg_pointer_rtx,
 			  gen_rtx_PLUS (word_mode, stack_pointer_rtx,
@@ -8171,8 +8170,7 @@ add,l %2,%3,%3\;bv,n %%r0(%3)"
 	     the only method that we have for doing DImode multiplication
 	     is with a libcall.  This could be trouble if we haven't
 	     allocated enough space for the outgoing arguments.  */
-	  if (INTVAL (nb) > current_function_outgoing_args_size)
-	    abort ();
+	  gcc_assert (INTVAL (nb) <= current_function_outgoing_args_size);
 
 	  emit_move_insn (arg_pointer_rtx,
 			  gen_rtx_PLUS (word_mode, stack_pointer_rtx,
@@ -9263,8 +9261,7 @@ add,l %2,%3,%3\;bv,n %%r0(%3)"
 {
   int locality = INTVAL (operands[2]);
 
-  if (locality < 0 || locality > 3)
-    abort ();
+  gcc_assert (locality >= 0 && locality <= 3);
 
   /* Change operand[0] to a MEM as we don't have the infrastructure
      to output all the supported address modes for ldw/ldd when we use
@@ -9309,8 +9306,7 @@ add,l %2,%3,%3\;bv,n %%r0(%3)"
   };
   int read_or_write = INTVAL (operands[1]);
 
-  if (read_or_write < 0 || read_or_write > 1)
-    abort ();
+  gcc_assert (read_or_write >= 0 && read_or_write <= 1);
 
   return instr [read_or_write];
 }
@@ -9338,9 +9334,8 @@ add,l %2,%3,%3\;bv,n %%r0(%3)"
   };
   int read_or_write = INTVAL (operands[1]);
 
-  if ((which_alternative != 0 && which_alternative != 1)
-      || (read_or_write < 0 || read_or_write > 1))
-    abort ();
+  gcc_assert (which_alternative == 0 || which_alternative == 1);
+  gcc_assert (read_or_write >= 0 && read_or_write <= 1);
 
   return instr [which_alternative][read_or_write];
 }