mirror/gcc
2
0
Fork 0
mirror of git://gcc.gnu.org/git/gcc.git synced 2025-03-22 15:00:55 +08:00
Code Issues Packages Projects Releases Wiki Activity

emit-rtl.c (immed_double_const): Use gcc_assert and gcc_unreachable.

Browse Source 
* emit-rtl.c (immed_double_const): Use gcc_assert and gcc_unreachable.
	(gen_rtx_SUBREG, gen_reg_rtx, mark_user_reg, subreg_hard_regno,
	gen_lowpart_common, gen_highpart, gen_highpart_mode,
	subreg_highpart_offset, operand_subword, operand_subword_force,
	mem_expr_equal_p, set_mem_attributes_minus_bitpos,
	set_mem_alias_set, change_address_1, verify_rtx_sharing,
	copy_most_rtx, set_first_insn, set_last_insn, prev_cc0_setter,
	try_split, add_insn_after, add_insn_before, remove_insn,
	remove_unnecessary_notes, emit_insn_before, emit_jump_insn_before,
	emit_call_insn_before, emit_insn_after, emit_jump_insn_after,
	emit_call_insn_after, emit_insn, emit_jump_insn, emit_call_insn,
	set_unique_reg_note, emit, push_to_full_sequence, copy_insn_1,
	gen_const_vector_0, emit_copy_of_insn_after): Likewise.
	* et-forest.c (set_prev, set_next, et_check_occ_sanity,
	record_path_before_1, check_path_after_1, check_path_after): Likewise.
	* except.c (gen_eh_region, resolve_one_fixup_region,
	remove_unreachable_regions, convert_from_eh_region_ranges_1,
	add_ehl_entry, duplicate_eh_region_1, build_post_landing_pads,
	connect_post_landing_pads, sjlj_emit_function_exit,
	remove_exception_handler_label, remove_eh_handler,
	reachable_next_level, collect_one_action_chain,
	output_function_exception_table): Likewise.
	* explow.c (trunc_int_for_mode, copy_to_mode_reg,
	optimize_save_area_alloca, allocate_dynamic_stack_space,
	probe_stack_range, hard_function_value): Likewise.
	* expmed.c (mode_for_extraction, store_bit_field,
	store_fixed_bit_field, extract_bit_field, expand_shift,
	expand_mult_const, expand_mult, choose_multiplier,
	expand_mult_highpart, expand_divmod, emit_store_flag,
	do_cmp_and_jump): Likewise.
	* expr.c (convert_move, convert_modes, move_by_pieces,
	move_by_pieces_ninsns, move_by_pieces_1, emit_block_move,
	move_block_from_reg, gen_group_rtx, emit_group_load,
	emit_group_move, emit_group_store, use_reg, use_regs,
	can_store_by_pieces, store_by_pieces, store_by_pieces_1,
	emit_move_insn, emit_move_insn_1, emit_push_insn,
	expand_assignment, store_expr, count_type_elements,
	store_constructor, store_field, safe_from_p, expand_var,
	expand_expr_addr_expr, expand_expr_real_1, do_store_flag): Likewise.

From-SVN: r87178
This commit is contained in:
Nathan Sidwell 2004-09-08 08:05:14 +00:00
parent ced3f397be
commit 5b0264cb4d
7 changed files with 1092 additions and 1210 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

44
gcc/ChangeLog
View File

@ -1,3 +1,45 @@
2004-09-08 Nathan Sidwell <nathan@codesourcery.com>
* emit-rtl.c (immed_double_const): Use gcc_assert and gcc_unreachable.
(gen_rtx_SUBREG, gen_reg_rtx, mark_user_reg, subreg_hard_regno,
gen_lowpart_common, gen_highpart, gen_highpart_mode,
subreg_highpart_offset, operand_subword, operand_subword_force,
mem_expr_equal_p, set_mem_attributes_minus_bitpos,
set_mem_alias_set, change_address_1, verify_rtx_sharing,
copy_most_rtx, set_first_insn, set_last_insn, prev_cc0_setter,
try_split, add_insn_after, add_insn_before, remove_insn,
remove_unnecessary_notes, emit_insn_before, emit_jump_insn_before,
emit_call_insn_before, emit_insn_after, emit_jump_insn_after,
emit_call_insn_after, emit_insn, emit_jump_insn, emit_call_insn,
set_unique_reg_note, emit, push_to_full_sequence, copy_insn_1,
gen_const_vector_0, emit_copy_of_insn_after): Likewise.
* et-forest.c (set_prev, set_next, et_check_occ_sanity,
record_path_before_1, check_path_after_1, check_path_after): Likewise.
* except.c (gen_eh_region, resolve_one_fixup_region,
remove_unreachable_regions, convert_from_eh_region_ranges_1,
add_ehl_entry, duplicate_eh_region_1, build_post_landing_pads,
connect_post_landing_pads, sjlj_emit_function_exit,
remove_exception_handler_label, remove_eh_handler,
reachable_next_level, collect_one_action_chain,
output_function_exception_table): Likewise.
* explow.c (trunc_int_for_mode, copy_to_mode_reg,
optimize_save_area_alloca, allocate_dynamic_stack_space,
probe_stack_range, hard_function_value): Likewise.
* expmed.c (mode_for_extraction, store_bit_field,
store_fixed_bit_field, extract_bit_field, expand_shift,
expand_mult_const, expand_mult, choose_multiplier,
expand_mult_highpart, expand_divmod, emit_store_flag,
do_cmp_and_jump): Likewise.
* expr.c (convert_move, convert_modes, move_by_pieces,
move_by_pieces_ninsns, move_by_pieces_1, emit_block_move,
move_block_from_reg, gen_group_rtx, emit_group_load,
emit_group_move, emit_group_store, use_reg, use_regs,
can_store_by_pieces, store_by_pieces, store_by_pieces_1,
emit_move_insn, emit_move_insn_1, emit_push_insn,
expand_assignment, store_expr, count_type_elements,
store_constructor, store_field, safe_from_p, expand_var,
expand_expr_addr_expr, expand_expr_real_1, do_store_flag): Likewise.
2004-09-08 Nathan Sidwell <nathan@codesourcery.com>
* dbxout.c (dbxout_type, dbxout_type_name, dbxout_symbol): Use
@ -6066,7 +6108,7 @@
* config/i386/xmmintrin.h: Include <mm_malloc.h>.
2004-08-03 H.J. Lu <hongjiu.lu@intel.com>
Tanguy Fautrà <tfautre@pandora.be>
Tanguy Fautrà <tfautre@pandora.be>
* config/i386/pmm_malloc.h: New file.

277
gcc/emit-rtl.c
View File

