This is the mail archive of the
gcc-patches@gcc.gnu.org
mailing list for the GCC project.
More assertification
- From: Nathan Sidwell <nathan at codesourcery dot com>
- To: GCC Patches <gcc-patches at gcc dot gnu dot org>
- Date: Fri, 22 Apr 2005 17:15:34 +0100
- Subject: More assertification
- Organization: CodeSourcery LLC
This patch cleans up some more common files where 'abort' was being used in
comments, and some abort calls had crept in.
booted & tested on i686-pc-linux-gnu, checked & unchecked. Installed.
I think that's all the compile-time common files done, whew!
nathan
--
Nathan Sidwell :: http://www.codesourcery.com :: CodeSourcery LLC
nathan@codesourcery.com :: http://www.planetfall.pwp.blueyonder.co.uk
2005-04-22 Nathan Sidwell <nathan@codesourcery.com>
* builtins.c (gimplify_va_arg_expr): Reword comments to avoid
'abort'. Use gcc_assert and gcc_unreachable as appropriate.
* c-format.c (get_constant, decode_format_attr, get_flag_spec,
find_char_info_specifier_index,
find_length_info_modifier_index): Likewise.
* c-typeck.c (composite_type, pop_init_level): Likewise.
* combine.c (cant_combine_insn_p, try_combine): Likewise.
* cse.c (cse_insn): Likewise
* dominance.c (calc_dfs_tree): Likewise
dwarf2out.c (loc_descriptor_from_tree_1,
add_abstract_origin_attribute, force_decl_die,
force_type_die): Likewise
emit-rtl.c (operand_subword_force): Likewise
explow.c (hard_function_value): Likewise
expmed.c (store_bit_field, expand_divmod,
emit_store_flag_force): Likewise
expr.c (emit_move_multi_word, store_expr,
expand_expr_real_1): Likewise
final.c (this_is_asm_operands, shorten_branches, final_scan_insn,
output_operand): Likewise
flow.c (recompute_reg_usage): Likewise
* function.c (assign_stack_temp_for_type, assign_temp,
handle_epilogue_set): Likewise
* genextract.c (main): Likewise
* gimplify.c (mostly_copy_tree_r, gimplify_return_expr,
gimplify_modify_expr_rhs, gimplify_expr): Likewise
* haifa-sched.c (ready_lastpos, ready_remove_first, ready_element,
ready_remove, rm_line_notes, rm_other_notes,
schedule_block): Likewise
mips-tfile.c (copy_object, out_of_bounds): Likewise
Index: builtins.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/builtins.c,v
retrieving revision 1.458
diff -c -3 -p -r1.458 builtins.c
*** builtins.c 20 Apr 2005 04:53:53 -0000 1.458
--- builtins.c 22 Apr 2005 13:23:15 -0000
*************** gimplify_va_arg_expr (tree *expr_p, tree
*** 4262,4268 ****
gimplify_expr (&valist, pre_p, post_p, is_gimple_min_lval, fb_lvalue);
if (!targetm.gimplify_va_arg_expr)
! /* Once most targets are converted this should abort. */
return GS_ALL_DONE;
*expr_p = targetm.gimplify_va_arg_expr (valist, type, pre_p, post_p);
--- 4262,4269 ----
gimplify_expr (&valist, pre_p, post_p, is_gimple_min_lval, fb_lvalue);
if (!targetm.gimplify_va_arg_expr)
! /* FIXME:Once most targets are converted we should merely
! assert this is non-null. */
return GS_ALL_DONE;
*expr_p = targetm.gimplify_va_arg_expr (valist, type, pre_p, post_p);
Index: c-format.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/c-format.c,v
retrieving revision 1.71
diff -c -3 -p -r1.71 c-format.c
*** c-format.c 29 Mar 2005 22:15:52 -0000 1.71
--- c-format.c 22 Apr 2005 13:23:21 -0000
*************** check_format_string (tree argument, unsi
*** 148,154 ****
}
/* Verify EXPR is a constant, 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)
--- 148,154 ----
}
/* Verify EXPR is a constant, and store its value.
! If validated_p is true there should be no 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_W
*** 164,175 ****
return true;
}
! /* Decode the arguments to a "format" attribute into a function_format_info
! structure. It is already known that the list is of the right length.
! If VALIDATED_P is true, then these attributes have already been validated
! and this function will abort if they are erroneous; if false, it
! will give an error message. Returns true if the attributes are
! successfully decoded, false otherwise. */
static bool
decode_format_attr (tree args, function_format_info *info, int validated_p)
--- 164,175 ----
return true;
}
! /* Decode the arguments to a "format" attribute into a
! function_format_info structure. It is already known that the list
! is of the right length. If VALIDATED_P is true, then these
! attributes have already been validated and must not be erroneous;
! if false, it will give an error message. Returns true if the
! attributes are successfully decoded, false otherwise. */
static bool
decode_format_attr (tree args, function_format_info *info, int validated_p)
*************** finish_dollar_format_checking (format_ch
*** 1063,1072 ****
/* Retrieve the specification for a format flag. SPEC contains the
specifications for format flags for the applicable kind of format.
FLAG is the flag in question. If PREDICATES is NULL, the basic
! spec for that flag must be retrieved and this function aborts if
! it cannot be found. If PREDICATES is not NULL, it is a string listing
! possible predicates for the spec entry; if an entry predicated on any
! of these is found, it is returned, otherwise NULL is returned. */
static const format_flag_spec *
get_flag_spec (const format_flag_spec *spec, int flag, const char *predicates)
--- 1063,1072 ----
/* Retrieve the specification for a format flag. SPEC contains the
specifications for format flags for the applicable kind of format.
FLAG is the flag in question. If PREDICATES is NULL, the basic
! spec for that flag must be retrieved and must exist. If
! PREDICATES is not NULL, it is a string listing possible predicates
! for the spec entry; if an entry predicated on any of these is
! found, it is returned, otherwise NULL is returned. */
static const format_flag_spec *
get_flag_spec (const format_flag_spec *spec, int flag, const char *predicates)
*************** format_type_warning (const char *descr,
*** 2236,2242 ****
/* Given a format_char_info array FCI, and a character C, this function
returns the index into the conversion_specs where that specifier's
! data is located. If the character isn't found it aborts. */
static unsigned int
find_char_info_specifier_index (const format_char_info *fci, int c)
{
--- 2236,2242 ----
/* Given a format_char_info array FCI, and a character C, this function
returns the index into the conversion_specs where that specifier's
! data is located. The character must exist. */
static unsigned int
find_char_info_specifier_index (const format_char_info *fci, int c)
{
*************** find_char_info_specifier_index (const fo
*** 2252,2259 ****
/* Given a format_length_info array FLI, and a character C, this
function returns the index into the conversion_specs where that
! modifier's data is located. If the character isn't found it
! aborts. */
static unsigned int
find_length_info_modifier_index (const format_length_info *fli, int c)
{
--- 2252,2258 ----
/* Given a format_length_info array FLI, and a character C, this
function returns the index into the conversion_specs where that
! modifier's data is located. The character must exist. */
static unsigned int
find_length_info_modifier_index (const format_length_info *fli, int c)
{
Index: c-typeck.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/c-typeck.c,v
retrieving revision 1.434
diff -c -3 -p -r1.434 c-typeck.c
*** c-typeck.c 20 Apr 2005 16:41:32 -0000 1.434
--- c-typeck.c 22 Apr 2005 13:23:38 -0000
*************** composite_type (tree t1, tree t2)
*** 344,350 ****
/* If both args specify argument types, we must merge the two
lists, argument by argument. */
/* Tell global_bindings_p to return false so that variable_size
! doesn't abort on VLAs in parameter types. */
c_override_global_bindings_to_false = true;
len = list_length (p1);
--- 344,350 ----
/* If both args specify argument types, we must merge the two
lists, argument by argument. */
/* Tell global_bindings_p to return false so that variable_size
! doesn't die on VLAs in parameter types. */
c_override_global_bindings_to_false = true;
len = list_length (p1);
*************** pop_init_level (int implicit)
*** 5018,5024 ****
/* We have already issued an error message for the existence
of a flexible array member not at the end of the structure.
! Discard the initializer so that we do not abort later. */
if (TREE_CHAIN (constructor_fields) != NULL_TREE)
constructor_type = NULL_TREE;
}
--- 5018,5024 ----
/* We have already issued an error message for the existence
of a flexible array member not at the end of the structure.
! Discard the initializer so that we do not die later. */
if (TREE_CHAIN (constructor_fields) != NULL_TREE)
constructor_type = NULL_TREE;
}
Index: combine.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/combine.c,v
retrieving revision 1.487
diff -c -3 -p -r1.487 combine.c
*** combine.c 15 Apr 2005 03:16:20 -0000 1.487
--- combine.c 22 Apr 2005 13:24:06 -0000
*************** cant_combine_insn_p (rtx insn)
*** 1527,1533 ****
/* Never combine loads and stores involving hard regs that are likely
to be spilled. The register allocator can usually handle such
reg-reg moves by tying. If we allow the combiner to make
! substitutions of likely-spilled regs, we may abort in reload.
As an exception, we allow combinations involving fixed regs; these are
not available to the register allocator so there's no risk involved. */
--- 1527,1533 ----
/* Never combine loads and stores involving hard regs that are likely
to be spilled. The register allocator can usually handle such
reg-reg moves by tying. If we allow the combiner to make
! substitutions of likely-spilled regs, reload might die.
As an exception, we allow combinations involving fixed regs; these are
not available to the register allocator so there's no risk involved. */
*************** try_combine (rtx i3, rtx i2, rtx i1, int
*** 2096,2103 ****
|| (i1 != 0 && FIND_REG_INC_NOTE (i1, NULL_RTX) != 0
&& (n_occurrences + added_sets_1 + (added_sets_2 && ! i1_feeds_i3)
> 1))
! /* Fail if we tried to make a new register (we used to abort, but there's
! really no reason to). */
|| max_reg_num () != maxreg
/* Fail if we couldn't do something and have a CLOBBER. */
|| GET_CODE (newpat) == CLOBBER
--- 2096,2102 ----
|| (i1 != 0 && FIND_REG_INC_NOTE (i1, NULL_RTX) != 0
&& (n_occurrences + added_sets_1 + (added_sets_2 && ! i1_feeds_i3)
> 1))
! /* Fail if we tried to make a new register. */
|| max_reg_num () != maxreg
/* Fail if we couldn't do something and have a CLOBBER. */
|| GET_CODE (newpat) == CLOBBER
Index: cse.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/cse.c,v
retrieving revision 1.353
diff -c -3 -p -r1.353 cse.c
*** cse.c 6 Apr 2005 17:04:59 -0000 1.353
--- cse.c 22 Apr 2005 13:24:22 -0000
*************** cse_insn (rtx insn, rtx libcall_insn)
*** 5534,5542 ****
else if (constant_pool_entries_cost
&& CONSTANT_P (trial)
! /* Reject cases that will abort in decode_rtx_const.
! On the alpha when simplifying a switch, we get
! (const (truncate (minus (label_ref) (label_ref)))). */
&& ! (GET_CODE (trial) == CONST
&& GET_CODE (XEXP (trial, 0)) == TRUNCATE)
/* Likewise on IA-64, except without the truncate. */
--- 5534,5543 ----
else if (constant_pool_entries_cost
&& CONSTANT_P (trial)
! /* Reject cases that will cause decode_rtx_const to
! die. On the alpha when simplifying a switch, we
! get (const (truncate (minus (label_ref)
! (label_ref)))). */
&& ! (GET_CODE (trial) == CONST
&& GET_CODE (XEXP (trial, 0)) == TRUNCATE)
/* Likewise on IA-64, except without the truncate. */
Index: dominance.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/dominance.c,v
retrieving revision 1.38
diff -c -3 -p -r1.38 dominance.c
*** dominance.c 9 Apr 2005 16:43:27 -0000 1.38
--- dominance.c 22 Apr 2005 13:24:24 -0000
*************** calc_dfs_tree (struct dom_info *di, enum
*** 372,378 ****
di->nodes = di->dfsnum - 1;
! /* This aborts e.g. when there is _no_ path from ENTRY to EXIT at all. */
gcc_assert (di->nodes == (unsigned int) n_basic_blocks + 1);
}
--- 372,378 ----
di->nodes = di->dfsnum - 1;
! /* Make sure there is a path from ENTRY to EXIT at all. */
gcc_assert (di->nodes == (unsigned int) n_basic_blocks + 1);
}
Index: dwarf2out.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/dwarf2out.c,v
retrieving revision 1.586
diff -c -3 -p -r1.586 dwarf2out.c
*** dwarf2out.c 21 Apr 2005 09:17:13 -0000 1.586
--- dwarf2out.c 22 Apr 2005 13:24:53 -0000
*************** loc_descriptor_from_tree_1 (tree loc, in
*** 9283,9289 ****
#ifdef ENABLE_CHECKING
/* Otherwise this is a generic code; we should just lists all of
! these explicitly. Aborting means we forgot one. */
gcc_unreachable ();
#else
/* In a release build, we want to degrade gracefully: better to
--- 9283,9289 ----
#ifdef ENABLE_CHECKING
/* Otherwise this is a generic code; we should just lists all of
! these explicitly. We forgot one. */
gcc_unreachable ();
#else
/* In a release build, we want to degrade gracefully: better to
*************** add_abstract_origin_attribute (dw_die_re
*** 10583,10589 ****
trees (in the case of java, they simply have no block tree, in some other
languages). For these functions, there is nothing we can really do to
output correct debug info for inlined functions in all cases. Rather
! than abort, we'll just produce deficient debug info now, in that we will
have variables without a proper abstract origin. In the future, when all
functions are lowered, we should re-add a gcc_assert (origin_die)
here. */
--- 10583,10589 ----
trees (in the case of java, they simply have no block tree, in some other
languages). For these functions, there is nothing we can really do to
output correct debug info for inlined functions in all cases. Rather
! than die, we'll just produce deficient debug info now, in that we will
have variables without a proper abstract origin. In the future, when all
functions are lowered, we should re-add a gcc_assert (origin_die)
here. */
*************** is_redundant_typedef (tree decl)
*** 12540,12546 ****
return 0;
}
! /* Returns the DIE for decl or aborts. */
static dw_die_ref
force_decl_die (tree decl)
--- 12540,12546 ----
return 0;
}
! /* Returns the DIE for decl. A DIE will always be returned. */
static dw_die_ref
force_decl_die (tree decl)
*************** force_decl_die (tree decl)
*** 12593,12600 ****
gcc_unreachable ();
}
! /* See if we can find the die for this deci now.
! If not then abort. */
if (!decl_die)
decl_die = lookup_decl_die (decl);
gcc_assert (decl_die);
--- 12593,12599 ----
gcc_unreachable ();
}
! /* We should be able to find the DIE now. */
if (!decl_die)
decl_die = lookup_decl_die (decl);
gcc_assert (decl_die);
*************** force_decl_die (tree decl)
*** 12603,12609 ****
return decl_die;
}
! /* Returns the DIE for decl or aborts. */
static dw_die_ref
force_type_die (tree type)
--- 12602,12608 ----
return decl_die;
}
! /* Returns the DIE for TYPE. A DIE is always returned. */
static dw_die_ref
force_type_die (tree type)
Index: emit-rtl.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/emit-rtl.c,v
retrieving revision 1.436
diff -c -3 -p -r1.436 emit-rtl.c
*** emit-rtl.c 25 Mar 2005 02:23:57 -0000 1.436
--- emit-rtl.c 22 Apr 2005 13:25:02 -0000
*************** operand_subword (rtx op, unsigned int of
*** 1330,1338 ****
return simplify_gen_subreg (word_mode, op, mode, (offset * UNITS_PER_WORD));
}
! /* Similar to `operand_subword', but never return 0. If we can't extract
! the required subword, put OP into a register and try again. If that fails,
! abort. We always validate the address in this case.
MODE is the mode of OP, in case it is CONST_INT. */
--- 1330,1339 ----
return simplify_gen_subreg (word_mode, op, mode, (offset * UNITS_PER_WORD));
}
! /* Similar to `operand_subword', but never return 0. If we can't
! extract the required subword, put OP into a register and try again.
! The second attempt must succeed. We always validate the address in
! this case.
MODE is the mode of OP, in case it is CONST_INT. */
Index: explow.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/explow.c,v
retrieving revision 1.143
diff -c -3 -p -r1.143 explow.c
*** explow.c 18 Jan 2005 11:36:08 -0000 1.143
--- explow.c 22 Apr 2005 13:25:05 -0000
*************** hard_function_value (tree valtype, tree
*** 1525,1532 ****
enum machine_mode tmpmode;
/* int_size_in_bytes can return -1. We don't need a check here
! since the value of bytes will be large enough that no mode
! will match and we will abort later in this function. */
for (tmpmode = GET_CLASS_NARROWEST_MODE (MODE_INT);
tmpmode != VOIDmode;
--- 1525,1532 ----
enum machine_mode tmpmode;
/* int_size_in_bytes can return -1. We don't need a check here
! since the value of bytes will then be large enough that no
! mode will match anyway. */
for (tmpmode = GET_CLASS_NARROWEST_MODE (MODE_INT);
tmpmode != VOIDmode;
Index: expmed.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/expmed.c,v
retrieving revision 1.226
diff -c -3 -p -r1.226 expmed.c
*** expmed.c 13 Mar 2005 17:06:42 -0000 1.226
--- expmed.c 22 Apr 2005 13:25:17 -0000
*************** store_bit_field (rtx str_rtx, unsigned H
*** 544,551 ****
/* This is the mode we must force value to, so that there will be enough
subwords to extract. Note that fieldmode will often (always?) be
VOIDmode, because that is what store_field uses to indicate that this
! is a bit field, but passing VOIDmode to operand_subword_force will
! result in an abort. */
fieldmode = GET_MODE (value);
if (fieldmode == VOIDmode)
fieldmode = smallest_mode_for_size (nwords * BITS_PER_WORD, MODE_INT);
--- 544,551 ----
/* This is the mode we must force value to, so that there will be enough
subwords to extract. Note that fieldmode will often (always?) be
VOIDmode, because that is what store_field uses to indicate that this
! is a bit field, but passing VOIDmode to operand_subword_force
! is not allowed. */
fieldmode = GET_MODE (value);
if (fieldmode == VOIDmode)
fieldmode = smallest_mode_for_size (nwords * BITS_PER_WORD, MODE_INT);
*************** store_bit_field (rtx str_rtx, unsigned H
*** 582,591 ****
{
if (!REG_P (op0))
{
! /* Since this is a destination (lvalue), we can't copy it to a
! pseudo. We can trivially remove a SUBREG that does not
! change the size of the operand. Such a SUBREG may have been
! added above. Otherwise, abort. */
gcc_assert (GET_CODE (op0) == SUBREG
&& (GET_MODE_SIZE (GET_MODE (op0))
== GET_MODE_SIZE (GET_MODE (SUBREG_REG (op0)))));
--- 582,591 ----
{
if (!REG_P (op0))
{
! /* Since this is a destination (lvalue), we can't copy
! it to a pseudo. We can remove a SUBREG that does not
! change the size of the operand. Such a SUBREG may
! have been added above. */
gcc_assert (GET_CODE (op0) == SUBREG
&& (GET_MODE_SIZE (GET_MODE (op0))
== GET_MODE_SIZE (GET_MODE (SUBREG_REG (op0)))));
*************** expand_divmod (int rem_flag, enum tree_c
*** 3835,3842 ****
|| optab2->handlers[compute_mode].libfunc)
break;
! /* If we still couldn't find a mode, use MODE, but we'll probably abort
! in expand_binop. */
if (compute_mode == VOIDmode)
compute_mode = mode;
--- 3835,3842 ----
|| optab2->handlers[compute_mode].libfunc)
break;
! /* If we still couldn't find a mode, use MODE, but expand_binop will
! probably die. */
if (compute_mode == VOIDmode)
compute_mode = mode;
*************** emit_store_flag_force (rtx target, enum
*** 5538,5546 ****
The algorithm is based on the code in expr.c:do_jump.
! Note that this does not perform a general comparison. Only variants
! generated within expmed.c are correctly handled, others abort (but could
! be handled if needed). */
static void
do_cmp_and_jump (rtx arg1, rtx arg2, enum rtx_code op, enum machine_mode mode,
--- 5538,5546 ----
The algorithm is based on the code in expr.c:do_jump.
! Note that this does not perform a general comparison. Only
! variants generated within expmed.c are correctly handled, others
! could be handled if needed. */
static void
do_cmp_and_jump (rtx arg1, rtx arg2, enum rtx_code op, enum machine_mode mode,
Index: expr.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/expr.c,v
retrieving revision 1.785
diff -c -3 -p -r1.785 expr.c
*** expr.c 21 Apr 2005 15:35:49 -0000 1.785
--- expr.c 22 Apr 2005 13:25:36 -0000
*************** emit_move_multi_word (enum machine_mode
*** 3020,3027 ****
rtx ypart = operand_subword (y, i, 1, mode);
/* If we can't get a part of Y, put Y into memory if it is a
! constant. Otherwise, force it into a register. If we still
! can't get a part of Y, abort. */
if (ypart == 0 && CONSTANT_P (y))
{
y = force_const_mem (mode, y);
--- 3020,3027 ----
rtx ypart = operand_subword (y, i, 1, mode);
/* If we can't get a part of Y, put Y into memory if it is a
! constant. Otherwise, force it into a register. Then we must
! be able to get a part of Y. */
if (ypart == 0 && CONSTANT_P (y))
{
y = force_const_mem (mode, y);
*************** store_expr (tree exp, rtx target, int ca
*** 4222,4231 ****
but TARGET is not valid memory reference, TEMP will differ
from TARGET although it is really the same location. */
&& !(alt_rtl && rtx_equal_p (alt_rtl, target))
! /* If there's nothing to copy, don't bother. Don't call expr_size
! unless necessary, because some front-ends (C++) expr_size-hook
! aborts on objects that are not supposed to be bit-copied or
! bit-initialized. */
&& expr_size (exp) != const0_rtx)
{
if (GET_MODE (temp) != GET_MODE (target)
--- 4222,4231 ----
but TARGET is not valid memory reference, TEMP will differ
from TARGET although it is really the same location. */
&& !(alt_rtl && rtx_equal_p (alt_rtl, target))
! /* If there's nothing to copy, don't bother. Don't call
! expr_size unless necessary, because some front-ends (C++)
! expr_size-hook must not be given objects that are not
! supposed to be bit-copied or bit-initialized. */
&& expr_size (exp) != const0_rtx)
{
if (GET_MODE (temp) != GET_MODE (target)
*************** expand_expr_real_1 (tree exp, rtx target
*** 8341,8348 ****
op2 = expand_expr (oprnd2, NULL_RTX, VOIDmode, 0);
temp = expand_ternary_op (mode, this_optab, op0, op1, op2,
target, unsignedp);
! if (temp == 0)
! abort ();
return temp;
}
--- 8341,8347 ----
op2 = expand_expr (oprnd2, NULL_RTX, VOIDmode, 0);
temp = expand_ternary_op (mode, this_optab, op0, op1, op2,
target, unsignedp);
! gcc_assert (temp);
return temp;
}
Index: final.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/final.c,v
retrieving revision 1.351
diff -c -3 -p -r1.351 final.c
*** final.c 9 Apr 2005 13:37:33 -0000 1.351
--- final.c 22 Apr 2005 13:25:43 -0000
*************** static const char *last_filename;
*** 136,142 ****
extern int length_unit_log; /* This is defined in insn-attrtab.c. */
/* Nonzero while outputting an `asm' with operands.
! This means that inconsistencies are the user's fault, so don't abort.
The precise value is the insn being output, to pass to error_for_asm. */
rtx this_is_asm_operands;
--- 136,142 ----
extern int length_unit_log; /* This is defined in insn-attrtab.c. */
/* Nonzero while outputting an `asm' with operands.
! 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. */
rtx this_is_asm_operands;
*************** shorten_branches (rtx first ATTRIBUTE_UN
*** 788,794 ****
label_align = xrealloc (label_align,
n_labels * sizeof (struct label_alignment));
! /* Range of labels grows monotonically in the function. Abort here
means that the initialization of array got lost. */
gcc_assert (n_old_labels <= n_labels);
--- 788,794 ----
label_align = xrealloc (label_align,
n_labels * sizeof (struct label_alignment));
! /* Range of labels grows monotonically in the function. Failing here
means that the initialization of array got lost. */
gcc_assert (n_old_labels <= n_labels);
*************** final_scan_insn (rtx insn, FILE *file, i
*** 2060,2066 ****
/* Get out the operand values. */
string = decode_asm_operands (body, ops, NULL, NULL, NULL);
! /* Inhibit aborts on what would otherwise be compiler bugs. */
insn_noperands = noperands;
this_is_asm_operands = insn;
--- 2060,2066 ----
/* Get out the operand values. */
string = decode_asm_operands (body, ops, NULL, NULL, NULL);
! /* Inhibit dieing on what would otherwise be compiler bugs. */
insn_noperands = noperands;
this_is_asm_operands = insn;
*************** output_operand (rtx x, int code ATTRIBUT
*** 3135,3142 ****
if (x && GET_CODE (x) == SUBREG)
x = alter_subreg (&x);
! /* If X is a pseudo-register, abort now rather than writing trash to the
! assembler file. */
gcc_assert (!x || !REG_P (x) || REGNO (x) < FIRST_PSEUDO_REGISTER);
PRINT_OPERAND (asm_out_file, x, code);
--- 3135,3141 ----
if (x && GET_CODE (x) == SUBREG)
x = alter_subreg (&x);
! /* X must not be a psuedo reg. */
gcc_assert (!x || !REG_P (x) || REGNO (x) < FIRST_PSEUDO_REGISTER);
PRINT_OPERAND (asm_out_file, x, code);
Index: flow.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/flow.c,v
retrieving revision 1.626
diff -c -3 -p -r1.626 flow.c
*** flow.c 15 Apr 2005 16:47:17 -0000 1.626
--- flow.c 22 Apr 2005 13:25:52 -0000
*************** void
*** 4334,4342 ****
recompute_reg_usage (void)
{
allocate_reg_life_data ();
! /* distribute_notes in combiner fails to convert some of the REG_UNUSED notes
! to REG_DEAD notes. This causes CHECK_DEAD_NOTES in sched1 to abort. To
! solve this update the DEATH_NOTES here. */
update_life_info (NULL, UPDATE_LIFE_LOCAL, PROP_REG_INFO | PROP_DEATH_NOTES);
}
--- 4334,4343 ----
recompute_reg_usage (void)
{
allocate_reg_life_data ();
! /* distribute_notes in combiner fails to convert some of the
! REG_UNUSED notes to REG_DEAD notes. This causes CHECK_DEAD_NOTES
! in sched1 to die. To solve this update the DEATH_NOTES
! here. */
update_life_info (NULL, UPDATE_LIFE_LOCAL, PROP_REG_INFO | PROP_DEATH_NOTES);
}
Index: function.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/function.c,v
retrieving revision 1.611
diff -c -3 -p -r1.611 function.c
*** function.c 12 Apr 2005 21:33:51 -0000 1.611
--- function.c 22 Apr 2005 13:26:04 -0000
*************** make_slot_available (struct temp_slot *t
*** 578,590 ****
free_temp_slots. Automatic variables for a block are allocated
with this flag. KEEP values of 2 or 3 were needed respectively
for variables whose lifetime is controlled by CLEANUP_POINT_EXPRs
! or for SAVE_EXPRs, but they are now unused and will abort.
TYPE is the type that will be used for the stack slot. */
rtx
! assign_stack_temp_for_type (enum machine_mode mode, HOST_WIDE_INT size, int keep,
! tree type)
{
unsigned int align;
struct temp_slot *p, *best_p = 0, *selected = NULL, **pp;
--- 578,590 ----
free_temp_slots. Automatic variables for a block are allocated
with this flag. KEEP values of 2 or 3 were needed respectively
for variables whose lifetime is controlled by CLEANUP_POINT_EXPRs
! or for SAVE_EXPRs, but they are now unused.
TYPE is the type that will be used for the stack slot. */
rtx
! assign_stack_temp_for_type (enum machine_mode mode, HOST_WIDE_INT size,
! int keep, tree type)
{
unsigned int align;
struct temp_slot *p, *best_p = 0, *selected = NULL, **pp;
*************** assign_temp (tree type_or_decl, int keep
*** 815,821 ****
/* The size of the temporary may be too large to fit into an integer. */
/* ??? Not sure this should happen except for user silliness, so limit
this to things that aren't compiler-generated temporaries. The
! rest of the time we'll abort in assign_stack_temp_for_type. */
if (decl && size == -1
&& TREE_CODE (TYPE_SIZE_UNIT (type)) == INTEGER_CST)
{
--- 815,821 ----
/* The size of the temporary may be too large to fit into an integer. */
/* ??? Not sure this should happen except for user silliness, so limit
this to things that aren't compiler-generated temporaries. The
! rest of the time we'll die in assign_stack_temp_for_type. */
if (decl && size == -1
&& TREE_CODE (TYPE_SIZE_UNIT (type)) == INTEGER_CST)
{
*************** emit_return_into_block (basic_block bb,
*** 4715,4748 ****
#if defined(HAVE_epilogue) && defined(INCOMING_RETURN_ADDR_RTX)
! /* These functions convert the epilogue into a variant that does not modify the
! stack pointer. This is used in cases where a function returns an object
! whose size is not known until it is computed. The called function leaves the
! object on the stack, leaves the stack depressed, and returns a pointer to
! the object.
!
! What we need to do is track all modifications and references to the stack
! pointer, deleting the modifications and changing the references to point to
! the location the stack pointer would have pointed to had the modifications
! taken place.
!
! These functions need to be portable so we need to make as few assumptions
! about the epilogue as we can. However, the epilogue basically contains
! three things: instructions to reset the stack pointer, instructions to
! reload registers, possibly including the frame pointer, and an
! instruction to return to the caller.
!
! If we can't be sure of what a relevant epilogue insn is doing, we abort.
! We also make no attempt to validate the insns we make since if they are
! invalid, we probably can't do anything valid. The intent is that these
! routines get "smarter" as more and more machines start to use them and
! they try operating on different epilogues.
!
! We use the following structure to track what the part of the epilogue that
! we've already processed has done. We keep two copies of the SP equivalence,
! one for use during the insn we are processing and one for use in the next
! insn. The difference is because one part of a PARALLEL may adjust SP
! and the other may use it. */
struct epi_info
{
--- 4715,4749 ----
#if defined(HAVE_epilogue) && defined(INCOMING_RETURN_ADDR_RTX)
! /* These functions convert the epilogue into a variant that does not
! modify the stack pointer. This is used in cases where a function
! returns an object whose size is not known until it is computed.
! The called function leaves the object on the stack, leaves the
! stack depressed, and returns a pointer to the object.
!
! What we need to do is track all modifications and references to the
! stack pointer, deleting the modifications and changing the
! references to point to the location the stack pointer would have
! pointed to had the modifications taken place.
!
! These functions need to be portable so we need to make as few
! assumptions about the epilogue as we can. However, the epilogue
! basically contains three things: instructions to reset the stack
! pointer, instructions to reload registers, possibly including the
! frame pointer, and an instruction to return to the caller.
!
! We must be sure of what a relevant epilogue insn is doing. We also
! make no attempt to validate the insns we make since if they are
! invalid, we probably can't do anything valid. The intent is that
! these routines get "smarter" as more and more machines start to use
! them and they try operating on different epilogues.
!
! We use the following structure to track what the part of the
! epilogue that we've already processed has done. We keep two copies
! of the SP equivalence, one for use during the insn we are
! processing and one for use in the next insn. The difference is
! because one part of a PARALLEL may adjust SP and the other may use
! it. */
struct epi_info
{
*************** static void
*** 4960,4966 ****
handle_epilogue_set (rtx set, struct epi_info *p)
{
/* First handle the case where we are setting SP. Record what it is being
! set from. If unknown, abort. */
if (reg_set_p (stack_pointer_rtx, set))
{
gcc_assert (SET_DEST (set) == stack_pointer_rtx);
--- 4961,4967 ----
handle_epilogue_set (rtx set, struct epi_info *p)
{
/* First handle the case where we are setting SP. Record what it is being
! set from, which we must be able to determine */
if (reg_set_p (stack_pointer_rtx, set))
{
gcc_assert (SET_DEST (set) == stack_pointer_rtx);
*************** handle_epilogue_set (rtx set, struct epi
*** 4995,5008 ****
return;
}
! /* Next handle the case where we are setting SP's equivalent register.
! If we already have a value to set it to, abort. We could update, but
! there seems little point in handling that case. Note that we have
! to allow for the case where we are setting the register set in
! the previous part of a PARALLEL inside a single insn. But use the
! old offset for any updates within this insn. We must allow for the case
! where the register is being set in a different (usually wider) mode than
! Pmode). */
else if (p->new_sp_equiv_reg != 0 && reg_set_p (p->new_sp_equiv_reg, set))
{
gcc_assert (!p->equiv_reg_src
--- 4996,5009 ----
return;
}
! /* Next handle the case where we are setting SP's equivalent
! register. We must not already have a value to set it to. We
! could update, but there seems little point in handling that case.
! Note that we have to allow for the case where we are setting the
! register set in the previous part of a PARALLEL inside a single
! insn. But use the old offset for any updates within this insn.
! We must allow for the case where the register is being set in a
! different (usually wider) mode than Pmode). */
else if (p->new_sp_equiv_reg != 0 && reg_set_p (p->new_sp_equiv_reg, set))
{
gcc_assert (!p->equiv_reg_src
Index: genextract.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/genextract.c,v
retrieving revision 1.61
diff -c -3 -p -r1.61 genextract.c
*** genextract.c 9 Sep 2004 13:22:33 -0000 1.61
--- genextract.c 22 Apr 2005 13:26:05 -0000
*************** from the machine description file `md'.
*** 475,483 ****
printf (" break;\n\n");
}
! /* This should never be reached. Note that we would also reach this abort
! if we tried to extract something whose INSN_CODE was a DEFINE_EXPAND or
! DEFINE_SPLIT, but that is correct. */
printf (" default:\n gcc_unreachable ();\n");
printf (" }\n}\n");
--- 475,483 ----
printf (" break;\n\n");
}
! /* This should never be reached. Note that we would also reach here
! if we tried to extract something whose INSN_CODE was a
! DEFINE_EXPAND or DEFINE_SPLIT, but that is correct. */
printf (" default:\n gcc_unreachable ();\n");
printf (" }\n}\n");
Index: gimplify.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/gimplify.c,v
retrieving revision 2.123
diff -c -3 -p -r2.123 gimplify.c
*** gimplify.c 15 Apr 2005 03:09:49 -0000 2.123
--- gimplify.c 22 Apr 2005 13:26:14 -0000
*************** mostly_copy_tree_r (tree *tp, int *walk_
*** 606,612 ****
|| TREE_CODE_CLASS (code) == tcc_constant
|| code == SAVE_EXPR || code == TARGET_EXPR
/* We can't do anything sensible with a BLOCK used as an expression,
! but we also can't abort when we see it because of non-expression
uses. So just avert our eyes and cross our fingers. Silly Java. */
|| code == BLOCK)
*walk_subtrees = 0;
--- 606,612 ----
|| TREE_CODE_CLASS (code) == tcc_constant
|| code == SAVE_EXPR || code == TARGET_EXPR
/* We can't do anything sensible with a BLOCK used as an expression,
! but we also can't just die when we see it because of non-expression
uses. So just avert our eyes and cross our fingers. Silly Java. */
|| code == BLOCK)
*walk_subtrees = 0;
*************** gimplify_return_expr (tree stmt, tree *p
*** 930,936 ****
returned in registers. If we're returning values in registers, then
we don't want to extend the lifetime of the RESULT_DECL, particularly
across another call. In addition, for those aggregates for which
! hard_function_value generates a PARALLEL, we'll abort during normal
expansion of structure assignments; there's special code in expand_return
to handle this case that does not exist in expand_expr. */
if (!result_decl
--- 930,936 ----
returned in registers. If we're returning values in registers, then
we don't want to extend the lifetime of the RESULT_DECL, particularly
across another call. In addition, for those aggregates for which
! hard_function_value generates a PARALLEL, we'll die during normal
expansion of structure assignments; there's special code in expand_return
to handle this case that does not exist in expand_expr. */
if (!result_decl
*************** gimplify_modify_expr_rhs (tree *expr_p,
*** 2893,2899 ****
??? What about code that pulls out the temp and uses it
elsewhere? I think that such code never uses the TARGET_EXPR as
! an initializer. If I'm wrong, we'll abort because the temp won't
have any RTL. In that case, I guess we'll need to replace
references somehow. */
tree init = TARGET_EXPR_INITIAL (*from_p);
--- 2893,2899 ----
??? What about code that pulls out the temp and uses it
elsewhere? I think that such code never uses the TARGET_EXPR as
! an initializer. If I'm wrong, we'll die because the temp won't
have any RTL. In that case, I guess we'll need to replace
references somehow. */
tree init = TARGET_EXPR_INITIAL (*from_p);
*************** gimplify_expr (tree *expr_p, tree *pre_p
*** 4329,4335 ****
#endif
gcc_assert (fallback & fb_mayfail);
/* If this is an asm statement, and the user asked for the
! impossible, don't abort. Fail and let gimplify_asm_expr
issue an error. */
ret = GS_ERROR;
goto out;
--- 4329,4335 ----
#endif
gcc_assert (fallback & fb_mayfail);
/* If this is an asm statement, and the user asked for the
! impossible, don't die. Fail and let gimplify_asm_expr
issue an error. */
ret = GS_ERROR;
goto out;
Index: haifa-sched.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/haifa-sched.c,v
retrieving revision 1.253
diff -c -3 -p -r1.253 haifa-sched.c
*** haifa-sched.c 10 Feb 2005 18:59:05 -0000 1.253
--- haifa-sched.c 22 Apr 2005 13:26:19 -0000
*************** queue_insn (rtx insn, int n_cycles)
*** 753,760 ****
HAIFA_INLINE static rtx *
ready_lastpos (struct ready_list *ready)
{
! if (ready->n_ready == 0)
! abort ();
return ready->vec + ready->first - ready->n_ready + 1;
}
--- 753,759 ----
HAIFA_INLINE static rtx *
ready_lastpos (struct ready_list *ready)
{
! gcc_assert (ready->n_ready);
return ready->vec + ready->first - ready->n_ready + 1;
}
*************** HAIFA_INLINE static rtx
*** 782,789 ****
ready_remove_first (struct ready_list *ready)
{
rtx t;
! if (ready->n_ready == 0)
! abort ();
t = ready->vec[ready->first--];
ready->n_ready--;
/* If the queue becomes empty, reset it. */
--- 781,788 ----
ready_remove_first (struct ready_list *ready)
{
rtx t;
!
! gcc_assert (ready->n_ready);
t = ready->vec[ready->first--];
ready->n_ready--;
/* If the queue becomes empty, reset it. */
*************** ready_remove_first (struct ready_list *r
*** 803,812 ****
HAIFA_INLINE static rtx
ready_element (struct ready_list *ready, int index)
{
! #ifdef ENABLE_CHECKING
! if (ready->n_ready == 0 || index >= ready->n_ready)
! abort ();
! #endif
return ready->vec[ready->first - index];
}
--- 802,809 ----
HAIFA_INLINE static rtx
ready_element (struct ready_list *ready, int index)
{
! gcc_assert (ready->n_ready && index < ready->n_ready);
!
return ready->vec[ready->first - index];
}
*************** ready_remove (struct ready_list *ready,
*** 822,829 ****
if (index == 0)
return ready_remove_first (ready);
! if (ready->n_ready == 0 || index >= ready->n_ready)
! abort ();
t = ready->vec[ready->first - index];
ready->n_ready--;
for (i = index; i < ready->n_ready; i++)
--- 819,825 ----
if (index == 0)
return ready_remove_first (ready);
! gcc_assert (ready->n_ready && index < ready->n_ready);
t = ready->vec[ready->first - index];
ready->n_ready--;
for (i = index; i < ready->n_ready; i++)
*************** rm_line_notes (rtx head, rtx tail)
*** 1105,1116 ****
prev = insn;
insn = unlink_line_notes (insn, next_tail);
! if (prev == tail)
! abort ();
! if (prev == head)
! abort ();
! if (insn == next_tail)
! abort ();
}
}
}
--- 1101,1107 ----
prev = insn;
insn = unlink_line_notes (insn, next_tail);
! gcc_assert (prev != tail && prev != head && insn != next_tail);
}
}
}
*************** rm_other_notes (rtx head, rtx tail)
*** 1289,1300 ****
insn = unlink_other_notes (insn, next_tail);
! if (prev == tail)
! abort ();
! if (prev == head)
! abort ();
! if (insn == next_tail)
! abort ();
}
}
}
--- 1280,1286 ----
insn = unlink_other_notes (insn, next_tail);
! gcc_assert (prev != tail && prev != head && insn != next_tail);
}
}
}
*************** schedule_block (int b, int rgn_n_insns)
*** 1868,1885 ****
and caused problems because schedule_block and compute_forward_dependences
had different notions of what the "head" insn was. */
! if (head == tail && (! INSN_P (head)))
! abort ();
/* Debug info. */
if (sched_verbose)
{
! fprintf (sched_dump, ";; ======================================================\n");
fprintf (sched_dump,
";; -- basic block %d from %d to %d -- %s reload\n",
b, INSN_UID (head), INSN_UID (tail),
(reload_completed ? "after" : "before"));
! fprintf (sched_dump, ";; ======================================================\n");
fprintf (sched_dump, "\n");
}
--- 1854,1872 ----
and caused problems because schedule_block and compute_forward_dependences
had different notions of what the "head" insn was. */
! gcc_assert (head != tail || INSN_P (head));
/* Debug info. */
if (sched_verbose)
{
! fprintf (sched_dump,
! ";; ======================================================\n");
fprintf (sched_dump,
";; -- basic block %d from %d to %d -- %s reload\n",
b, INSN_UID (head), INSN_UID (tail),
(reload_completed ? "after" : "before"));
! fprintf (sched_dump,
! ";; ======================================================\n");
fprintf (sched_dump, "\n");
}
*************** schedule_block (int b, int rgn_n_insns)
*** 1938,1945 ****
list. */
queue_to_ready (&ready);
! if (ready.n_ready == 0)
! abort ();
if (sched_verbose >= 2)
{
--- 1925,1931 ----
list. */
queue_to_ready (&ready);
! gcc_assert (ready.n_ready);
if (sched_verbose >= 2)
{
*************** schedule_block (int b, int rgn_n_insns)
*** 2122,2129 ****
/* Sanity check -- queue must be empty now. Meaningless if region has
multiple bbs. */
! if (current_sched_info->queue_must_finish_empty && q_size != 0)
! abort ();
/* Update head/tail boundaries. */
head = NEXT_INSN (prev_head);
--- 2108,2114 ----
/* Sanity check -- queue must be empty now. Meaningless if region has
multiple bbs. */
! gcc_assert (!current_sched_info->queue_must_finish_empty || q_size);
/* Update head/tail boundaries. */
head = NEXT_INSN (prev_head);
Index: mips-tfile.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/mips-tfile.c,v
retrieving revision 1.66
diff -c -3 -p -r1.66 mips-tfile.c
*** mips-tfile.c 1 Apr 2005 03:42:44 -0000 1.66
--- mips-tfile.c 22 Apr 2005 13:26:30 -0000
*************** copy_object (void)
*** 4438,4444 ****
! /* Abort if the symbol table is not last. */
if (max_file_offset != (unsigned long) stat_buf.st_size)
fatal ("symbol table is not last (symbol table ends at %ld, .o ends at %ld",
max_file_offset,
--- 4438,4444 ----
! /* The symbol table should be last. */
if (max_file_offset != (unsigned long) stat_buf.st_size)
fatal ("symbol table is not last (symbol table ends at %ld, .o ends at %ld",
max_file_offset,
*************** pfatal_with_name (const char *msg)
*** 4940,4946 ****
}
! /* Procedure to abort with an out of bounds error message. It has
type int, so it can be used with an ?: expression within the
ORIG_xxx macros, but the function never returns. */
--- 4940,4946 ----
}
! /* Procedure to die with an out of bounds error message. It has
type int, so it can be used with an ?: expression within the
ORIG_xxx macros, but the function never returns. */