c-aux-info.c (gen_type): Use gcc_assert or gcc_unreachable.

	* c-aux-info.c (gen_type): Use gcc_assert or gcc_unreachable.
	* c-common.c (c_type_hash, c_common_nodes_and_builtins,
	c_expand_expr, boolean_increment, nonnull_check_p,
	check_function_arguments_recurse, fold_offsetof_1): Likewise.
	* c-cppbuiltin.c (define__GNUC__, builtin_define_stdint_macros,
	builtin_define_type_max): Likewise.
	* c-decl.c (bind, pop_scope, merge_decls, pushdecl_top_level,
	implicit_decl_warning, builtin_function, build_compound_literal,
	complete_array_type, grokdeclarator, get_parm_info,
	start_function, store_parm_decls_oldstyle,
	c_write_global_declarations): Likewise.
	* c-format.c (get_constant, decode_format_attr,
	maybe_read_dollar_number, get_flag_spec, check_format_arg,
	check_format_types, format_type_warning,
	find_char_info_specifier_index, init_dynamic_asm_fprintf_info,
	init_dynamic_diag_info, handle_format_attribute): Likewise.
	* c-gimplify.c (push_context, pop_context, finish_bc_block):
	* c-lex.c (c_lex_with_flags, lex_string): Likewise.
	* c-objc-common.c (c_tree_printer): Likewise.
	* c-pch.c (pch_init): Likewise.
	* c-pragma.c (maybe_apply_pragma_weak): Likewise.
	* c-pretty-print.c (pp_c_tree_decl_identifier): Likewise.
	* c-typeck.c (c_incomplete_type_error, composite_type,
	common_pointer_type, common_type, same_translation_unit_p,
	tagged_types_tu_compatible_p, finish_init, pop_init_level,
	set_designator, set_nonincremental_init_from_string,
	process_init_element, c_finish_if_stmt): Likewise.
	* caller-save.c (init_caller_save, save_call_clobbered_regs,
	insert_restore, insert_save, insert_one_insn): Likewise.
	* calls.c (emit_call_1, compute_argument_block_size,
	precompute_arguments, expand_call, emit_library_call_value_1,
	store_one_arg): Likewise.

From-SVN: r87140

gcc/ChangeLog

 2004-09-07  Nathan Sidwell  <nathan@codesourcery.com>
 
+	* c-aux-info.c (gen_type): Use gcc_assert or gcc_unreachable.
+	* c-common.c (c_type_hash, c_common_nodes_and_builtins,
+	c_expand_expr, boolean_increment, nonnull_check_p,
+	check_function_arguments_recurse, fold_offsetof_1): Likewise.
+	* c-cppbuiltin.c (define__GNUC__, builtin_define_stdint_macros,
+	builtin_define_type_max): Likewise.
+	* c-decl.c (bind, pop_scope, merge_decls, pushdecl_top_level,
+	implicit_decl_warning, builtin_function, build_compound_literal,
+	complete_array_type, grokdeclarator, get_parm_info,
+	start_function, store_parm_decls_oldstyle,
+	c_write_global_declarations): Likewise.
+	* c-format.c (get_constant, decode_format_attr,
+	maybe_read_dollar_number, get_flag_spec, check_format_arg,
+	check_format_types, format_type_warning,
+	find_char_info_specifier_index, init_dynamic_asm_fprintf_info,
+	init_dynamic_diag_info, handle_format_attribute): Likewise.
+	* c-gimplify.c (push_context, pop_context, finish_bc_block): 
+	* c-lex.c (c_lex_with_flags, lex_string): Likewise.
+	* c-objc-common.c (c_tree_printer): Likewise.
+	* c-pch.c (pch_init): Likewise.
+	* c-pragma.c (maybe_apply_pragma_weak): Likewise.
+	* c-pretty-print.c (pp_c_tree_decl_identifier): Likewise.
+	* c-typeck.c (c_incomplete_type_error, composite_type,
+	common_pointer_type, common_type, same_translation_unit_p,
+	tagged_types_tu_compatible_p, finish_init, pop_init_level,
+	set_designator, set_nonincremental_init_from_string,
+	process_init_element, c_finish_if_stmt): Likewise.
+	* caller-save.c (init_caller_save, save_call_clobbered_regs,
+	insert_restore, insert_save, insert_one_insn): Likewise.
+	* calls.c (emit_call_1, compute_argument_block_size,
+	precompute_arguments, expand_call, emit_library_call_value_1,
+	store_one_arg): Likewise.
+
+2004-09-07  Nathan Sidwell  <nathan@codesourcery.com>
+
 	* configure.ac (enable-checking): Add release option. Reorganize
 	to avoid repetition.
 	* configure: Rebuilt.

gcc/c-aux-info.c

@@ -447,7 +447,7 @@ gen_type (const char *ret_val, tree t, formals_style style)
 	  break;
 
         default:
-          abort ();
+          gcc_unreachable ();
         }
     }
   if (TYPE_READONLY (t))

gcc/c-common.c

@@ -2578,7 +2578,7 @@ c_type_hash (const void *p)
       t2 = TYPE_FIELDS (t);
       break;
     default:
-      abort ();
+      gcc_unreachable ();
     }
   for (; t2; t2 = TREE_CHAIN (t2))
     i++;
@@ -3188,8 +3188,8 @@ c_common_nodes_and_builtins (void)
     {									\
       tree decl;							\
 									\
-      if (strncmp (NAME, "__builtin_", strlen ("__builtin_")) != 0)	\
-	abort ();							\
+      gcc_assert (!strncmp (NAME, "__builtin_",				\
+			    strlen ("__builtin_")));			\
 									\
       if (!BOTH_P)							\
 	decl = lang_hooks.builtin_function (NAME, builtin_types[TYPE],	\
@@ -3830,7 +3830,7 @@ c_expand_expr (tree exp, rtx target, enum machine_mode tmode,
       }
 
     default:
-      abort ();
+      gcc_unreachable ();
     }
 }
 