@ -456,12 +456,12 @@ immed_double_const (HOST_WIDE_INT i0, HOST_WIDE_INT i1, enum machine_mode mode)
if (mode != VOIDmode)
{
int width;
if (GET_MODE_CLASS (mode) != MODE_INT
&& GET_MODE_CLASS (mode) != MODE_PARTIAL_INT
/* We can get a 0 for an error mark. */
&& GET_MODE_CLASS (mode) != MODE_VECTOR_INT
&& GET_MODE_CLASS (mode) != MODE_VECTOR_FLOAT)
abort ();
gcc_assert (GET_MODE_CLASS (mode) == MODE_INT
|| GET_MODE_CLASS (mode) == MODE_PARTIAL_INT
/* We can get a 0 for an error mark. */
|| GET_MODE_CLASS (mode) == MODE_VECTOR_INT
|| GET_MODE_CLASS (mode) == MODE_VECTOR_FLOAT);
/* We clear out all bits that don't belong in MODE, unless they and
our sign bit are all one. So we get either a reasonable negative
@ -474,9 +474,9 @@ immed_double_const (HOST_WIDE_INT i0, HOST_WIDE_INT i1, enum machine_mode mode)
else if (width == HOST_BITS_PER_WIDE_INT
&& ! (i1 == ~0 && i0 < 0))
i1 = 0;
else if (width > 2 * HOST_BITS_PER_WIDE_INT)
/* We cannot represent this value as a constant. */
abort ();
else
/* We should be able to represent this value as a constant. */
gcc_assert (width <= 2 * HOST_BITS_PER_WIDE_INT);
/* If this would be an entire word for the target, but is not for
the host, then sign-extend on the host so that the number will
@ -623,16 +623,14 @@ gen_rtx_SUBREG (enum machine_mode mode, rtx reg, int offset)
{
/* This is the most common failure type.
Catch it early so we can see who does it. */
if ((offset % GET_MODE_SIZE (mode)) != 0)
abort ();
gcc_assert (!(offset % GET_MODE_SIZE (mode)));
/* This check isn't usable right now because combine will
throw arbitrary crap like a CALL into a SUBREG in
gen_lowpart_for_combine so we must just eat it. */
#if 0
/* Check for this too. */
if (offset >= GET_MODE_SIZE (GET_MODE (reg)))
abort ();
gcc_assert (offset < GET_MODE_SIZE (GET_MODE (reg)));
#endif
return gen_rtx_raw_SUBREG (mode, reg, offset);
}
@ -711,8 +709,7 @@ gen_reg_rtx (enum machine_mode mode)
/* Don't let anything called after initial flow analysis create new
registers. */
if (no_new_pseudos)
abort ();
gcc_assert (!no_new_pseudos);
if (generating_concat_p
&& (GET_MODE_CLASS (mode) == MODE_COMPLEX_FLOAT
@ -972,10 +969,11 @@ mark_user_reg (rtx reg)
REG_USERVAR_P (XEXP (reg, 0)) = 1;
REG_USERVAR_P (XEXP (reg, 1)) = 1;
}
else if (REG_P (reg))
REG_USERVAR_P (reg) = 1;
else
abort ();
{
gcc_assert (REG_P (reg));
REG_USERVAR_P (reg) = 1;
}
}
/* Identify REG as a probable pointer register and show its alignment
@ -1044,23 +1042,17 @@ subreg_hard_regno (rtx x, int check_mode)
/* This is where we attempt to catch illegal subregs
created by the compiler. */
if (GET_CODE (x) != SUBREG
|| !REG_P (reg))
abort ();
gcc_assert (GET_CODE (x) == SUBREG && REG_P (reg));
base_regno = REGNO (reg);
if (base_regno >= FIRST_PSEUDO_REGISTER)
abort ();
if (check_mode && ! HARD_REGNO_MODE_OK (base_regno, GET_MODE (reg)))
abort ();
gcc_assert (base_regno < FIRST_PSEUDO_REGISTER);
gcc_assert (!check_mode || HARD_REGNO_MODE_OK (base_regno, GET_MODE (reg)));
#ifdef ENABLE_CHECKING
if (!subreg_offset_representable_p (REGNO (reg), GET_MODE (reg),
SUBREG_BYTE (x), mode))
abort ();
gcc_assert (subreg_offset_representable_p (REGNO (reg), GET_MODE (reg),
SUBREG_BYTE (x), mode));
#endif
/* Catch non-congruent offsets too. */
byte_offset = SUBREG_BYTE (x);
if ((byte_offset % GET_MODE_SIZE (mode)) != 0)
abort ();
gcc_assert (!(byte_offset % GET_MODE_SIZE (mode)));
final_regno = subreg_regno (x);
@ -1096,8 +1088,7 @@ gen_lowpart_common (enum machine_mode mode, rtx x)
xsize = GET_MODE_SIZE (innermode);
if (innermode == VOIDmode || innermode == BLKmode)
abort ();
gcc_assert (innermode != VOIDmode && innermode != BLKmode);
if (innermode == mode)
return x;
@ -1224,21 +1215,22 @@ gen_highpart (enum machine_mode mode, rtx x)
/* This case loses if X is a subreg. To catch bugs early,
complain if an invalid MODE is used even in other cases. */
if (msize > UNITS_PER_WORD
&& msize != (unsigned int) GET_MODE_UNIT_SIZE (GET_MODE (x)))
abort ();
gcc_assert (msize <= UNITS_PER_WORD
|| msize == (unsigned int) GET_MODE_UNIT_SIZE (GET_MODE (x)));
result = simplify_gen_subreg (mode, x, GET_MODE (x),
subreg_highpart_offset (mode, GET_MODE (x)));
gcc_assert (result);
/* simplify_gen_subreg is not guaranteed to return a valid operand for
the target if we have a MEM. gen_highpart must return a valid operand,
emitting code if necessary to do so. */
if (result != NULL_RTX && MEM_P (result))
result = validize_mem (result);
if (!result)
abort ();
if (MEM_P (result))
{
result = validize_mem (result);
gcc_assert (result);
}
return result;
}
@ -1249,8 +1241,7 @@ gen_highpart_mode (enum machine_mode outermode, enum machine_mode innermode, rtx
{
if (GET_MODE (exp) != VOIDmode)
{
if (GET_MODE (exp) != innermode)
abort ();
gcc_assert (GET_MODE (exp) == innermode);
return gen_highpart (outermode, exp);
}
return simplify_gen_subreg (outermode, exp, innermode,
@ -1285,8 +1276,7 @@ subreg_highpart_offset (enum machine_mode outermode, enum machine_mode innermode
unsigned int offset = 0;
int difference = (GET_MODE_SIZE (innermode) - GET_MODE_SIZE (outermode));
if (GET_MODE_SIZE (innermode) < GET_MODE_SIZE (outermode))
abort ();
gcc_assert (GET_MODE_SIZE (innermode) >= GET_MODE_SIZE (outermode));
if (difference > 0)
{
@ -1346,8 +1336,7 @@ operand_subword (rtx op, unsigned int offset, int validate_address, enum machine
if (mode == VOIDmode)
mode = GET_MODE (op);
if (mode == VOIDmode)
abort ();
gcc_assert (mode != VOIDmode);
/* If OP is narrower than a word, fail. */
if (mode != BLKmode
@ -1405,8 +1394,7 @@ operand_subword_force (rtx op, unsigned int offset, enum machine_mode mode)
}
result = operand_subword (op, offset, 1, mode);
if (result == 0)
abort ();
gcc_assert (result);
return result;
}
@ -1500,13 +1488,13 @@ mem_expr_equal_p (tree expr1, tree expr2)
if (TREE_CODE (expr1) == INDIRECT_REF)
return mem_expr_equal_p (TREE_OPERAND (expr1, 0),
TREE_OPERAND (expr2, 0));
/* ARRAY_REFs, ARRAY_RANGE_REFs and BIT_FIELD_REFs should already
have been resolved here. */
gcc_assert (DECL_P (expr1));
/* Decls with different pointers can't be equal. */
if (DECL_P (expr1))
return 0;
abort(); /* ARRAY_REFs, ARRAY_RANGE_REFs and BIT_FIELD_REFs should already
have been resolved here. */
return 0;
}
/* Given REF, a MEM, and T, either the type of X or the expression
@ -1540,8 +1528,7 @@ set_mem_attributes_minus_bitpos (rtx ref, tree t, int objectp,
wrong answer, as it assumes that DECL_RTL already has the right alias
info. Callers should not set DECL_RTL until after the call to
set_mem_attributes. */
if (DECL_P (t) && ref == DECL_RTL_IF_SET (t))
abort ();
gcc_assert (!DECL_P (t) || ref != DECL_RTL_IF_SET (t));
/* Get the alias set from the expression or type (perhaps using a
front-end routine) and use it. */
@ -1754,8 +1741,7 @@ set_mem_alias_set (rtx mem, HOST_WIDE_INT set)
{
#ifdef ENABLE_CHECKING
/* If the new and old alias sets don't conflict, something is wrong. */
if (!alias_sets_conflict_p (set, MEM_ALIAS_SET (mem)))
abort ();
gcc_assert (alias_sets_conflict_p (set, MEM_ALIAS_SET (mem)));
#endif
MEM_ATTRS (mem) = get_mem_attrs (set, MEM_EXPR (mem), MEM_OFFSET (mem),
@ -1814,8 +1800,7 @@ change_address_1 (rtx memref, enum machine_mode mode, rtx addr, int validate)
{
rtx new;
if (!MEM_P (memref))
abort ();
gcc_assert (MEM_P (memref));
if (mode == VOIDmode)
mode = GET_MODE (memref);
if (addr == 0)
@ -1827,10 +1812,7 @@ change_address_1 (rtx memref, enum machine_mode mode, rtx addr, int validate)
if (validate)
{
if (reload_in_progress || reload_completed)
{
if (! memory_address_p (mode, addr))
abort ();
}
gcc_assert (memory_address_p (mode, addr));
else
addr = memory_address (mode, addr);
}
@ -2285,7 +2267,7 @@ verify_rtx_sharing (rtx orig, rtx insn)
debug_rtx (insn);
error ("Shared rtx");
debug_rtx (x);
abort ();
fatal_error ("Internal consistency failure");
}
RTX_FLAG (x, used) = 1;
@ -2490,7 +2472,7 @@ copy_most_rtx (rtx orig, rtx may_share)
break;
default:
abort ();
gcc_unreachable ();
}
}
return copy;
@ -2822,8 +2804,7 @@ get_insns (void)
void
set_first_insn (rtx insn)
{
if (PREV_INSN (insn) != 0)
abort ();
gcc_assert (!PREV_INSN (insn));
first_insn = insn;
}
@ -2840,8 +2821,7 @@ get_last_insn (void)
void
set_last_insn (rtx insn)
{
if (NEXT_INSN (insn) != 0)
abort ();
gcc_assert (!NEXT_INSN (insn));
last_insn = insn;
}
@ -3191,8 +3171,7 @@ prev_cc0_setter (rtx insn)
return XEXP (note, 0);
insn = prev_nonnote_insn (insn);
if (! sets_cc0_p (PATTERN (insn)))
abort ();
gcc_assert (sets_cc0_p (PATTERN (insn)));
return insn;
}
@ -3292,8 +3271,7 @@ try_split (rtx pat, rtx trial, int last)
one jump is created, otherwise the machine description
is responsible for this step using
split_branch_probability variable. */
if (njumps != 1)
abort ();
gcc_assert (njumps == 1);
REG_NOTES (insn)
= gen_rtx_EXPR_LIST (REG_BR_PROB,
GEN_INT (probability),
@ -3510,8 +3488,7 @@ add_insn_after (rtx insn, rtx after)
rtx next = NEXT_INSN (after);
basic_block bb;
if (optimize && INSN_DELETED_P (after))
abort ();
gcc_assert (!optimize || !INSN_DELETED_P (after));
NEXT_INSN (insn) = next;
PREV_INSN (insn) = after;
@ -3535,8 +3512,7 @@ add_insn_after (rtx insn, rtx after)
break;
}
if (stack == 0)
abort ();
gcc_assert (stack);
}
if (!BARRIER_P (after)
@ -3575,8 +3551,7 @@ add_insn_before (rtx insn, rtx before)
rtx prev = PREV_INSN (before);
basic_block bb;
if (optimize && INSN_DELETED_P (before))
abort ();
gcc_assert (!optimize || !INSN_DELETED_P (before));
PREV_INSN (insn) = prev;
NEXT_INSN (insn) = before;
@ -3603,8 +3578,7 @@ add_insn_before (rtx insn, rtx before)
break;
}
if (stack == 0)
abort ();
gcc_assert (stack);
}
if (!BARRIER_P (before)
@ -3614,14 +3588,13 @@ add_insn_before (rtx insn, rtx before)
set_block_for_insn (insn, bb);
if (INSN_P (insn))
bb->flags |= BB_DIRTY;
/* Should not happen as first in the BB is always
either NOTE or LABEl. */
if (BB_HEAD (bb) == insn
/* Avoid clobbering of structure when creating new BB. */
&& !BARRIER_P (insn)
&& (!NOTE_P (insn)
|| NOTE_LINE_NUMBER (insn) != NOTE_INSN_BASIC_BLOCK))
abort ();
/* Should not happen as first in the BB is always either NOTE or
LABEl. */
gcc_assert (BB_HEAD (bb) != insn
/* Avoid clobbering of structure when creating new BB. */
|| BARRIER_P (insn)
|| (NOTE_P (insn)
&& NOTE_LINE_NUMBER (insn) == NOTE_INSN_BASIC_BLOCK));
}
PREV_INSN (before) = insn;
@ -3660,8 +3633,7 @@ remove_insn (rtx insn)
break;
}
if (stack == 0)
abort ();
gcc_assert (stack);
}
if (next)
@ -3683,8 +3655,7 @@ remove_insn (rtx insn)
break;
}
if (stack == 0)
abort ();
gcc_assert (stack);
}
if (!BARRIER_P (insn)
&& (bb = BLOCK_FOR_INSN (insn)))
@ -3695,8 +3666,7 @@ remove_insn (rtx insn)
{
/* Never ever delete the basic block note without deleting whole
basic block. */
if (NOTE_P (insn))
abort ();
gcc_assert (!NOTE_P (insn));
BB_HEAD (bb) = next;
}
if (BB_END (bb) == insn)
@ -3709,8 +3679,7 @@ remove_insn (rtx insn)
void
add_function_usage_to (rtx call_insn, rtx call_fusage)
{
if (! call_insn || !CALL_P (call_insn))
abort ();
gcc_assert (call_insn && CALL_P (call_insn));
/* Put the register usage information on the CALL. If there is already
some usage information, put ours at the end. */
@ -3857,11 +3826,10 @@ remove_unnecessary_notes (void)
case NOTE_INSN_EH_REGION_END:
/* Too many end notes. */
if (eh_stack == NULL_RTX)
abort ();
gcc_assert (eh_stack);
/* Mismatched nesting. */
if (NOTE_EH_HANDLER (XEXP (eh_stack, 0)) != NOTE_EH_HANDLER (insn))
abort ();
gcc_assert (NOTE_EH_HANDLER (XEXP (eh_stack, 0))
== NOTE_EH_HANDLER (insn));
tmp = eh_stack;
eh_stack = XEXP (eh_stack, 1);
free_INSN_LIST_node (tmp);
@ -3870,18 +3838,15 @@ remove_unnecessary_notes (void)
case NOTE_INSN_BLOCK_BEG:
/* By now, all notes indicating lexical blocks should have
NOTE_BLOCK filled in. */
if (NOTE_BLOCK (insn) == NULL_TREE)
abort ();
gcc_assert (NOTE_BLOCK (insn));
block_stack = alloc_INSN_LIST (insn, block_stack);
break;
case NOTE_INSN_BLOCK_END:
/* Too many end notes. */
if (block_stack == NULL_RTX)
abort ();
gcc_assert (block_stack);
/* Mismatched nesting. */
if (NOTE_BLOCK (XEXP (block_stack, 0)) != NOTE_BLOCK (insn))
abort ();
gcc_assert (NOTE_BLOCK (XEXP (block_stack, 0)) == NOTE_BLOCK (insn));
tmp = block_stack;
block_stack = XEXP (block_stack, 1);
free_INSN_LIST_node (tmp);
@ -3930,8 +3895,7 @@ remove_unnecessary_notes (void)
}
/* Too many begin notes. */
if (block_stack || eh_stack)
abort ();
gcc_assert (!block_stack && !eh_stack);
}
@ -3968,10 +3932,7 @@ emit_insn_before (rtx x, rtx before)
rtx last = before;
rtx insn;
#ifdef ENABLE_RTL_CHECKING
if (before == NULL_RTX)
abort ();
#endif
gcc_assert (before);
if (x == NULL_RTX)
return last;
@ -3996,7 +3957,7 @@ emit_insn_before (rtx x, rtx before)
#ifdef ENABLE_RTL_CHECKING
case SEQUENCE:
abort ();
gcc_unreachable ();
break;
#endif
@ -4017,10 +3978,7 @@ emit_jump_insn_before (rtx x, rtx before)
{
rtx insn, last = NULL_RTX;
#ifdef ENABLE_RTL_CHECKING
if (before == NULL_RTX)
abort ();
#endif
gcc_assert (before);
switch (GET_CODE (x))
{
@ -4042,7 +4000,7 @@ emit_jump_insn_before (rtx x, rtx before)
#ifdef ENABLE_RTL_CHECKING
case SEQUENCE:
abort ();
gcc_unreachable ();
break;
#endif
@ -4063,10 +4021,7 @@ emit_call_insn_before (rtx x, rtx before)
{
rtx last = NULL_RTX, insn;
#ifdef ENABLE_RTL_CHECKING
if (before == NULL_RTX)
abort ();
#endif
gcc_assert (before);
switch (GET_CODE (x))
{
@ -4088,7 +4043,7 @@ emit_call_insn_before (rtx x, rtx before)
#ifdef ENABLE_RTL_CHECKING
case SEQUENCE:
abort ();
gcc_unreachable ();
break;
#endif
@ -4196,10 +4151,7 @@ emit_insn_after (rtx x, rtx after)
{
rtx last = after;
#ifdef ENABLE_RTL_CHECKING
if (after == NULL_RTX)
abort ();
#endif
gcc_assert (after);
if (x == NULL_RTX)
return last;
@ -4217,7 +4169,7 @@ emit_insn_after (rtx x, rtx after)
#ifdef ENABLE_RTL_CHECKING
case SEQUENCE:
abort ();
gcc_unreachable ();
break;
#endif
@ -4255,10 +4207,7 @@ emit_jump_insn_after (rtx x, rtx after)
{
rtx last;
#ifdef ENABLE_RTL_CHECKING
if (after == NULL_RTX)
abort ();
#endif
gcc_assert (after);
switch (GET_CODE (x))
{
@ -4273,7 +4222,7 @@ emit_jump_insn_after (rtx x, rtx after)
#ifdef ENABLE_RTL_CHECKING
case SEQUENCE:
abort ();
gcc_unreachable ();
break;
#endif
@ -4294,10 +4243,7 @@ emit_call_insn_after (rtx x, rtx after)
{
rtx last;
#ifdef ENABLE_RTL_CHECKING
if (after == NULL_RTX)
abort ();
#endif
gcc_assert (after);
switch (GET_CODE (x))
{
@ -4312,7 +4258,7 @@ emit_call_insn_after (rtx x, rtx after)
#ifdef ENABLE_RTL_CHECKING
case SEQUENCE:
abort ();
gcc_unreachable ();
break;
#endif
@ -4513,7 +4459,7 @@ emit_insn (rtx x)
#ifdef ENABLE_RTL_CHECKING
case SEQUENCE:
abort ();
gcc_unreachable ();
break;
#endif
@ -4554,7 +4500,7 @@ emit_jump_insn (rtx x)
#ifdef ENABLE_RTL_CHECKING
case SEQUENCE:
abort ();
gcc_unreachable ();
break;
#endif
@ -4588,7 +4534,7 @@ emit_call_insn (rtx x)
#ifdef ENABLE_RTL_CHECKING
case SEQUENCE:
abort ();
gcc_unreachable ();
break;
#endif
@ -4737,8 +4683,7 @@ set_unique_reg_note (rtx insn, enum reg_note kind, rtx datum)
means the insn only has one * useful * set). */
if (GET_CODE (PATTERN (insn)) == PARALLEL && multiple_sets (insn))
{
if (note)
abort ();
gcc_assert (!note);
return NULL_RTX;
}
@ -4807,21 +4752,24 @@ emit (rtx x)
{
enum rtx_code code = classify_insn (x);
if (code == CODE_LABEL)
return emit_label (x);
else if (code == INSN)
return emit_insn (x);
else if (code == JUMP_INSN)
switch (code)
{
rtx insn = emit_jump_insn (x);
if (any_uncondjump_p (insn) || GET_CODE (x) == RETURN)
return emit_barrier ();
return insn;
case CODE_LABEL:
return emit_label (x);
case INSN:
return emit_insn (x);
case JUMP_INSN:
{
rtx insn = emit_jump_insn (x);
if (any_uncondjump_p (insn) || GET_CODE (x) == RETURN)
return emit_barrier ();
return insn;
}
case CALL_INSN:
return emit_call_insn (x);
default:
gcc_unreachable ();
}
else if (code == CALL_INSN)
return emit_call_insn (x);
else
abort ();
}
/* Space for free sequence stack entries. */
@ -4883,8 +4831,7 @@ push_to_full_sequence (rtx first, rtx last)
first_insn = first;
last_insn = last;
/* We really should have the end of the insn chain here. */
if (last && NEXT_INSN (last))
abort ();
gcc_assert (!last || !NEXT_INSN (last));
}
/* Set up the outer-level insn chain
@ -5104,15 +5051,14 @@ copy_insn_1 (rtx orig)
break;
default:
abort ();
gcc_unreachable ();
}
}
if (code == SCRATCH)
{
i = copy_insn_n_scratches++;
if (i >= MAX_RECOG_OPERANDS)
abort ();
gcc_assert (i < MAX_RECOG_OPERANDS);
copy_insn_scratch_in[i] = orig;
copy_insn_scratch_out[i] = copy;
}
@ -5227,8 +5173,7 @@ gen_const_vector_0 (enum machine_mode mode)
v = rtvec_alloc (units);
/* We need to call this function after we to set CONST0_RTX first. */
if (!CONST0_RTX (inner))
abort ();
gcc_assert (CONST0_RTX (inner));
for (i = 0; i < units; ++i)
RTVEC_ELT (v, i) = CONST0_RTX (inner);
@ -5477,7 +5422,7 @@ emit_copy_of_insn_after (rtx insn, rtx after)
break;
default:
abort ();
gcc_unreachable ();
}
/* Update LABEL_NUSES. */

58
gcc/et-forest.c
View File

@ -88,8 +88,7 @@ static inline void
set_prev (struct et_occ *occ, struct et_occ *t)
{
#ifdef DEBUG_ET
if (occ == t)
abort ();
gcc_assert (occ != t);
#endif
occ->prev = t;
@ -103,8 +102,7 @@ static inline void
set_next (struct et_occ *occ, struct et_occ *t)
{
#ifdef DEBUG_ET
if (occ == t)
abort ();
gcc_assert (occ != t);
#endif
occ->next = t;
@ -145,40 +143,26 @@ et_check_occ_sanity (struct et_occ *occ)
if (!occ)
return;
if (occ->parent == occ)
abort ();
if (occ->prev == occ)
abort ();
if (occ->next == occ)
abort ();
if (occ->next && occ->next == occ->prev)
abort ();
gcc_assert (occ->parent != occ);
gcc_assert (occ->prev != occ);
gcc_assert (occ->next != occ);
gcc_assert (!occ->next || occ->next != occ->prev);
if (occ->next)
{
if (occ->next == occ->parent)
abort ();
if (occ->next->parent != occ)
abort ();
gcc_assert (occ->next != occ->parent);
gcc_assert (occ->next->parent == occ);
}
if (occ->prev)
{
if (occ->prev == occ->parent)
abort ();
if (occ->prev->parent != occ)
abort ();
gcc_assert (occ->prev != occ->parent);
gcc_assert (occ->prev->parent == occ);
}
if (occ->parent
&& occ->parent->prev != occ
&& occ->parent->next != occ)
abort ();
gcc_assert (!occ->parent
|| occ->parent->prev == occ
|| occ->parent->next == occ);
}
/* Checks whether tree rooted at OCC is sane. */
@ -233,8 +217,7 @@ record_path_before_1 (struct et_occ *occ, int depth)
fprintf (stderr, "%d (%d); ", ((basic_block) occ->of->data)->index, depth);
if (len >= MAX_NODES)
abort ();
gcc_assert (len < MAX_NODES);
depths[len] = depth;
datas[len] = occ->of;
@ -247,8 +230,7 @@ record_path_before_1 (struct et_occ *occ, int depth)
mn = m;
}
if (mn != occ->min + depth - occ->depth)
abort ();
gcc_assert (mn == occ->min + depth - occ->depth);
return mn;
}
@ -285,9 +267,7 @@ check_path_after_1 (struct et_occ *occ, int depth)
}
len--;
if (depths[len] != depth
|| datas[len] != occ->of)
abort ();
gcc_assert (depths[len] == depth && datas[len] == occ->of);
if (occ->prev)
{
@ -296,8 +276,7 @@ check_path_after_1 (struct et_occ *occ, int depth)
mn = m;
}
if (mn != occ->min + depth - occ->depth)
abort ();
gcc_assert (mn == occ->min + depth - occ->depth);
return mn;
}
@ -312,8 +291,7 @@ check_path_after (struct et_occ *occ)
occ = occ->parent;
check_path_after_1 (occ, 0);
if (len != 0)
abort ();
gcc_assert (!len);
}
#endif

48
gcc/except.c
View File

@ -460,8 +460,7 @@ gen_eh_region (enum eh_region_type type, struct eh_region *outer)
struct eh_region *new;
#ifdef ENABLE_CHECKING
if (! doing_eh (0))
abort ();
gcc_assert (doing_eh (0));
#endif
/* Insert a new blank region as a leaf in the tree. */
@ -688,8 +687,7 @@ resolve_one_fixup_region (struct eh_region *fixup)
&& cleanup->u.cleanup.exp == fixup->u.fixup.cleanup_exp)
break;
}
if (j > n)
abort ();
gcc_assert (j <= n);
real = cleanup->outer;
if (real && real->type == ERT_FIXUP)
@ -811,14 +809,12 @@ remove_unreachable_regions (rtx insns)
if (r->resume)
{
if (uid_region_num[INSN_UID (r->resume)])
abort ();
gcc_assert (!uid_region_num[INSN_UID (r->resume)]);
uid_region_num[INSN_UID (r->resume)] = i;
}
if (r->label)
{
if (uid_region_num[INSN_UID (r->label)])
abort ();
gcc_assert (!uid_region_num[INSN_UID (r->label)]);
uid_region_num[INSN_UID (r->label)] = i;
}
}
@ -942,8 +938,7 @@ convert_from_eh_region_ranges_1 (rtx *pinsns, int *orig_sp, int cur)
}
}
if (sp != orig_sp)
abort ();
gcc_assert (sp == orig_sp);
}
static void
@ -1006,8 +1001,7 @@ add_ehl_entry (rtx label, struct eh_region *region)
label. After landing pad creation, the exception handlers may
share landing pads. This is ok, since maybe_remove_eh_handler
only requires the 1-1 mapping before landing pad creation. */
if (*slot && !cfun->eh->built_landing_pads)
abort ();
gcc_assert (!*slot || cfun->eh->built_landing_pads);
*slot = entry;
}
@ -1104,7 +1098,7 @@ duplicate_eh_region_1 (struct eh_region *o, struct inline_remap *map)
n->u.throw.type = o->u.throw.type;
default:
abort ();
gcc_unreachable ();
}
if (o->label)
@ -1112,8 +1106,7 @@ duplicate_eh_region_1 (struct eh_region *o, struct inline_remap *map)
if (o->resume)
{
n->resume = map->insn_map[INSN_UID (o->resume)];
if (n->resume == NULL)
abort ();
gcc_assert (n->resume);
}
return n;
@ -1586,7 +1579,7 @@ build_post_landing_pads (void)
break;
default:
abort ();
gcc_unreachable ();
}
}
}
@ -1657,8 +1650,7 @@ connect_post_landing_pads (void)
end_sequence ();
barrier = emit_insn_before (seq, region->resume);
/* Avoid duplicate barrier. */
if (!BARRIER_P (barrier))
abort ();
gcc_assert (BARRIER_P (barrier));
delete_insn (barrier);
delete_insn (region->resume);
@ -2049,8 +2041,7 @@ sjlj_emit_function_exit (void)
/* Figure out whether the place we are supposed to insert libcall
is inside the last basic block or after it. In the other case
we need to emit to edge. */
if (e->src->next_bb != EXIT_BLOCK_PTR)
abort ();
gcc_assert (e->src->next_bb == EXIT_BLOCK_PTR);
for (insn = NEXT_INSN (BB_END (e->src)); insn; insn = NEXT_INSN (insn))
if (insn == cfun->eh->sjlj_exit_after)
break;
@ -2258,8 +2249,7 @@ remove_exception_handler_label (rtx label)
tmp.label = label;
slot = (struct ehl_map_entry **)
htab_find_slot (cfun->eh->exception_handler_label_map, &tmp, NO_INSERT);
if (! slot)
abort ();
gcc_assert (slot);
htab_clear_slot (cfun->eh->exception_handler_label_map, (void **) slot);
}
@ -2330,8 +2320,7 @@ remove_eh_handler (struct eh_region *region)
try->type == ERT_CATCH;
try = try->next_peer)
continue;
if (try->type != ERT_TRY)
abort ();
gcc_assert (try->type == ERT_TRY);
next = region->u.catch.next_catch;
prev = region->u.catch.prev_catch;
@ -2642,10 +2631,11 @@ reachable_next_level (struct eh_region *region, tree type_thrown,
case ERT_FIXUP:
case ERT_UNKNOWN:
/* Shouldn't see these here. */
gcc_unreachable ();
break;
default:
gcc_unreachable ();
}
abort ();
}
/* Invoke CALLBACK on each region reachable from REGION_NUMBER. */
@ -3259,7 +3249,7 @@ collect_one_action_chain (htab_t ar_hash, struct eh_region *region)
return collect_one_action_chain (ar_hash, region->outer);
default:
abort ();
gcc_unreachable ();
}
}
@ -3763,8 +3753,8 @@ output_function_exception_table (void)
cgraph_varpool_mark_needed_node (node);
}
}
else if (TREE_CODE (type) != INTEGER_CST)
abort ();
else
gcc_assert (TREE_CODE (type) == INTEGER_CST);
}
if (tt_format == DW_EH_PE_absptr || tt_format == DW_EH_PE_aligned)

