* lambda.h (lambda_vector_min_nz): Likewise.

	* langhooks.h (struct lang_hooks_for_types,
	struct lang_hooks): Likewise.
	* output.h (assemble_integer, this_is_asm_operands): Likewise.
	* tree.h: Likewise.
	* vec.h: Likewise.
	* tree-flow-inline.h (relink_imm_use): Use gcc_assert.

	* optabs.c (prepare_cmp_insn, emit_cmp_and_jump_insns): Reword
	comments to avoid 'abort'.  Use gcc_assert as necessary.
	* opts.c (common_handle_option): Likewise.
	* pretty-print.c (pp_base_format_text): Likewise.
	* print-rtl.c (print_rtx): Likewise.
	* read-rtl.c (read_rtx_filename, read_rtx_1): Likewise.
	* regmove.c (try_auto_increment): Likewise.
	* reload.c (find_valid_class, find_reloads_toplev,
	find_equiv_reg): Likewise.
	* reload1.c (reload, forget_old_reloads_1, function_invariant_p,
	merge_assigned_reloads): Likewise.
	* tree-inline.c (inline_forbidden_p_1,
	estimate_num_insns_1): Likewise.
	* tree-optimize.c (execute_todo): Likewise.
	* tree-outof-ssa.c (eliminate_phi): Likewise.
	* tree-ssa-alias.c (add_pointed_to_expr): Likewise.
	* tree-ssa-ccp.c (maybe_fold_stmt_indirect): Likewise.
	* tree-ssa-operands.c (parse_ssa_operands,
	get_indirect_ref_operands, create_ssa_artficial_load_stmt): Likewise.
	* tree-ssa-pre.c (find_or_generate_expression): Likewise.
	* tree-ssanames.c (release_ssa_name): Likewise.
	* tree.c (int_bit_position, int_byte_position, tree_low_cst,
	walk_tree): Likewise.

	* tree-ssa-operands.c (verify_abort): Fold into ..
	(verify_imm_links): ... here.


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

25 files changed, 143 insertions, 173 deletions

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 9399f7e833c..811ff1deb61 100644
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,41 @@
+2005-04-21  Nathan Sidwell  <nathan@codesourcery.com>
+
+	* cfghooks.h (struct cfg_hooks): Reword comments to avoid 'abort'.
+	* lambda.h (lambda_vector_min_nz): Likewise.
+	* langhooks.h (struct lang_hooks_for_types,
+	struct lang_hooks): Likewise.
+	* output.h (assemble_integer, this_is_asm_operands): Likewise.
+	* tree.h: Likewise.
+	* vec.h: Likewise.
+	* tree-flow-inline.h (relink_imm_use): Use gcc_assert.
+	
+	* optabs.c (prepare_cmp_insn, emit_cmp_and_jump_insns): Reword
+	comments to avoid 'abort'.  Use gcc_assert as necessary.
+	* opts.c (common_handle_option): Likewise.
+	* pretty-print.c (pp_base_format_text): Likewise.
+	* print-rtl.c (print_rtx): Likewise.
+	* read-rtl.c (read_rtx_filename, read_rtx_1): Likewise.
+	* regmove.c (try_auto_increment): Likewise.
+	* reload.c (find_valid_class, find_reloads_toplev,
+	find_equiv_reg): Likewise.
+	* reload1.c (reload, forget_old_reloads_1, function_invariant_p, 
+	merge_assigned_reloads): Likewise.
+	* tree-inline.c (inline_forbidden_p_1,
+	estimate_num_insns_1): Likewise.
+	* tree-optimize.c (execute_todo): Likewise.
+	* tree-outof-ssa.c (eliminate_phi): Likewise.
+	* tree-ssa-alias.c (add_pointed_to_expr): Likewise.
+	* tree-ssa-ccp.c (maybe_fold_stmt_indirect): Likewise.
+	* tree-ssa-operands.c (parse_ssa_operands,
+	get_indirect_ref_operands, create_ssa_artficial_load_stmt): Likewise.
+	* tree-ssa-pre.c (find_or_generate_expression): Likewise.
+	* tree-ssanames.c (release_ssa_name): Likewise.
+	* tree.c (int_bit_position, int_byte_position, tree_low_cst, 
+	walk_tree): Likewise.
+
+	* tree-ssa-operands.c (verify_abort): Fold into ..
+	(verify_imm_links): ... here.
+
 2005-04-21  Richard Henderson  <rth@redhat.com>
 
 	* config/alpha/sync.md (sync_new_nand<I48MODE>): Fix constraints
@@ -85,8 +123,6 @@
 
 2005-04-21  Nathan Sidwell  <nathan@codesourcery.com>
 