@@ -3878,7 +3878,7 @@ boolean_increment (enum tree_code code, tree arg)
       val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
       break;
     default:
-      abort ();
+      gcc_unreachable ();
     }
   TREE_SIDE_EFFECTS (val) = 1;
   return val;
@@ -5111,8 +5111,9 @@ nonnull_check_p (tree args, unsigned HOST_WIDE_INT param_num)
 
   for (; args; args = TREE_CHAIN (args))
     {
-      if (! get_nonnull_operand (TREE_VALUE (args), &arg_num))
-	abort ();
+      bool found = get_nonnull_operand (TREE_VALUE (args), &arg_num);
+
+      gcc_assert (found);
 
       if (arg_num == param_num)
 	return true;
@@ -5356,9 +5357,8 @@ check_function_arguments_recurse (void (*callback)
 		   || TREE_CODE (format_num_expr) == NON_LVALUE_EXPR)
 	      format_num_expr = TREE_OPERAND (format_num_expr, 0);
 
-	    if (TREE_CODE (format_num_expr) != INTEGER_CST
-		|| TREE_INT_CST_HIGH (format_num_expr) != 0)
-	      abort ();
+	    gcc_assert (TREE_CODE (format_num_expr) == INTEGER_CST
+			&& !TREE_INT_CST_HIGH (format_num_expr));
 
 	    format_num = TREE_INT_CST_LOW (format_num_expr);
 
@@ -5619,7 +5619,7 @@ fold_offsetof_1 (tree expr)
       break;
 
     default:
-      abort ();
+      gcc_unreachable ();
     }
 
   return size_binop (code, base, off);

gcc/c-cppbuiltin.c

@@ -261,8 +261,7 @@ define__GNUC__ (void)
 
   while (*v && ! ISDIGIT (*v))
     v++;
-  if (!*v || (v > version_string && v[-1] != '-'))
-    abort ();
+  gcc_assert (*v && (v <= version_string || v[-1] == '-'));
 
   q = v;
   while (ISDIGIT (*v))
@@ -271,8 +270,8 @@ define__GNUC__ (void)
   if (c_dialect_cxx ())
     builtin_define_with_value_n ("__GNUG__", q, v - q);
 
-  if (*v != '.' || !ISDIGIT (v[1]))
-    abort ();
+  gcc_assert (*v == '.' || ISDIGIT (v[1]));
+  
   q = ++v;
   while (ISDIGIT (*v))
     v++;
@@ -280,8 +279,7 @@ define__GNUC__ (void)
 
   if (*v == '.')
     {
-      if (!ISDIGIT (v[1]))
-	abort ();
+      gcc_assert (ISDIGIT (v[1]));
       q = ++v;
       while (ISDIGIT (*v))
 	v++;
@@ -290,8 +288,7 @@ define__GNUC__ (void)
   else
     builtin_define_with_value_n ("__GNUC_PATCHLEVEL__", "0", 1);
 
-  if (*v && *v != ' ' && *v != '-')
-    abort ();
+  gcc_assert (!*v || *v == ' ' || *v == '-');
 }
 
 /* Define macros used by <stdint.h>.  Currently only defines limits
@@ -307,7 +304,7 @@ builtin_define_stdint_macros (void)
   else if (intmax_type_node == integer_type_node)
     intmax_long = 0;
   else
-    abort ();
+    gcc_unreachable ();
   builtin_define_type_max ("__INTMAX_MAX__", intmax_type_node, intmax_long);
 }
 
@@ -617,7 +614,7 @@ builtin_define_type_max (const char *macro, tree type, int is_long)
     case 32:	idx = 4; break;
     case 64:	idx = 6; break;
     case 128:	idx = 8; break;
-    default:    abort ();
+    default:    gcc_unreachable ();
     }
 
   value = values[idx + TYPE_UNSIGNED (type)];

gcc/c-format.c

@@ -151,7 +151,7 @@ check_format_string (tree argument, unsigned HOST_WIDE_INT format_num,
    and store its value. If validated_p is true, abort on errors.
    Returns true on success, false otherwise.  */
 static bool
-get_constant(tree expr, unsigned HOST_WIDE_INT *value, int validated_p)
+get_constant (tree expr, unsigned HOST_WIDE_INT *value, int validated_p)
 {
   while (TREE_CODE (expr) == NOP_EXPR
 	 || TREE_CODE (expr) == CONVERT_EXPR
@@ -160,8 +160,7 @@ get_constant(tree expr, unsigned HOST_WIDE_INT *value, int validated_p)
 
   if (TREE_CODE (expr) != INTEGER_CST || TREE_INT_CST_HIGH (expr) != 0)
     {
-      if (validated_p)
-	abort ();
+      gcc_assert (!validated_p);
       return false;
     }
 
@@ -187,8 +186,7 @@ decode_format_attr (tree args, function_format_info *info, int validated_p)
 
   if (TREE_CODE (format_type_id) != IDENTIFIER_NODE)
     {
-      if (validated_p)
-	abort ();
+      gcc_assert (!validated_p);
       error ("unrecognized format specifier");
       return false;
     }
@@ -200,8 +198,7 @@ decode_format_attr (tree args, function_format_info *info, int validated_p)
 
       if (info->format_type == format_type_error)
 	{
-	  if (validated_p)
-	    abort ();
+	  gcc_assert (!validated_p);
 	  warning ("%qs is an unrecognized format function type", p);
 	  return false;
 	}
@@ -221,8 +218,7 @@ decode_format_attr (tree args, function_format_info *info, int validated_p)
 
   if (info->first_arg_num != 0 && info->first_arg_num <= info->format_num)
     {
-      if (validated_p)
-	abort ();
+      gcc_assert (!validated_p);
       error ("format string arg follows the args to be formatted");
       return false;
     }
@@ -1004,11 +1000,8 @@ maybe_read_dollar_number (const char **format,
       for (i = 1; i < argnum && *param_ptr != 0; i++)
 	*param_ptr = TREE_CHAIN (*param_ptr);
 
-      if (*param_ptr == 0)
-	{
-	  /* This case shouldn't be caught here.  */
-	  abort ();
-	}
+      /* This case shouldn't be caught here.  */
+      gcc_assert (*param_ptr);
     }
   else
     *param_ptr = 0;
@@ -1096,10 +1089,8 @@ get_flag_spec (const format_flag_spec *spec, int flag, const char *predicates)
       else if (spec[i].predicate == 0)
 	return &spec[i];
     }
-  if (predicates == NULL)
-    abort ();
-  else
-    return NULL;
+  gcc_assert (predicates);
+  return NULL;
 }
 
 