31
gcc/explow.c
View File

@ -50,8 +50,7 @@ trunc_int_for_mode (HOST_WIDE_INT c, enum machine_mode mode)
int width = GET_MODE_BITSIZE (mode);
/* You want to truncate to a _what_? */
if (! SCALAR_INT_MODE_P (mode))
abort ();
gcc_assert (SCALAR_INT_MODE_P (mode));
/* Canonicalize BImode to 0 and STORE_FLAG_VALUE. */
if (mode == BImode)
@ -633,8 +632,7 @@ copy_to_mode_reg (enum machine_mode mode, rtx x)
if (! general_operand (x, VOIDmode))
x = force_operand (x, temp);
if (GET_MODE (x) != mode && GET_MODE (x) != VOIDmode)
abort ();
gcc_assert (GET_MODE (x) == mode || GET_MODE (x) == VOIDmode);
if (x != temp)
emit_move_insn (temp, x);
return temp;
@ -1106,11 +1104,10 @@ optimize_save_area_alloca (void)
Right now only supported port with stack that grow upward
is the HPPA and it does not define SETJMP_VIA_SAVE_AREA. */
if (GET_CODE (pat) != SET
|| SET_DEST (pat) != stack_pointer_rtx
|| GET_CODE (SET_SRC (pat)) != MINUS
|| XEXP (SET_SRC (pat), 0) != stack_pointer_rtx)
abort ();
gcc_assert (GET_CODE (pat) == SET
&& SET_DEST (pat) == stack_pointer_rtx
&& GET_CODE (SET_SRC (pat)) == MINUS
&& XEXP (SET_SRC (pat), 0) == stack_pointer_rtx);
/* This will now be transformed into a (set REG REG)
so we can just blow away all the other notes. */
@ -1134,8 +1131,7 @@ optimize_save_area_alloca (void)
if (XEXP (srch, 1) == note)
break;
if (srch == NULL_RTX)
abort ();
gcc_assert (srch);
XEXP (srch, 1) = XEXP (note, 1);
}
@ -1229,8 +1225,7 @@ allocate_dynamic_stack_space (rtx size, rtx target, int known_align)
/* ??? Code below assumes that the save area needs maximal
alignment. This constraint may be too strong. */
if (PREFERRED_STACK_BOUNDARY != BIGGEST_ALIGNMENT)
abort ();
gcc_assert (PREFERRED_STACK_BOUNDARY == BIGGEST_ALIGNMENT);
if (GET_CODE (size) == CONST_INT)
{
@ -1287,8 +1282,8 @@ allocate_dynamic_stack_space (rtx size, rtx target, int known_align)
/* We ought to be called always on the toplevel and stack ought to be aligned
properly. */
if (stack_pointer_delta % (PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT))
abort ();
gcc_assert (!(stack_pointer_delta
% (PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT)));
/* If needed, check that we have the required amount of stack. Take into
account what has already been checked. */
@ -1539,8 +1534,7 @@ probe_stack_range (HOST_WIDE_INT first, rtx size)
1, OPTAB_WIDEN);
#endif
if (temp != test_addr)
abort ();
gcc_assert (temp == test_addr);
emit_label (test_lab);
emit_cmp_and_jump_insns (test_addr, last_addr, CMP_OPCODE,
@ -1594,8 +1588,7 @@ hard_function_value (tree valtype, tree func ATTRIBUTE_UNUSED,
}
/* No suitable mode found. */
if (tmpmode == VOIDmode)
abort ();
gcc_assert (tmpmode != VOIDmode);
PUT_MODE (val, tmpmode);
}