-2005-04-21  Nathan Sidwell  <nathan@codesourcery.com>
-
 	* config/i386/i386.c (type_natural_mode): Use gcc_unreachable and
 	gcc_assert instead of abort.
 	(classify_argument, examine_argument, construct_container,
diff --git a/gcc/cfghooks.h b/gcc/cfghooks.h
index a05a0154c92..2a2ab3e864b 100644
--- a/gcc/cfghooks.h
+++ b/gcc/cfghooks.h
@@ -43,8 +43,8 @@ struct cfg_hooks
   edge (*redirect_edge_and_branch) (edge e, basic_block b);
 
   /* Same as the above but allows redirecting of fallthru edges.  In that case
-     newly created forwarder basic block is returned.  It aborts when called
-     on abnormal edge.  */
+     newly created forwarder basic block is returned.  The edge must
+     not be abnormal.  */
   basic_block (*redirect_edge_and_branch_force) (edge, basic_block);
 
   /* Remove statements corresponding to a given basic block.  */
diff --git a/gcc/lambda.h b/gcc/lambda.h
index 6e145ad4ce7..0c259d6924b 100644
--- a/gcc/lambda.h
+++ b/gcc/lambda.h
@@ -326,19 +326,15 @@ lambda_vector_min_nz (lambda_vector vec1, int n, int start)
 {
   int j;
   int min = -1;
-#ifdef ENABLE_CHECKING 
-  if (start > n)
-    abort ();
-#endif
+
+  gcc_assert (start <= n);
   for (j = start; j < n; j++)
     {
       if (vec1[j])
 	if (min < 0 || vec1[j] < vec1[min])
 	  min = j;
     }
-
-  if (min < 0)
-    abort ();
+  gcc_assert (min >= 0);
 
   return min;
 }
diff --git a/gcc/langhooks.h b/gcc/langhooks.h
index e3ff6724eff..e10592c9871 100644
--- a/gcc/langhooks.h
+++ b/gcc/langhooks.h
@@ -120,7 +120,7 @@ struct lang_hooks_for_types
   /* Given a type, apply default promotions to unnamed function
      arguments and return the new type.  Return the same type if no
      change.  Required by any language that supports variadic
-     arguments.  The default hook aborts.  */
+     arguments.  The default hook dies.  */
   tree (*type_promotes_to) (tree);
 
   /* Register TYPE as a builtin type with the indicated NAME.  The
@@ -207,7 +207,7 @@ struct lang_hooks
 
   /* Determines the size of any language-specific tcc_constant or
      tcc_exceptional nodes.  Since it is called from make_node, the
-     only information available is the tree code.  Expected to abort
+     only information available is the tree code.  Expected to die
      on unrecognized codes.  */
   size_t (*tree_size) (enum tree_code);
 
diff --git a/gcc/optabs.c b/gcc/optabs.c
index c180da17a9c..d67c6ce8917 100644
--- a/gcc/optabs.c
+++ b/gcc/optabs.c
@@ -3307,7 +3307,8 @@ can_compare_p (enum rtx_code code, enum machine_mode mode,
    comparison or emitting a library call to perform the comparison if no insn
    is available to handle it.
    The values which are passed in through pointers can be modified; the caller
-   should perform the comparison on the modified values.  */
+   should perform the comparison on the modified values.  Constant
+   comparisons must have already been folded.  */
 
 static void
 prepare_cmp_insn (rtx *px, rtx *py, enum rtx_code *pcomparison, rtx size,
@@ -3321,11 +3322,6 @@ prepare_cmp_insn (rtx *px, rtx *py, enum rtx_code *pcomparison, rtx size,
 
   class = GET_MODE_CLASS (mode);
 
-  /* They could both be VOIDmode if both args are immediate constants,
-     but we should fold that at an earlier stage.
-     With no special code here, this will call abort,
-     reminding the programmer to implement such folding.  */
-
   if (mode != BLKmode && flag_force_mem)
     {
       /* Load duplicate non-volatile operands once.  */
@@ -3352,9 +3348,9 @@ prepare_cmp_insn (rtx *px, rtx *py, enum rtx_code *pcomparison, rtx size,
     y = force_reg (mode, y);
 
 #ifdef HAVE_cc0
-  /* Abort if we have a non-canonical comparison.  The RTL documentation
-     states that canonical comparisons are required only for targets which
-     have cc0.  */
+  /* Make sure if we have a canonical comparison.  The RTL
+     documentation states that canonical comparisons are required only
+     for targets which have cc0.  */
   gcc_assert (!CONSTANT_P (x) || CONSTANT_P (y));
 #endif
 
@@ -3601,9 +3597,8 @@ emit_cmp_and_jump_insns (rtx x, rtx y, enum rtx_code comparison, rtx size,
     }
 
 #ifdef HAVE_cc0
-  /* If OP0 is still a constant, then both X and Y must be constants.  Force
-     X into a register to avoid aborting in emit_cmp_insn due to non-canonical
-     RTL.  */
+  /* If OP0 is still a constant, then both X and Y must be constants.
+     Force X into a register to create canonical RTL.  */
   if (CONSTANT_P (op0))
     op0 = force_reg (mode, op0);
 #endif
diff --git a/gcc/opts.c b/gcc/opts.c
index 70a9b22ac5b..10946ffe806 100644
--- a/gcc/opts.c
+++ b/gcc/opts.c
@@ -1027,10 +1027,8 @@ common_handle_option (size_t scode, const char *arg, int value)
     default:
       /* If the flag was handled in a standard way, assume the lack of
 	 processing here is intentional.  */
-      if (cl_options[scode].flag_var)
-	break;
-
-      abort ();
+      gcc_assert (cl_options[scode].flag_var);
+      break;
     }
 
   return 1;
diff --git a/gcc/output.h b/gcc/output.h
index 4d9eabb49f7..d7b81399c64 100644
--- a/gcc/output.h
+++ b/gcc/output.h
@@ -320,8 +320,8 @@ extern bool default_assemble_integer (rtx, unsigned int, int);
 
 /* Assemble the integer constant X into an object of SIZE bytes.  ALIGN is
    the alignment of the integer in bits.  Return 1 if we were able to output
-   the constant, otherwise 0.  If FORCE is nonzero, abort if we can't output
-   the constant.  */
+   the constant, otherwise 0.  If FORCE is nonzero the constant must
+   be outputable. */
 extern bool assemble_integer (rtx, unsigned, unsigned, int);
 
 /* An interface to assemble_integer for the common case in which a value is
@@ -425,7 +425,7 @@ extern rtx current_insn_predicate;
 extern rtx current_output_insn;
 
 /* Nonzero while outputting an `asm' with operands.
-   This means that inconsistencies are the user's fault, so don't abort.
+   This means that inconsistencies are the user's fault, so don't die.
    The precise value is the insn being output, to pass to error_for_asm.  */
 extern rtx this_is_asm_operands;
 
diff --git a/gcc/pretty-print.c b/gcc/pretty-print.c
index 3a10e7600c6..8e071020cb5 100644
--- a/gcc/pretty-print.c
+++ b/gcc/pretty-print.c
@@ -365,14 +365,13 @@ pp_base_format_text (pretty_printer *pp, text_info *text)
 	  break;
 
 	default:
-          if (!pp_format_decoder (pp) || !(*pp_format_decoder (pp)) (pp, text))
-	    {
-	      /* Hmmm.  The client failed to install a format translator
-                 but called us with an unrecognized format.  Or, maybe, the
-                 translated string just contains an invalid format, or
-                 has formats in the wrong order.  Sorry.  */
-	      abort ();
-	    }
+	  {
+	    bool ok;
+	    
+	    gcc_assert (pp_format_decoder (pp));
+	    ok = pp_format_decoder (pp) (pp, text);
+	    gcc_assert (ok);
+	  }
 	}
       if (quoted)
 	pp_string (pp, close_quote);
diff --git a/gcc/print-rtl.c b/gcc/print-rtl.c
index 56f4da69fe5..db214e9b89e 100644
--- a/gcc/print-rtl.c
+++ b/gcc/print-rtl.c
@@ -554,10 +554,7 @@ print_rtx (rtx in_rtx)
 	break;
 
       default:
-	fprintf (stderr,
-		 "switch format wrong in rtl.print_rtx(). format was: %c.\n",
-		 format_ptr[-1]);
-	abort ();
+	gcc_unreachable ();
       }
 
   switch (GET_CODE (in_rtx))
diff --git a/gcc/read-rtl.c b/gcc/read-rtl.c
index e2ea54a6ed2..b9e0cb5fc82 100644
--- a/gcc/read-rtl.c
+++ b/gcc/read-rtl.c
@@ -160,7 +160,7 @@ static struct obstack joined_conditions_obstack;
 /* The current line number for the file.  */
 int read_rtx_lineno = 1;
 
-/* The filename for aborting with file and line.  */
+/* The filename for error reporting.  */
 const char *read_rtx_filename = "<unknown>";
 
 static void
@@ -1487,11 +1487,7 @@ read_rtx_1 (FILE *infile)
 	break;
 
       default:
-	fprintf (stderr,
-		 "switch format wrong in rtl.read_rtx(). format was: %c.\n",
-		 format_ptr[i]);
-	fprintf (stderr, "\tfile position: %ld\n", ftell (infile));
-	abort ();
+	gcc_unreachable ();
       }
 
   c = read_skip_spaces (infile);
diff --git a/gcc/regmove.c b/gcc/regmove.c
index 182973fb38a..ed273e211ce 100644
--- a/gcc/regmove.c
+++ b/gcc/regmove.c
@@ -135,7 +135,7 @@ try_auto_increment (rtx insn, rtx inc_insn, rtx inc_insn_set, rtx reg,
 		  /* If there is a REG_DEAD note on this insn, we must
 		     change this not to REG_UNUSED meaning that the register
 		     is set, but the value is dead.  Failure to do so will
-		     result in a sched1 abort -- when it recomputes lifetime
+		     result in a sched1 dieing -- when it recomputes lifetime
 		     information, the number of REG_DEAD notes will have
 		     changed.  */
 		  rtx note = find_reg_note (insn, REG_DEAD, reg);
diff --git a/gcc/reload.c b/gcc/reload.c
index 29154753b85..394a43014b6 100644
--- a/gcc/reload.c
+++ b/gcc/reload.c
@@ -671,7 +671,7 @@ clear_secondary_mem (void)
 /* Find the largest class which has at least one register valid in
    mode INNER, and which for every such register, that register number
    plus N is also valid in OUTER (if in range) and is cheap to move
-   into REGNO.  Abort if no such class exists.  */
+   into REGNO.  Such a class must exist.  */
 
 static enum reg_class
 find_valid_class (enum machine_mode outer ATTRIBUTE_UNUSED,
@@ -4559,14 +4559,14 @@ find_reloads_toplev (rtx x, int opnum, enum reload_type type,
 
   if (code == SUBREG && REG_P (SUBREG_REG (x)))
     {
-      /* Check for SUBREG containing a REG that's equivalent to a constant.
-	 If the constant has a known value, truncate it right now.
-	 Similarly if we are extracting a single-word of a multi-word
-	 constant.  If the constant is symbolic, allow it to be substituted
-	 normally.  push_reload will strip the subreg later.  If the
-	 constant is VOIDmode, abort because we will lose the mode of
-	 the register (this should never happen because one of the cases
-	 above should handle it).  */
+      /* Check for SUBREG containing a REG that's equivalent to a
+	 constant.  If the constant has a known value, truncate it
+	 right now.  Similarly if we are extracting a single-word of a
+	 multi-word constant.  If the constant is symbolic, allow it
+	 to be substituted normally.  push_reload will strip the
+	 subreg later.  The constant must not be VOIDmode, because we
+	 will lose the mode of the register (this should never happen
+	 because one of the cases above should handle it).  */
 
       int regno = REGNO (SUBREG_REG (x));
       rtx tem;
@@ -6536,7 +6536,7 @@ find_equiv_reg (rtx goal, rtx insn, enum reg_class class, int other,
 		 different from what they were when calculating the need for
 		 spills.  If we notice an input-reload insn here, we will
 		 reject it below, but it might hide a usable equivalent.
-		 That makes bad code.  It may even abort: perhaps no reg was
+		 That makes bad code.  It may even fail: perhaps no reg was
 		 spilled for this insn because it was assumed we would find
 		 that equivalent.  */
 	      || INSN_UID (p) < reload_first_uid))
diff --git a/gcc/reload1.c b/gcc/reload1.c
index b2200a8d3b3..fbe491bd5aa 100644
--- a/gcc/reload1.c
+++ b/gcc/reload1.c
@@ -1090,8 +1090,8 @@ reload (rtx first, int global)
       CLEAR_REGNO_REG_SET (bb->global_live_at_start,
 			   HARD_FRAME_POINTER_REGNUM);
 
-  /* Come here (with failure set nonzero) if we can't get enough spill regs
-     and we decide not to abort about it.  */
+  /* Come here (with failure set nonzero) if we can't get enough spill
+     regs.  */
  failed:
 
   CLEAR_REG_SET (&spilled_pseudos);
@@ -4059,7 +4059,7 @@ forget_old_reloads_1 (rtx x, rtx ignored ATTRIBUTE_UNUSED,
   unsigned int nr;
 
   /* note_stores does give us subregs of hard regs,
-     subreg_regno_offset will abort if it is not a hard reg.  */
+     subreg_regno_offset requires a hard reg.  */
   while (GET_CODE (x) == SUBREG)
     {
       /* We ignore the subreg offset when calculating the regno,
@@ -4963,11 +4963,11 @@ free_for_value_p (int regno, enum machine_mode mode, int opnum,
 }
 
 /* Return nonzero if the rtx X is invariant over the current function.  */
-/* ??? Actually, the places where we use this expect exactly what
- * is tested here, and not everything that is function invariant.  In
- * particular, the frame pointer and arg pointer are special cased;
- * pic_offset_table_rtx is not, and this will cause aborts when we
- *             go to spill these things to memory.  */
+/* ??? Actually, the places where we use this expect exactly what is
+   tested here, and not everything that is function invariant.  In
+   particular, the frame pointer and arg pointer are special cased;
+   pic_offset_table_rtx is not, and we must not spill these things to
+   memory.  */
 
 static int
 function_invariant_p (rtx x)
@@ -6087,10 +6087,10 @@ merge_assigned_reloads (rtx insn)
 			|| rld[j].when_needed == RELOAD_FOR_INPADDR_ADDRESS)
 		       ? RELOAD_FOR_OTHER_ADDRESS : RELOAD_OTHER);
 
-		  /* Check to see if we accidentally converted two reloads
-		     that use the same reload register with different inputs
-		     to the same type.  If so, the resulting code won't work,
-		     so abort.  */
+		  /* Check to see if we accidentally converted two
+		     reloads that use the same reload register with
+		     different inputs to the same type.  If so, the
+		     resulting code won't work.  */
 		  if (rld[j].reg_rtx)
 		    for (k = 0; k < j; k++)
 		      gcc_assert (rld[k].in == 0 || rld[k].reg_rtx == 0
diff --git a/gcc/tree-flow-inline.h b/gcc/tree-flow-inline.h
index 0199206f02c..9fbf4282de1 100644
--- a/gcc/tree-flow-inline.h
+++ b/gcc/tree-flow-inline.h
@@ -254,11 +254,8 @@ link_imm_use_stmt (ssa_imm_use_t *linknode, tree def, tree stmt)
 static inline void
 relink_imm_use (ssa_imm_use_t *node, ssa_imm_use_t *old)
 {
-#ifdef ENABLE_CHECKING
   /* The node one had better be in the same list.  */
-  if (*(old->use) != *(node->use))
-    abort ();
-#endif
+  gcc_assert (*(old->use) == *(node->use));
   node->prev = old->prev;
   node->next = old->next;
   if (old->prev)
@@ -268,7 +265,6 @@ relink_imm_use (ssa_imm_use_t *node, ssa_imm_use_t *old)
       /* Remove the old node from the list.  */
       old->prev = NULL;
     }
-
 }
 
 /* Relink ssa_imm_use node LINKNODE into the chain for OLD, with use occuring 
diff --git a/gcc/tree-inline.c b/gcc/tree-inline.c
index 9f24b880e2f..c5634fdd8f8 100644
--- a/gcc/tree-inline.c
+++ b/gcc/tree-inline.c
@@ -1069,7 +1069,7 @@ inline_forbidden_p_1 (tree *nodep, int *walk_subtrees ATTRIBUTE_UNUSED,
 	 UNION_TYPE nodes, then it goes into infinite recursion on a
 	 structure containing a pointer to its own type.  If it doesn't,
 	 then the type node for S doesn't get adjusted properly when
-	 F is inlined, and we abort in find_function_data.
+	 F is inlined. 
 
 	 ??? This is likely no longer true, but it's too late in the 4.0
 	 cycle to try to find out.  This should be checked for 4.1.  */
@@ -1430,7 +1430,6 @@ estimate_num_insns_1 (tree *tp, int *walk_subtrees, void *data)
 	break;
       }
     default:
-      /* Abort here se we know we don't miss any nodes.  */
       gcc_unreachable ();
     }
   return NULL;
diff --git a/gcc/tree-optimize.c b/gcc/tree-optimize.c
index 80c89bf2787..b0b6b340bbc 100644
--- a/gcc/tree-optimize.c
+++ b/gcc/tree-optimize.c
@@ -493,7 +493,7 @@ execute_todo (struct tree_opt_pass *pass, unsigned int flags, bool use_required)
         print_rtl (dump_file, get_insns ());
 
       /* Flush the file.  If verification fails, we won't be able to
-	 close the file before aborting.  */
+	 close the file before dieing.  */
       fflush (dump_file);
     }
   if ((flags & TODO_dump_cgraph)
diff --git a/gcc/tree-outof-ssa.c b/gcc/tree-outof-ssa.c
index 657d1b54610..a06a612a9b2 100644
--- a/gcc/tree-outof-ssa.c
+++ b/gcc/tree-outof-ssa.c
@@ -493,8 +493,7 @@ eliminate_phi (edge e, elim_graph g)
 
   gcc_assert (VARRAY_ACTIVE_SIZE (g->const_copies) == 0);
 
-  /* Abnormal edges already have everything coalesced, or the coalescer
-     would have aborted.  */
+  /* Abnormal edges already have everything coalesced.  */
   if (e->flags & EDGE_ABNORMAL)
     return;
 
diff --git a/gcc/tree-ssa-alias.c b/gcc/tree-ssa-alias.c
index d78ab53dbc4..09dbbbbfec4 100644
--- a/gcc/tree-ssa-alias.c
+++ b/gcc/tree-ssa-alias.c
@@ -1958,7 +1958,7 @@ add_pointed_to_expr (struct alias_info *ai, tree ptr, tree expr)
 	}
 
       /* Neither operand is a pointer?  VAR can be pointing anywhere.
-	 FIXME: Shouldn't we abort here?  If we get here, we found
+	 FIXME: Shouldn't we asserting here?  If we get here, we found
 	 PTR = INT_CST + INT_CST, which should not be a valid pointer
 	 expression.  */
       if (!(POINTER_TYPE_P (TREE_TYPE (op0))
diff --git a/gcc/tree-ssa-ccp.c b/gcc/tree-ssa-ccp.c
index 9003a9d974a..3ae0b1aca8b 100644
--- a/gcc/tree-ssa-ccp.c
+++ b/gcc/tree-ssa-ccp.c
@@ -1657,7 +1657,7 @@ maybe_fold_stmt_indirect (tree expr, tree base, tree offset)
 	  && TREE_CODE (TREE_OPERAND (t, 0)) == STRING_CST)
 	{
 	  /* FIXME: Except that this causes problems elsewhere with dead
-	     code not being deleted, and we abort in the rtl expanders 
+	     code not being deleted, and we die in the rtl expanders 
 	     because we failed to remove some ssa_name.  In the meantime,
 	     just return zero.  */
 	  /* FIXME2: This condition should be signaled by
diff --git a/gcc/tree-ssa-operands.c b/gcc/tree-ssa-operands.c
index b2f8b32fea1..a010b3040ef 100644
--- a/gcc/tree-ssa-operands.c
+++ b/gcc/tree-ssa-operands.c
@@ -1084,7 +1084,7 @@ parse_ssa_operands (tree stmt)
 
     default:
       /* Notice that if get_expr_operands tries to use &STMT as the operand
-	 pointer (which may only happen for USE operands), we will abort in
+	 pointer (which may only happen for USE operands), we will fail in
 	 append_use.  This default will handle statements like empty
 	 statements, or CALL_EXPRs that may appear on the RHS of a statement
 	 or as statements themselves.  */
@@ -1680,7 +1680,7 @@ get_indirect_ref_operands (tree stmt, tree expr, int flags)
 
   /* Everything else *should* have been folded elsewhere, but users
      are smarter than we in finding ways to write invalid code.  We
-     cannot just abort here.  If we were absolutely certain that we
+     cannot just assert here.  If we were absolutely certain that we
      do handle all valid cases, then we could just do nothing here.
      That seems optimistic, so attempt to do something logical... */
   else if ((TREE_CODE (ptr) == PLUS_EXPR || TREE_CODE (ptr) == MINUS_EXPR)
@@ -2219,29 +2219,6 @@ create_ssa_artficial_load_stmt (stmt_operands_p old_ops, tree new_stmt)
   ann->operands.vuse_ops = finalize_ssa_vuses (&(tmp.vuse_ops), NULL);
 }
 
-
-
-/* Issue immediate use error for VAR to debug file F.  */
-static void 
-verify_abort (FILE *f, ssa_imm_use_t *var)
-{
-  tree stmt;
-  stmt = var->stmt;
-  if (stmt)
-    {
-      if (stmt_modified_p(stmt))
-	{
-	  fprintf (f, " STMT MODIFIED. - <%p> ", (void *)stmt);
-	  print_generic_stmt (f, stmt, TDF_SLIM);
-	}
-    }
-  fprintf (f, " IMM ERROR : (use_p : tree - %p:%p)", (void *)var, 
-	   (void *)var->use);
-  print_generic_expr (f, USE_FROM_PTR (var), TDF_SLIM);
-  fprintf(f, "\n");
-}
-
-
 /* Scan the immediate_use list for VAR making sure its linked properly.
    return RTUE iof there is a problem.  */
 
@@ -2268,31 +2245,18 @@ verify_imm_links (FILE *f, tree var)
   for (ptr = list->next; ptr != list; )
     {
       if (prev != ptr->prev)
-        {
-	  verify_abort (f, ptr);
-	  return true;
-	}
-
+	goto error;
+      
       if (ptr->use == NULL)
-        {
-	  verify_abort (f, ptr); 	/* 2 roots, or SAFE guard node.  */
-	  return true;
-	}
-      else
-	if (*(ptr->use) != var)
-	  {
-	    verify_abort (f, ptr);
-	    return true;
-	  }
+	goto error; /* 2 roots, or SAFE guard node.  */
+      else if (*(ptr->use) != var)
+	goto error;
 
       prev = ptr;
       ptr = ptr->next;
       /* Avoid infinite loops.  */
       if (count++ > 30000)
-	{
-	  verify_abort (f, ptr);
-	  return true;
-	}
+	goto error;
     }
 
   /* Verify list in the other direction.  */
@@ -2300,26 +2264,29 @@ verify_imm_links (FILE *f, tree var)
   for (ptr = list->prev; ptr != list; )
     {
       if (prev != ptr->next)
-	{
-	  verify_abort (f, ptr);
-	  return true;
-	}
+	goto error;
       prev = ptr;
       ptr = ptr->prev;
       if (count-- < 0)
-	{
-	  verify_abort (f, ptr);
-	  return true;
-	}
+	goto error;
     }
 
   if (count != 0)
-    {
-      verify_abort (f, ptr);
-      return true;
-    }
+    goto error;
 
   return false;
+
+ error:
+  if (ptr->stmt && stmt_modified_p (ptr->stmt))
+    {
+      fprintf (f, " STMT MODIFIED. - <%p> ", (void *)ptr->stmt);
+      print_generic_stmt (f, ptr->stmt, TDF_SLIM);
+    }
+  fprintf (f, " IMM ERROR : (use_p : tree - %p:%p)", (void *)ptr, 
+	   (void *)ptr->use);
+  print_generic_expr (f, USE_FROM_PTR (ptr), TDF_SLIM);
+  fprintf(f, "\n");
+  return true;
 }
 
 
diff --git a/gcc/tree-ssa-pre.c b/gcc/tree-ssa-pre.c
index 0e705c301df..608e9303de2 100644
--- a/gcc/tree-ssa-pre.c
+++ b/gcc/tree-ssa-pre.c
@@ -1287,9 +1287,8 @@ find_or_generate_expression (basic_block block, tree expr, tree stmts)
 {
   tree genop = bitmap_find_leader (AVAIL_OUT (block), expr);
 
-  /* If it's still NULL, see if it is a complex expression, and if
-     so, generate it recursively, otherwise, abort, because it's
-     not really .  */
+  /* If it's still NULL, it must be a complex expression, so generate
+     it recursively.  */
   if (genop == NULL)
     {
       genop = VALUE_HANDLE_EXPR_SET (expr)->head->expr;
@@ -1309,7 +1308,7 @@ find_or_generate_expression (basic_block block, tree expr, tree stmts)
    EXPR is the expression to insert (in value form)
    STMTS is a statement list to append the necessary insertions into.
 
-   This function will abort if we hit some value that shouldn't be
+   This function will die if we hit some value that shouldn't be
    ANTIC but is (IE there is no leader for it, or its components).
    This function may also generate expressions that are themselves
    partially or fully redundant.  Those that are will be either made
diff --git a/gcc/tree-ssanames.c b/gcc/tree-ssanames.c
index 79e1a764e73..b0c430b8f96 100644
--- a/gcc/tree-ssanames.c
+++ b/gcc/tree-ssanames.c
@@ -1,23 +1,23 @@
 /* Generic routines for manipulating SSA_NAME expressions
    Copyright (C) 2003, 2004, 2005 Free Software Foundation, Inc.
-                                                                                
+                                                                               
 This file is part of GCC.
-                                                                                
+                                                                               
 GCC is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2, or (at your option)
 any later version.
-                                                                                
+                                                                               
 GCC is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
-                                                                                
+                                                                               
 You should have received a copy of the GNU General Public License
 along with GCC; see the file COPYING.  If not, write to
 the Free Software Foundation, 59 Temple Place - Suite 330,
 Boston, MA 02111-1307, USA.  */
-                                                                                
+
 #include "config.h"
 #include "system.h"
 #include "coretypes.h"
@@ -260,13 +260,7 @@ release_ssa_name (tree var)
       verify_imm_links (stderr, var);
 #endif
       while (imm->next != imm)
-        {
-	  delink_imm_use (imm->next);
-	}
-#ifdef ENABLE_CHECKING
-      if (imm->next != imm)
-        abort();
-#endif
+	delink_imm_use (imm->next);
 
       VARRAY_TREE (ssa_names, SSA_NAME_VERSION (var)) = NULL;
       memset (var, 0, tree_size (var));
diff --git a/gcc/tree.c b/gcc/tree.c
index a4969a0ae51..c8b6ea6a196 100644
--- a/gcc/tree.c
+++ b/gcc/tree.c
@@ -1496,9 +1496,9 @@ bit_position (tree field)
 		       DECL_FIELD_BIT_OFFSET (field));
 }
 
-/* Likewise, but return as an integer.  Abort if it cannot be represented
-   in that way (since it could be a signed value, we don't have the option
-   of returning -1 like int_size_in_byte can.  */
+/* Likewise, but return as an integer.  It must be representable in
+   that way (since it could be a signed value, we don't have the
+   option of returning -1 like int_size_in_byte can.  */
 
 HOST_WIDE_INT
 int_bit_position (tree field)
@@ -1516,9 +1516,9 @@ byte_position (tree field)
 			DECL_FIELD_BIT_OFFSET (field));
 }
 
-/* Likewise, but return as an integer.  Abort if it cannot be represented
-   in that way (since it could be a signed value, we don't have the option
-   of returning -1 like int_size_in_byte can.  */
+/* Likewise, but return as an integer.  It must be representable in
+   that way (since it could be a signed value, we don't have the
+   option of returning -1 like int_size_in_byte can.  */
 
 HOST_WIDE_INT
 int_byte_position (tree field)
@@ -3838,7 +3838,7 @@ host_integerp (tree t, int pos)
 
 /* Return the HOST_WIDE_INT least significant bits of T if it is an
    INTEGER_CST and there is no overflow.  POS is nonzero if the result must
-   be positive.  Abort if we cannot satisfy the above conditions.  */
+   be positive.  We must be able to satisfy the above conditions.  */
 
 HOST_WIDE_INT
 tree_low_cst (tree t, int pos)
@@ -6411,7 +6411,7 @@ walk_type_fields (tree type, walk_tree_fn func, void *data,
 
 /* Apply FUNC to all the sub-trees of TP in a pre-order traversal.  FUNC is
    called with the DATA and the address of each sub-tree.  If FUNC returns a
-   non-NULL value, the traversal is aborted, and the value returned by FUNC
+   non-NULL value, the traversal is stopped, and the value returned by FUNC
    is returned.  If PSET is non-NULL it is used to record the nodes visited,
    and to avoid visiting a node more than once.  */
 
diff --git a/gcc/tree.h b/gcc/tree.h
index 33d4d29f1ec..50ea50426e8 100644
--- a/gcc/tree.h
+++ b/gcc/tree.h
@@ -443,7 +443,7 @@ struct tree_common GTY(())
 #define TREE_SET_CODE(NODE, VALUE) ((NODE)->common.code = (VALUE))
 
 /* When checking is enabled, errors will be generated if a tree node
-   is accessed incorrectly. The macros abort with a fatal error.  */
+   is accessed incorrectly. The macros die with a fatal error.  */
 #if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
 
 #define TREE_CHECK(T, CODE) __extension__				\
diff --git a/gcc/vec.h b/gcc/vec.h
index 43aeb817d64..2c05fa13859 100644
--- a/gcc/vec.h
+++ b/gcc/vec.h
@@ -61,7 +61,7 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA
    Each operation that increases the number of active elements is
    available in 'quick' and 'safe' variants.  The former presumes that
    there is sufficient allocated space for the operation to succeed
-   (it aborts if there is not).  The latter will reallocate the
+   (it dies if there is not).  The latter will reallocate the
    vector, if needed.  Reallocation causes an exponential increase in
    vector size.  If you know you will be adding N elements, it would
    be more efficient to use the reserve operation before adding the
@@ -150,7 +150,7 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA
    T VEC_T_last(VEC(T) *v); // Pointer
    T *VEC_T_last(VEC(T) *v); // Object
 
-   Return the final element.  If V is empty,  abort.  */
+   Return the final element.  V must not be empty.  */
 
 #define VEC_last(T,V)	(VEC_OP(T,base,last)(VEC_BASE(V) VEC_CHECK_INFO))
 
@@ -158,8 +158,7 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA
    T VEC_T_index(VEC(T) *v, unsigned ix); // Pointer
    T *VEC_T_index(VEC(T) *v, unsigned ix); // Object
 
-   Return the IX'th element.  If IX is outside the domain of V,
-   abort.  */
+   Return the IX'th element.  If IX must be in the domain of V.  */
 
 #define VEC_index(T,V,I) (VEC_OP(T,base,index)(VEC_BASE(V),I VEC_CHECK_INFO))
 
@@ -234,8 +233,8 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA
    
    Push a new element onto the end, returns a pointer to the slot
    filled in. For object vectors, the new value can be NULL, in which
-   case NO initialization is performed.  Aborts if there is
-   insufficient space in the vector.  */
+   case NO initialization is performed.  There must
+   be sufficient space in the vector.  */
 
 #define VEC_quick_push(T,V,O)	\
 	(VEC_OP(T,base,quick_push)(VEC_BASE(V),O VEC_CHECK_INFO))
@@ -299,7 +298,7 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA
    Insert an element, VAL, at the IXth position of V. Return a pointer
    to the slot created.  For vectors of object, the new value can be
    NULL, in which case no initialization of the inserted slot takes
-   place. Aborts if there is insufficient space.  */
+   place. There must be sufficient space.  */
 
 #define VEC_quick_insert(T,V,I,O)	\
 	(VEC_OP(T,base,quick_insert)(VEC_BASE(V),I,O VEC_CHECK_INFO))