@@ -1299,8 +1290,8 @@ check_format_arg (void *ctx, tree format_tree,
   if (array_size != 0)
     {
       /* Variable length arrays can't be initialized.  */
-      if (TREE_CODE (array_size) != INTEGER_CST)
-	abort ();
+      gcc_assert (TREE_CODE (array_size) == INTEGER_CST);
+      
       if (host_integerp (array_size, 0))
 	{
 	  HOST_WIDE_INT array_size_value = TREE_INT_CST_LOW (array_size);
@@ -2053,10 +2044,8 @@ check_format_types (format_wanted_type *types, const char *format_start,
       arg_num = types->arg_num;
 
       /* The following should not occur here.  */
-      if (wanted_type == 0)
-	abort ();
-      if (wanted_type == void_type_node && types->pointer_count == 0)
-	abort ();
+      gcc_assert (wanted_type);
+      gcc_assert (wanted_type != void_type_node || types->pointer_count);
 
       if (types->pointer_count == 0)
 	wanted_type = lang_hooks.types.type_promotes_to (wanted_type);
@@ -2253,17 +2242,14 @@ format_type_warning (const char *descr, const char *format_start,
 static unsigned int
 find_char_info_specifier_index (const format_char_info *fci, int c)
 {
-  unsigned int i = 0;
-  
-  while (fci->format_chars)
-    {
-      if (strchr (fci->format_chars, c))
-	return i;
-      i++; fci++;
-    }
+  unsigned i;
+
+  for (i = 0; fci->format_chars; i++, fci++)
+    if (strchr (fci->format_chars, c))
+      return i;
   
   /* We shouldn't be looking for a non-existent specifier.  */
-  abort ();
+  gcc_unreachable ();
 }
 
 /* Given a format_length_info array FLI, and a character C, this
@@ -2273,17 +2259,14 @@ find_char_info_specifier_index (const format_char_info *fci, int c)
 static unsigned int
 find_length_info_modifier_index (const format_length_info *fli, int c)
 {
-  unsigned int i = 0;
-  
-  while (fli->name)
-    {
-      if (strchr (fli->name, c))
-	return i;
-      i++; fli++;
-    }
+  unsigned i;
+
+  for (i = 0; fli->name; i++, fli++)
+    if (strchr (fli->name, c))
+      return i;
   
   /* We shouldn't be looking for a non-existent modifier.  */
-  abort ();
+  gcc_unreachable ();
 }
 
 /* Determine the type of HOST_WIDE_INT in the code being compiled for
@@ -2293,7 +2276,7 @@ static void
 init_dynamic_asm_fprintf_info (void)
 {
   static tree hwi;
-      
+
   if (!hwi)
     {
       format_length_info *new_asm_fprintf_length_specs;
@@ -2303,9 +2286,10 @@ init_dynamic_asm_fprintf_info (void)
 	 length modifier to work, one must have issued: "typedef
 	 HOST_WIDE_INT __gcc_host_wide_int__;" in one's source code
 	 prior to using that modifier.  */
-      if (!(hwi = maybe_get_identifier ("__gcc_host_wide_int__"))
-	  || !(hwi = DECL_ORIGINAL_TYPE (identifier_global_value (hwi))))
-	abort ();
+      hwi = maybe_get_identifier ("__gcc_host_wide_int__");
+      gcc_assert (hwi);
+      hwi = DECL_ORIGINAL_TYPE (identifier_global_value (hwi));
+      gcc_assert (hwi);
 
       /* Create a new (writable) copy of asm_fprintf_length_specs.  */
       new_asm_fprintf_length_specs = (format_length_info *)
@@ -2320,7 +2304,7 @@ init_dynamic_asm_fprintf_info (void)
       else if (hwi == long_long_integer_type_node)
 	new_asm_fprintf_length_specs[i].index = FMT_LEN_ll;
       else
-	abort ();
+	gcc_unreachable ();
 
       /* Assign the new data for use.  */
       dynamic_format_types[asm_fprintf_format_type].length_char_specs =
@@ -2383,7 +2367,7 @@ init_dynamic_diag_info (void)
 	  else if (hwi == long_long_integer_type_node)
 	    diag_ls[i].index = FMT_LEN_ll;
 	  else
-	    abort ();
+	    gcc_unreachable ();
 	}
 
       /* Handle the __gcc_diag__ format specifics.  */
@@ -2551,7 +2535,7 @@ handle_format_attribute (tree *node, tree ARG_UNUSED (name), tree args,
 	       || info.format_type == gcc_cxxdiag_format_type)
 	init_dynamic_diag_info();
       else
-	abort();
+	gcc_unreachable();
     }
 
   return NULL_TREE;

gcc/c-gimplify.c

@@ -84,8 +84,7 @@ static struct c_gimplify_ctx
 static void
 push_context (void)
 {
-  if (ctxp)
-    abort ();
+  gcc_assert (!ctxp);
   ctxp = (struct c_gimplify_ctx *) xcalloc (1, sizeof (struct c_gimplify_ctx));
   ctxp->bc_id[bc_continue] = get_identifier ("continue");
   ctxp->bc_id[bc_break] = get_identifier ("break");
@@ -94,8 +93,7 @@ push_context (void)
 static void
 pop_context (void)
 {
-  if (!ctxp || ctxp->current_bc_label)
-    abort ();
+  gcc_assert (ctxp && !ctxp->current_bc_label);
   free (ctxp);
   ctxp = NULL;
 }
@@ -275,8 +273,7 @@ begin_bc_block (enum bc_t bc)
 static tree
 finish_bc_block (tree label, tree body)
 {
-  if (label != ctxp->current_bc_label)
-    abort ();
+  gcc_assert (label == ctxp->current_bc_label);
 
   if (TREE_USED (label))
     {

gcc/c-lex.c

@@ -373,7 +373,7 @@ c_lex_with_flags (tree *value, unsigned char *cpp_flags)
 	    break;
 
 	  default:
-	    abort ();
+	    gcc_unreachable ();
 	  }
       }
       break;
@@ -435,7 +435,7 @@ c_lex_with_flags (tree *value, unsigned char *cpp_flags)
     case CPP_HEADER_NAME:
     case CPP_COMMENT:
     case CPP_MACRO_ARG:
-      abort ();
+      gcc_unreachable ();
 
     default:
       *value = NULL_TREE;
@@ -737,12 +737,11 @@ lex_string (const cpp_token *tok, tree *valp, bool objc_string)
 
       if (c_lex_string_translate == -1)
 	{
-	  if (!cpp_interpret_string_notranslate (parse_in, strs, count,
-						 &istr, wide))
-	    /* Assume that, if we managed to translate the string
-	       above, then the untranslated parsing will always
-	       succeed.  */
-	    abort ();
+	  int xlated = cpp_interpret_string_notranslate (parse_in, strs, count,
+							 &istr, wide);
+	  /* Assume that, if we managed to translate the string above,
+	     then the untranslated parsing will always succeed.  */
+	  gcc_assert (xlated);
 	  
 	  if (TREE_STRING_LENGTH (value) != (int)istr.len
 	      || 0 != strncmp (TREE_STRING_POINTER (value), (char *)istr.text,

gcc/c-objc-common.c

@@ -213,10 +213,9 @@ c_tree_printer (pretty_printer *pp, text_info *text)
       break;
 
     case 'T':
-      if (TYPE_P (t))
-	name = TYPE_NAME (t);
-      else
-	abort ();
+      gcc_assert (TYPE_P (t));
+      name = TYPE_NAME (t);
+      
       if (name && TREE_CODE (name) == TYPE_DECL)
 	{
 	  if (DECL_NAME (name))

gcc/c-pch.c

@@ -129,10 +129,10 @@ pch_init (void)
   if (f == NULL)
     fatal_error ("can't create precompiled header %s: %m", pch_file);
   pch_outfile = f;
-  
-  if (strlen (host_machine) > 255 || strlen (target_machine) > 255
-      || strlen (version_string) > 255)
-    abort ();
+
+  gcc_assert (strlen (host_machine) < 256
+	      && strlen (target_machine) < 256
+	      && strlen (version_string) < 256);
   
   v.host_machine_length = strlen (host_machine);
   v.target_machine_length = strlen (target_machine);
@@ -143,8 +143,7 @@ pch_init (void)
     for (i = 0; i < MATCH_SIZE; i++)
       {
 	v.match[i] = *pch_matching[i].flag_var;
-	if (v.match[i] != *pch_matching[i].flag_var)
-	  abort ();
+	gcc_assert (v.match[i] == *pch_matching[i].flag_var);
       }
   }
   v.pch_init = &pch_init;

gcc/c-pragma.c

@@ -279,7 +279,7 @@ maybe_apply_pragma_weak (tree decl)
     return;
   /* If it's not a function or a variable, it can't be weak.
      FIXME: what kinds of things are visible outside this file but
-     aren't functions or variables?   Should this be an abort() instead?  */
+     aren't functions or variables?   Should this be an assert instead?  */
   if (TREE_CODE (decl) != FUNCTION_DECL && TREE_CODE (decl) != VAR_DECL)
     return;
 

gcc/c-pretty-print.c

@@ -2139,8 +2139,7 @@ pp_c_tree_decl_identifier (c_pretty_printer *pp, tree t)
 {
   const char *name;
 
-  if (!DECL_P (t))
-    abort ();
+  gcc_assert (DECL_P (t));
 
   if (DECL_NAME (t))
     name = IDENTIFIER_POINTER (DECL_NAME (t));

gcc/c-typeck.c

@@ -157,7 +157,7 @@ c_incomplete_type_error (tree value, tree type)
 	  return;
 
 	default:
-	  abort ();
+	  gcc_unreachable ();
 	}
 
       if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
@@ -240,8 +240,7 @@ composite_type (tree t1, tree t2)
   if (code2 == ENUMERAL_TYPE && code1 == INTEGER_TYPE)
     return t2;
 
-  if (code1 != code2)
-    abort ();
+  gcc_assert (code1 == code2);
 
   switch (code1)
     {
@@ -261,8 +260,7 @@ composite_type (tree t1, tree t2)
 	tree elt = composite_type (TREE_TYPE (t1), TREE_TYPE (t2));
 	
 	/* We should not have any type quals on arrays at all.  */
-	if (TYPE_QUALS (t1) || TYPE_QUALS (t2))
-	  abort ();
+	gcc_assert (!TYPE_QUALS (t1) && !TYPE_QUALS (t2));
 	
 	/* Save space: see if the result is identical to one of the args.  */
 	if (elt == TREE_TYPE (t1) && TYPE_DOMAIN (t1))
@@ -412,8 +410,8 @@ common_pointer_type (tree t1, tree t2)
   if (t2 == error_mark_node)
     return t1;
 
-  if (TREE_CODE (t1) != POINTER_TYPE || TREE_CODE (t2) != POINTER_TYPE)
-    abort ();
+  gcc_assert (TREE_CODE (t1) == POINTER_TYPE
+ 	      && TREE_CODE (t2) == POINTER_TYPE);
 
   /* Merge the attributes.  */
   attributes = targetm.merge_type_attributes (t1, t2);
@@ -470,13 +468,10 @@ common_type (tree t1, tree t2)
   code1 = TREE_CODE (t1);
   code2 = TREE_CODE (t2);
 
-  if (code1 != VECTOR_TYPE && code1 != COMPLEX_TYPE
-      && code1 != REAL_TYPE && code1 != INTEGER_TYPE)
-    abort ();
-
-  if (code2 != VECTOR_TYPE && code2 != COMPLEX_TYPE
-      && code2 != REAL_TYPE && code2 != INTEGER_TYPE)
-    abort ();
+  gcc_assert (code1 == VECTOR_TYPE || code1 == COMPLEX_TYPE
+	      || code1 == REAL_TYPE || code1 == INTEGER_TYPE);
+  gcc_assert (code2 == VECTOR_TYPE || code2 == COMPLEX_TYPE
+	      || code2 == REAL_TYPE || code2 == INTEGER_TYPE);
 
   /* If one type is a vector type, return that type.  (How the usual
      arithmetic conversions apply to the vector types extension is not
@@ -744,7 +739,7 @@ same_translation_unit_p (tree t1, tree t2)
       case 'd': t1 = DECL_CONTEXT (t1); break;
       case 't': t1 = TYPE_CONTEXT (t1); break;
       case 'x': t1 = BLOCK_SUPERCONTEXT (t1); break;  /* assume block */
-      default: abort ();
+      default: gcc_unreachable ();
       }
 
   while (t2 && TREE_CODE (t2) != TRANSLATION_UNIT_DECL)
@@ -753,7 +748,7 @@ same_translation_unit_p (tree t1, tree t2)
       case 'd': t2 = DECL_CONTEXT (t2); break;
       case 't': t2 = TYPE_CONTEXT (t2); break;
       case 'x': t2 = BLOCK_SUPERCONTEXT (t2); break;  /* assume block */
-      default: abort ();
+      default: gcc_unreachable ();
       }
 
   return t1 == t2;
@@ -935,7 +930,7 @@ tagged_types_tu_compatible_p (tree t1, tree t2)
       }
 
     default:
-      abort ();
+      gcc_unreachable ();
     }
 }
 
@@ -4371,8 +4366,7 @@ finish_init (void)
       free (q);
     }
 
-  if (constructor_range_stack)
-    abort ();
+  gcc_assert (!constructor_range_stack);
 
   /* Pop back to the data of the outer initializer (if any).  */
   free (spelling_base);
@@ -4716,8 +4710,7 @@ pop_init_level (int implicit)
       while (constructor_stack->implicit)
 	process_init_element (pop_init_level (1));
 
-      if (constructor_range_stack)
-	abort ();
+      gcc_assert (!constructor_range_stack);
     }
 
   /* Now output all pending elements.  */