167
gcc/expmed.c
View File

@ -298,7 +298,7 @@ mode_for_extraction (enum extraction_pattern pattern, int opno)
return MAX_MACHINE_MODE;
default:
abort ();
gcc_unreachable ();
}
if (opno == -1)
@ -386,10 +386,9 @@ store_bit_field (rtx str_rtx, unsigned HOST_WIDE_INT bitsize,
/* We could handle this, but we should always be called with a pseudo
for our targets and all insns should take them as outputs. */
if (! (*insn_data[icode].operand[0].predicate) (dest, mode0)
|| ! (*insn_data[icode].operand[1].predicate) (src, mode1)
|| ! (*insn_data[icode].operand[2].predicate) (rtxpos, mode2))
abort ();
gcc_assert ((*insn_data[icode].operand[0].predicate) (dest, mode0)
&& (*insn_data[icode].operand[1].predicate) (src, mode1)
&& (*insn_data[icode].operand[2].predicate) (rtxpos, mode2));
pat = GEN_FCN (icode) (dest, src, rtxpos);
seq = get_insns ();
end_sequence ();
@ -433,15 +432,14 @@ store_bit_field (rtx str_rtx, unsigned HOST_WIDE_INT bitsize,
{
if (GET_CODE (op0) == SUBREG)
{
if (GET_MODE (SUBREG_REG (op0)) == fieldmode
|| GET_MODE_CLASS (fieldmode) == MODE_INT
|| GET_MODE_CLASS (fieldmode) == MODE_PARTIAL_INT)
op0 = SUBREG_REG (op0);
else
/* Else we've got some float mode source being extracted into
a different float mode destination -- this combination of
subregs results in Severe Tire Damage. */
abort ();
/* Else we've got some float mode source being extracted
into a different float mode destination -- this
combination of subregs results in Severe Tire
Damage. */
gcc_assert (GET_MODE (SUBREG_REG (op0)) == fieldmode
|| GET_MODE_CLASS (fieldmode) == MODE_INT
|| GET_MODE_CLASS (fieldmode) == MODE_PARTIAL_INT);
op0 = SUBREG_REG (op0);
}
if (REG_P (op0))
op0 = gen_rtx_SUBREG (fieldmode, op0, byte_offset);
@ -462,10 +460,11 @@ store_bit_field (rtx str_rtx, unsigned HOST_WIDE_INT bitsize,
{
if (MEM_P (op0))
op0 = adjust_address (op0, imode, 0);
else if (imode != BLKmode)
op0 = gen_lowpart (imode, op0);
else
abort ();
{
gcc_assert (imode != BLKmode);
op0 = gen_lowpart (imode, op0);
}
}
}
@ -510,15 +509,13 @@ store_bit_field (rtx str_rtx, unsigned HOST_WIDE_INT bitsize,
if (GET_CODE (op0) == SUBREG)
{
if (GET_MODE (SUBREG_REG (op0)) == fieldmode
|| GET_MODE_CLASS (fieldmode) == MODE_INT
|| GET_MODE_CLASS (fieldmode) == MODE_PARTIAL_INT)
op0 = SUBREG_REG (op0);
else
/* Else we've got some float mode source being extracted into
a different float mode destination -- this combination of
subregs results in Severe Tire Damage. */
abort ();
/* Else we've got some float mode source being extracted into
a different float mode destination -- this combination of
subregs results in Severe Tire Damage. */
gcc_assert (GET_MODE (SUBREG_REG (op0)) == fieldmode
|| GET_MODE_CLASS (fieldmode) == MODE_INT
|| GET_MODE_CLASS (fieldmode) == MODE_PARTIAL_INT);
op0 = SUBREG_REG (op0);
}
emit_insn (GEN_FCN (icode)
@ -589,12 +586,10 @@ store_bit_field (rtx str_rtx, unsigned HOST_WIDE_INT bitsize,
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. */
if (GET_CODE (op0) == SUBREG
&& (GET_MODE_SIZE (GET_MODE (op0))
== GET_MODE_SIZE (GET_MODE (SUBREG_REG (op0)))))
op0 = SUBREG_REG (op0);
else
abort ();
gcc_assert (GET_CODE (op0) == SUBREG
&& (GET_MODE_SIZE (GET_MODE (op0))
== GET_MODE_SIZE (GET_MODE (SUBREG_REG (op0)))));
op0 = SUBREG_REG (op0);
}
op0 = gen_rtx_SUBREG (mode_for_size (BITS_PER_WORD, MODE_INT, 0),
op0, (offset * UNITS_PER_WORD));
@ -731,12 +726,12 @@ store_bit_field (rtx str_rtx, unsigned HOST_WIDE_INT bitsize,
}
else if (GET_CODE (value) == CONST_INT)
value1 = gen_int_mode (INTVAL (value), maxmode);
else if (!CONSTANT_P (value))
else
/* Parse phase is supposed to make VALUE's data type
match that of the component reference, which is a type
at least as wide as the field; so VALUE should have
a mode that corresponds to that type. */
abort ();
gcc_assert (CONSTANT_P (value));
}
/* If this machine's insv insists on a register,
@ -790,8 +785,7 @@ store_fixed_bit_field (rtx op0, unsigned HOST_WIDE_INT offset,
if (REG_P (op0) || GET_CODE (op0) == SUBREG)
{
if (offset != 0)
abort ();
gcc_assert (!offset);
/* Special treatment for a bit field split across two registers. */
if (bitsize + bitpos > BITS_PER_WORD)
{
@ -1146,10 +1140,9 @@ extract_bit_field (rtx str_rtx, unsigned HOST_WIDE_INT bitsize,
/* We could handle this, but we should always be called with a pseudo
for our targets and all insns should take them as outputs. */
if (! (*insn_data[icode].operand[0].predicate) (dest, mode0)
|| ! (*insn_data[icode].operand[1].predicate) (src, mode1)
|| ! (*insn_data[icode].operand[2].predicate) (rtxpos, mode2))
abort ();
gcc_assert ((*insn_data[icode].operand[0].predicate) (dest, mode0)
&& (*insn_data[icode].operand[1].predicate) (src, mode1)
&& (*insn_data[icode].operand[2].predicate) (rtxpos, mode2));
pat = GEN_FCN (icode) (dest, src, rtxpos);
seq = get_insns ();
@ -1170,10 +1163,11 @@ extract_bit_field (rtx str_rtx, unsigned HOST_WIDE_INT bitsize,
{
if (MEM_P (op0))
op0 = adjust_address (op0, imode, 0);
else if (imode != BLKmode)
op0 = gen_lowpart (imode, op0);
else
abort ();
{
gcc_assert (imode != BLKmode);
op0 = gen_lowpart (imode, op0);
}
}
}
@ -1299,8 +1293,7 @@ extract_bit_field (rtx str_rtx, unsigned HOST_WIDE_INT bitsize,
bitnum + bit_offset, 1, target_part, mode,
word_mode);
if (target_part == 0)
abort ();
gcc_assert (target_part);
if (result_part != target_part)
emit_move_insn (target_part, result_part);
@ -1346,13 +1339,11 @@ extract_bit_field (rtx str_rtx, unsigned HOST_WIDE_INT bitsize,
int_mode = int_mode_for_mode (tmode);
if (int_mode == BLKmode)
int_mode = int_mode_for_mode (mode);
if (int_mode == BLKmode)
abort (); /* Should probably push op0 out to memory and then
do a load. */
/* Should probably push op0 out to memory and then do a load. */
gcc_assert (int_mode != BLKmode);
/* OFFSET is the number of words or bytes (UNIT says which)
from STR_RTX to the first word or byte containing part of the field. */
if (!MEM_P (op0))
{
if (offset != 0
@ -2145,8 +2136,7 @@ expand_shift (enum tree_code code, enum machine_mode mode, rtx shifted,
define_expand for lshrsi3 was added to vax.md. */
}
if (temp == 0)
abort ();
gcc_assert (temp);
return temp;
}
@ -2649,7 +2639,7 @@ expand_mult_const (enum machine_mode mode, rtx op0, HOST_WIDE_INT val,
val_so_far = 1;
}
else
abort ();
gcc_unreachable ();
for (opno = 1; opno < alg->ops; opno++)
{
@ -2727,7 +2717,7 @@ expand_mult_const (enum machine_mode mode, rtx op0, HOST_WIDE_INT val,
break;
default:
abort ();
gcc_unreachable ();
}
/* Write a REG_EQUAL note on the last insn so that we can cse
@ -2762,8 +2752,7 @@ expand_mult_const (enum machine_mode mode, rtx op0, HOST_WIDE_INT val,
in the result mode, to avoid sign-/zero-extension confusion. */
val &= GET_MODE_MASK (mode);
val_so_far &= GET_MODE_MASK (mode);
if (val != val_so_far)
abort ();
gcc_assert (val == val_so_far);
return accum;
}
@ -2848,8 +2837,7 @@ expand_mult (enum machine_mode mode, rtx op0, rtx op1, rtx target,
&& flag_trapv && (GET_MODE_CLASS(mode) == MODE_INT)
? smulv_optab : smul_optab,
op0, op1, target, unsignedp, OPTAB_LIB_WIDEN);
if (op0 == 0)
abort ();
gcc_assert (op0);
return op0;
}
@ -2893,18 +2881,15 @@ choose_multiplier (unsigned HOST_WIDE_INT d, int n, int precision,
/* lgup = ceil(log2(divisor)); */
lgup = ceil_log2 (d);
if (lgup > n)
abort ();
gcc_assert (lgup <= n);
pow = n + lgup;
pow2 = n + lgup - precision;
if (pow == 2 * HOST_BITS_PER_WIDE_INT)
{
/* We could handle this with some effort, but this case is much better
handled directly with a scc insn, so rely on caller using that. */
abort ();
}
/* We could handle this with some effort, but this case is much
better handled directly with a scc insn, so rely on caller using
that. */
gcc_assert (pow != 2 * HOST_BITS_PER_WIDE_INT);
/* mlow = 2^(N + lgup)/d */
if (pow >= HOST_BITS_PER_WIDE_INT)
@ -2928,13 +2913,11 @@ choose_multiplier (unsigned HOST_WIDE_INT d, int n, int precision,
div_and_round_double (TRUNC_DIV_EXPR, 1, nl, nh, d, (HOST_WIDE_INT) 0,
&mhigh_lo, &mhigh_hi, &dummy1, &dummy2);
if (mhigh_hi && nh - d >= d)
abort ();
if (mhigh_hi > 1 || mlow_hi > 1)
abort ();
gcc_assert (!mhigh_hi || nh - d < d);
gcc_assert (mhigh_hi <= 1 && mlow_hi <= 1);
/* Assert that mlow < mhigh. */
if (! (mlow_hi < mhigh_hi || (mlow_hi == mhigh_hi && mlow_lo < mhigh_lo)))
abort ();
gcc_assert (mlow_hi < mhigh_hi
|| (mlow_hi == mhigh_hi && mlow_lo < mhigh_lo));
/* If precision == N, then mlow, mhigh exceed 2^N
(but they do not exceed 2^(N+1)). */
@ -3156,8 +3139,7 @@ expand_mult_highpart (enum machine_mode mode, rtx op0,
rtx op1, tem;
/* We can't support modes wider than HOST_BITS_PER_INT. */
if (GET_MODE_BITSIZE (mode) > HOST_BITS_PER_WIDE_INT)
abort ();
gcc_assert (GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT);
op1 = gen_int_mode (cnst1, wider_mode);
cnst1 &= GET_MODE_MASK (mode);
@ -3662,8 +3644,7 @@ expand_divmod (int rem_flag, enum tree_code code, enum machine_mode mode,
mh = choose_multiplier (d >> pre_shift, size,
size - pre_shift,
&ml, &post_shift, &dummy);
if (mh)
abort ();
gcc_assert (!mh);
}
else
pre_shift = 0;
@ -3939,8 +3920,7 @@ expand_divmod (int rem_flag, enum tree_code code, enum machine_mode mode,
mh = choose_multiplier (d, size, size - 1,
&ml, &post_shift, &lgup);
if (mh)
abort ();
gcc_assert (!mh);
if (post_shift < BITS_PER_WORD
&& size - 1 < BITS_PER_WORD)
@ -4398,7 +4378,7 @@ expand_divmod (int rem_flag, enum tree_code code, enum machine_mode mode,
return gen_lowpart (mode, rem_flag ? remainder : quotient);
default:
abort ();
gcc_unreachable ();
}
if (quotient == 0)
@ -4899,20 +4879,23 @@ emit_store_flag (rtx target, enum rtx_code code, rtx op0, rtx op1,
= compare_from_rtx (op0, op1, code, unsignedp, mode, NULL_RTX);
if (CONSTANT_P (comparison))
{
if (GET_CODE (comparison) == CONST_INT)
switch (GET_CODE (comparison))
{
case CONST_INT:
if (comparison == const0_rtx)
return const0_rtx;
}
break;
#ifdef FLOAT_STORE_FLAG_VALUE
else if (GET_CODE (comparison) == CONST_DOUBLE)
{
case CONST_DOUBLE:
if (comparison == CONST0_RTX (GET_MODE (comparison)))
return const0_rtx;
}
break;
#endif
else
abort ();
default:
gcc_unreachable ();
}
if (normalizep == 1)
return const1_rtx;
if (normalizep == -1)
@ -4987,14 +4970,14 @@ emit_store_flag (rtx target, enum rtx_code code, rtx op0, rtx op1,
op0 = expand_shift (RSHIFT_EXPR, compare_mode, op0,
size_int (GET_MODE_BITSIZE (compare_mode) - 1),
subtarget, normalizep == 1);
else if (STORE_FLAG_VALUE & 1)
else
{
gcc_assert (STORE_FLAG_VALUE & 1);
op0 = expand_and (compare_mode, op0, const1_rtx, subtarget);
if (normalizep == -1)
op0 = expand_unop (compare_mode, neg_optab, op0, op0, 0);
}
else
abort ();
/* If we were converting to a smaller mode, do the
conversion now. */
@ -5262,19 +5245,17 @@ do_cmp_and_jump (rtx arg1, rtx arg2, enum rtx_code op, enum machine_mode mode,
/* do_jump_by_parts_equality_rtx compares with zero. Luckily
that's the only equality operations we do */
case EQ:
if (arg2 != const0_rtx || mode != GET_MODE(arg1))
abort ();
gcc_assert (arg2 == const0_rtx && mode == GET_MODE(arg1));
do_jump_by_parts_equality_rtx (arg1, label2, label);
break;
case NE:
if (arg2 != const0_rtx || mode != GET_MODE(arg1))
abort ();
gcc_assert (arg2 == const0_rtx && mode == GET_MODE(arg1));
do_jump_by_parts_equality_rtx (arg1, label, label2);
break;
default:
abort ();
gcc_unreachable ();
}
emit_label (label2);

1677
gcc/expr.c
View File

File diff suppressed because it is too large Load Diff