@@ -4737,8 +4730,10 @@ pop_init_level (int implicit)
 	 already have pedwarned for empty brackets.  */
       if (integer_zerop (constructor_unfilled_index))
 	constructor_type = NULL_TREE;
-      else if (! TYPE_SIZE (constructor_type))
+      else
 	{
+	  gcc_assert (!TYPE_SIZE (constructor_type));
+	  
 	  if (constructor_depth > 2)
 	    error_init ("initialization of flexible array member in a nested context");
 	  else if (pedantic)
@@ -4750,10 +4745,6 @@ pop_init_level (int implicit)
 	  if (TREE_CHAIN (constructor_fields) != NULL_TREE)
 	    constructor_type = NULL_TREE;
 	}
-      else
-	/* Zero-length arrays are no longer special, so we should no longer
-	   get here.  */
-	abort ();
     }
 
   /* Warn when some struct elements are implicitly initialized to zero.  */
@@ -4869,14 +4860,14 @@ set_designator (int array)
   if (constructor_type == 0)
     return 1;
 
-  /* If there were errors in this designator list already, bail out silently.  */
+  /* If there were errors in this designator list already, bail out
+     silently.  */
   if (designator_errorneous)
     return 1;
 
   if (!designator_depth)
     {
-      if (constructor_range_stack)
-	abort ();
+      gcc_assert (!constructor_range_stack);
 
       /* Designator list starts at the level of closest explicit
 	 braces.  */
@@ -4892,19 +4883,20 @@ set_designator (int array)
       return 1;
     }
 
-  if (TREE_CODE (constructor_type) == RECORD_TYPE
-      || TREE_CODE (constructor_type) == UNION_TYPE)
+  switch (TREE_CODE (constructor_type))
     {
+    case  RECORD_TYPE:
+    case  UNION_TYPE:
       subtype = TREE_TYPE (constructor_fields);
       if (subtype != error_mark_node)
 	subtype = TYPE_MAIN_VARIANT (subtype);
-    }
-  else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
-    {
+      break;
+    case ARRAY_TYPE:
       subtype = TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type));
+      break;
+    default:
+      gcc_unreachable ();
     }
-  else
-    abort ();
 
   subcode = TREE_CODE (subtype);
   if (array && subcode != ARRAY_TYPE)
@@ -5324,18 +5316,17 @@ set_nonincremental_init_from_string (tree str)
   const char *p, *end;
   int byte, wchar_bytes, charwidth, bitpos;
 
-  if (TREE_CODE (constructor_type) != ARRAY_TYPE)
-    abort ();
+  gcc_assert (TREE_CODE (constructor_type) == ARRAY_TYPE);
 
   if (TYPE_PRECISION (TREE_TYPE (TREE_TYPE (str)))
       == TYPE_PRECISION (char_type_node))
     wchar_bytes = 1;
-  else if (TYPE_PRECISION (TREE_TYPE (TREE_TYPE (str)))
-	   == TYPE_PRECISION (wchar_type_node))
-    wchar_bytes = TYPE_PRECISION (wchar_type_node) / BITS_PER_UNIT;
   else
-    abort ();
-
+    {
+      gcc_assert (TYPE_PRECISION (TREE_TYPE (TREE_TYPE (str)))
+		  == TYPE_PRECISION (wchar_type_node));
+      wchar_bytes = TYPE_PRECISION (wchar_type_node) / BITS_PER_UNIT;
+    }
   charwidth = TYPE_PRECISION (char_type_node);
   type = TREE_TYPE (constructor_type);
   p = TREE_STRING_POINTER (str);
@@ -6077,16 +6068,14 @@ process_init_element (struct c_expr value)
 	  constructor_range_stack = 0;
 	  while (constructor_stack != range_stack->stack)
 	    {
-	      if (!constructor_stack->implicit)
-		abort ();
+	      gcc_assert (constructor_stack->implicit);
 	      process_init_element (pop_init_level (1));
 	    }
 	  for (p = range_stack;
 	       !p->range_end || tree_int_cst_equal (p->index, p->range_end);
 	       p = p->prev)
 	    {
-	      if (!constructor_stack->implicit)
-		abort ();
+	      gcc_assert (constructor_stack->implicit);
 	      process_init_element (pop_init_level (1));
 	    }
 
@@ -6471,7 +6460,7 @@ c_finish_if_stmt (location_t if_locus, tree cond, tree then_block,
 	    inner_if = TREE_OPERAND (inner_if, 0);
 	    break;
 	  default:
-	    abort ();
+	    gcc_unreachable ();
 	  }
     found:
 

gcc/caller-save.c

@@ -160,8 +160,7 @@ init_caller_save (void)
 	 [(int) MODE_BASE_REG_CLASS (regno_save_mode [i][1])], i))
       break;
 
-  if (i == FIRST_PSEUDO_REGISTER)
-    abort ();
+  gcc_assert (i < FIRST_PSEUDO_REGISTER);
 
   addr_reg = gen_rtx_REG (Pmode, i);
 
@@ -381,8 +380,7 @@ save_call_clobbered_regs (void)
 
       next = chain->next;
 
-      if (chain->is_caller_save_insn)
-	abort ();
+      gcc_assert (!chain->is_caller_save_insn);
 
       if (INSN_P (insn))
 	{
@@ -431,22 +429,17 @@ save_call_clobbered_regs (void)
 		 {
 		   int r = reg_renumber[regno];
 		   int nregs;
-
-		   if (r >= 0)
-		     {
-		       enum machine_mode mode;
-
-		       nregs = hard_regno_nregs[r][PSEUDO_REGNO_MODE (regno)];
-		       mode = HARD_REGNO_CALLER_SAVE_MODE
-			        (r, nregs, PSEUDO_REGNO_MODE (regno));
-		       if (GET_MODE_BITSIZE (mode)
-			   > GET_MODE_BITSIZE (save_mode[r]))
-			 save_mode[r] = mode;
-		       while (nregs-- > 0)
-			 SET_HARD_REG_BIT (hard_regs_to_save, r + nregs);
-		     }
-		   else
-		     abort ();
+		   enum machine_mode mode;
+
+		   gcc_assert (r >= 0);
+		   nregs = hard_regno_nregs[r][PSEUDO_REGNO_MODE (regno)];
+		   mode = HARD_REGNO_CALLER_SAVE_MODE
+		     (r, nregs, PSEUDO_REGNO_MODE (regno));
+		   if (GET_MODE_BITSIZE (mode)
+		       > GET_MODE_BITSIZE (save_mode[r]))
+		     save_mode[r] = mode;
+		   while (nregs-- > 0)
+		     SET_HARD_REG_BIT (hard_regs_to_save, r + nregs);
 		 });
 
 	      /* Record all registers set in this call insn.  These don't need
@@ -650,9 +643,7 @@ insert_restore (struct insn_chain *chain, int before_p, int regno,
      or SET_SRC.  Instead of doing so and causing a crash later, check
      for this common case and abort here instead.  This will remove one
      step in debugging such problems.  */
-
-  if (regno_save_mem[regno][1] == 0)
-    abort ();
+  gcc_assert (regno_save_mem[regno][1]);
 
   /* Get the pattern to emit and update our status.
 
@@ -725,9 +716,7 @@ insert_save (struct insn_chain *chain, int before_p, int regno,
      or SET_SRC.  Instead of doing so and causing a crash later, check
      for this common case and abort here instead.  This will remove one
      step in debugging such problems.  */
-
-  if (regno_save_mem[regno][1] == 0)
-    abort ();
+  gcc_assert (regno_save_mem[regno][1]);
 
   /* Get the pattern to emit and update our status.
 
@@ -824,9 +813,7 @@ insert_one_insn (struct insn_chain *chain, int before_p, int code, rtx pat)
 	      rtx reg = XEXP (link, 0);
 	      int regno, i;
 
-	      if (!REG_P (reg))
-		abort ();
-
+	      gcc_assert (REG_P (reg));
 	      regno = REGNO (reg);
 	      if (regno >= FIRST_PSEUDO_REGISTER)
 		regno = reg_renumber[regno];

gcc/calls.c

@@ -349,7 +349,7 @@ emit_call_1 (rtx funexp, tree fntree, tree fndecl ATTRIBUTE_UNUSED,
     }
   else
 #endif
-    abort ();
+    gcc_unreachable ();
 
   /* Find the call we just emitted.  */
   call_insn = last_call_insn ();
@@ -1158,8 +1158,7 @@ compute_argument_block_size (int reg_parm_stack_space,
 	  /* We don't handle this case yet.  To handle it correctly we have
 	     to add the delta, round and subtract the delta.
 	     Currently no machine description requires this support.  */
-	  if (stack_pointer_delta & (preferred_stack_boundary - 1))
-	    abort ();
+	  gcc_assert (!(stack_pointer_delta & (preferred_stack_boundary - 1)));
 	  args_size->var = round_up (args_size->var, preferred_stack_boundary);
 	}
 
@@ -1225,8 +1224,7 @@ precompute_arguments (int flags, int num_actuals, struct arg_data *args)
       enum machine_mode mode;
 
       /* If this is an addressable type, we cannot pre-evaluate it.  */
-      if (TREE_ADDRESSABLE (TREE_TYPE (args[i].tree_value)))
-	abort ();
+      gcc_assert (!TREE_ADDRESSABLE (TREE_TYPE (args[i].tree_value)));
 
       args[i].initial_value = args[i].value
 	= expand_expr (args[i].tree_value, NULL_RTX, VOIDmode, 0);
@@ -1999,8 +1997,7 @@ expand_call (tree exp, rtx target, int ignore)
 
   /* Operand 0 is a pointer-to-function; get the type of the function.  */
   funtype = TREE_TYPE (addr);
-  if (! POINTER_TYPE_P (funtype))
-    abort ();
+  gcc_assert (POINTER_TYPE_P (funtype));
   funtype = TREE_TYPE (funtype);
 
   /* Munge the tree to split complex arguments into their imaginary
@@ -2641,8 +2638,8 @@ expand_call (tree exp, rtx target, int ignore)
 	 now!  */
 
       /* Stack must be properly aligned now.  */
-      if (pass && stack_pointer_delta % preferred_unit_stack_boundary)
-	abort ();
+      gcc_assert (!pass
+		  || !(stack_pointer_delta % preferred_unit_stack_boundary));
 
       /* Generate the actual call instruction.  */
       emit_call_1 (funexp, exp, fndecl, funtype, unadjusted_args_size,
@@ -2754,8 +2751,7 @@ expand_call (tree exp, rtx target, int ignore)
 	    {
 	      last = PREV_INSN (last);
 	      /* There was no CALL_INSN?  */
-	      if (last == before_call)
-		abort ();
+	      gcc_assert (last != before_call);
 	    }
 
 	  emit_barrier_after (last);
@@ -2855,36 +2851,36 @@ expand_call (tree exp, rtx target, int ignore)
 
       if (targetm.calls.promote_function_return(funtype))
 	{
-      /* If we promoted this return value, make the proper SUBREG.  TARGET
-	 might be const0_rtx here, so be careful.  */
-      if (REG_P (target)
-	  && TYPE_MODE (TREE_TYPE (exp)) != BLKmode
-	  && GET_MODE (target) != TYPE_MODE (TREE_TYPE (exp)))
-	{
-	  tree type = TREE_TYPE (exp);
-	  int unsignedp = TYPE_UNSIGNED (type);
-	  int offset = 0;
-
-	  /* If we don't promote as expected, something is wrong.  */
-	  if (GET_MODE (target)
-	      != promote_mode (type, TYPE_MODE (type), &unsignedp, 1))
-	    abort ();
-
-	if ((WORDS_BIG_ENDIAN || BYTES_BIG_ENDIAN)
-	    && GET_MODE_SIZE (GET_MODE (target))
-	       > GET_MODE_SIZE (TYPE_MODE (type)))
-	  {
-	    offset = GET_MODE_SIZE (GET_MODE (target))
-		     - GET_MODE_SIZE (TYPE_MODE (type));
-	    if (! BYTES_BIG_ENDIAN)
-	      offset = (offset / UNITS_PER_WORD) * UNITS_PER_WORD;
-	    else if (! WORDS_BIG_ENDIAN)
-	      offset %= UNITS_PER_WORD;
-	  }
-	  target = gen_rtx_SUBREG (TYPE_MODE (type), target, offset);
-	  SUBREG_PROMOTED_VAR_P (target) = 1;
-	  SUBREG_PROMOTED_UNSIGNED_SET (target, unsignedp);
-	}
+	  /* If we promoted this return value, make the proper SUBREG.
+	     TARGET might be const0_rtx here, so be careful.  */
+	  if (REG_P (target)
+	      && TYPE_MODE (TREE_TYPE (exp)) != BLKmode
+	      && GET_MODE (target) != TYPE_MODE (TREE_TYPE (exp)))
+	    {
+	      tree type = TREE_TYPE (exp);
+	      int unsignedp = TYPE_UNSIGNED (type);
+	      int offset = 0;
+	      enum machine_mode pmode;
+	      
+	      pmode = promote_mode (type, TYPE_MODE (type), &unsignedp, 1);
+	      /* If we don't promote as expected, something is wrong.  */
+	      gcc_assert (GET_MODE (target) == pmode);
+	      
+	      if ((WORDS_BIG_ENDIAN || BYTES_BIG_ENDIAN)
+		  && (GET_MODE_SIZE (GET_MODE (target))
+		      > GET_MODE_SIZE (TYPE_MODE (type))))
+		{
+		  offset = GET_MODE_SIZE (GET_MODE (target))
+		    - GET_MODE_SIZE (TYPE_MODE (type));
+		  if (! BYTES_BIG_ENDIAN)
+		    offset = (offset / UNITS_PER_WORD) * UNITS_PER_WORD;
+		  else if (! WORDS_BIG_ENDIAN)
+		    offset %= UNITS_PER_WORD;
+		}
+	      target = gen_rtx_SUBREG (TYPE_MODE (type), target, offset);
+	      SUBREG_PROMOTED_VAR_P (target) = 1;
+	      SUBREG_PROMOTED_UNSIGNED_SET (target, unsignedp);
+	    }
 	}
 
       /* If size of args is variable or this was a constructor call for a stack
@@ -2971,10 +2967,9 @@ expand_call (tree exp, rtx target, int ignore)
 	  normal_call_insns = insns;
 
 	  /* Verify that we've deallocated all the stack we used.  */
-	  if (! (flags & (ECF_NORETURN | ECF_LONGJMP))
-	      && old_stack_allocated != stack_pointer_delta
-					- pending_stack_adjust)
-	    abort ();
+	  gcc_assert ((flags & (ECF_NORETURN | ECF_LONGJMP))
+		      || (old_stack_allocated
+			  == stack_pointer_delta - pending_stack_adjust));
 	}
 
       /* If something prevents making this a sibling call,
@@ -3286,6 +3281,8 @@ emit_library_call_value_1 (int retval, rtx orgfun, rtx value,
   if (mem_value && struct_value == 0 && ! pcc_struct_value)
     {
       rtx addr = XEXP (mem_value, 0);
+      int partial;
+      
       nargs++;
 
       /* Make sure it is a reasonable operand for a move or push insn.  */
@@ -3298,8 +3295,8 @@ emit_library_call_value_1 (int retval, rtx orgfun, rtx value,
       argvec[count].partial = 0;
 
       argvec[count].reg = FUNCTION_ARG (args_so_far, Pmode, NULL_TREE, 1);
-      if (FUNCTION_ARG_PARTIAL_NREGS (args_so_far, Pmode, NULL_TREE, 1))
-	abort ();
+      partial = FUNCTION_ARG_PARTIAL_NREGS (args_so_far, Pmode, NULL_TREE, 1);
+      gcc_assert (!partial);
 
       locate_and_pad_parm (Pmode, NULL_TREE,
 #ifdef STACK_PARMS_IN_REG_PARM_AREA
@@ -3325,9 +3322,8 @@ emit_library_call_value_1 (int retval, rtx orgfun, rtx value,
 
       /* We cannot convert the arg value to the mode the library wants here;
 	 must do it earlier where we know the signedness of the arg.  */
-      if (mode == BLKmode
-	  || (GET_MODE (val) != mode && GET_MODE (val) != VOIDmode))
-	abort ();
+      gcc_assert (mode != BLKmode
+		  && (GET_MODE (val) == mode || GET_MODE (val) == VOIDmode));
 
       /* Make sure it is a reasonable operand for a move or push insn.  */
       if (!REG_P (val) && !MEM_P (val)
@@ -3397,8 +3393,7 @@ emit_library_call_value_1 (int retval, rtx orgfun, rtx value,
 			   argvec[count].partial,
 			   NULL_TREE, &args_size, &argvec[count].locate);
 
-      if (argvec[count].locate.size.var)
-	abort ();
+      gcc_assert (!argvec[count].locate.size.var);
 
       if (argvec[count].reg == 0 || argvec[count].partial != 0
 	  || reg_parm_stack_space > 0)
@@ -3662,8 +3657,8 @@ emit_library_call_value_1 (int retval, rtx orgfun, rtx value,
 	    ? hard_libcall_value (outmode) : NULL_RTX);
 
   /* Stack must be properly aligned now.  */
-  if (stack_pointer_delta & (PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT - 1))
-    abort ();
+  gcc_assert (!(stack_pointer_delta
+		& (PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT - 1)));
 
   before_call = get_last_insn ();
 
@@ -3698,8 +3693,7 @@ emit_library_call_value_1 (int retval, rtx orgfun, rtx value,
 	{
 	  last = PREV_INSN (last);
 	  /* There was no CALL_INSN?  */
-	  if (last == before_call)
-	    abort ();
+	  gcc_assert (last != before_call);
 	}
 
       emit_barrier_after (last);
@@ -3975,11 +3969,10 @@ store_one_arg (struct arg_data *arg, rtx argblock, int flags,
       partial = arg->partial;
     }
 
-  if (reg != 0 && partial == 0)
-    /* Being passed entirely in a register.  We shouldn't be called in
-       this case.  */
-    abort ();
-
+  /* Being passed entirely in a register.  We shouldn't be called in
+     this case.  */
+  gcc_assert (reg == 0 || partial != 0);
+  
   /* If this arg needs special alignment, don't load the registers
      here.  */
   if (arg->n_aligned_regs != 0)
@@ -4151,8 +4144,8 @@ store_one_arg (struct arg_data *arg, rtx argblock, int flags,
 		i = INTVAL (XEXP (XEXP (x, 0), 1));
 
 	      /* expand_call should ensure this.  */
-	      if (arg->locate.offset.var || GET_CODE (size_rtx) != CONST_INT)
-		abort ();
+	      gcc_assert (!arg->locate.offset.var
+			  && GET_CODE (size_rtx) == CONST_INT);
 
 	      if (arg->locate.offset.constant > i)
 		{