This is the mail archive of the
gcc-patches@gcc.gnu.org
mailing list for the GCC project.
[assert] [rs]*.[ch]
- From: Nathan Sidwell <nathan at codesourcery dot com>
- To: GCC Patches <gcc-patches at gcc dot gnu dot org>, Giovanni Bajo <giovannibajo at libero dot it>
- Date: Thu, 09 Sep 2004 18:08:31 +0100
- Subject: [assert] [rs]*.[ch]
- Organization: Codesourcery LLC
I've installed this patch from Giovanni. It does the r* and s* files.
I tweaked it slightly, I think there were a couple of unreachables
that could really be asserts.
booted & tested on i686-pc-linux-gnu.
Thanks Giovanni!
nathan
--
Nathan Sidwell :: http://www.codesourcery.com :: CodeSourcery LLC
nathan@codesourcery.com :: http://www.planetfall.pwp.blueyonder.co.uk
2004-09-09 Giovanni Bajo <giovannibajo@gcc.gnu.org>
* ra-build.c (copy_insn_p, remember_move, defuse_overlap_p_1,
live_out_1, prune_hardregs_for_mode, init_one_web_common,
reinit_one_web, add_subweb, add_subweb_2, init_web_parts,
record_conflict, compare_and_free_webs, init_webs_defs_uses,
parts_to_webs_1, parts_to_webs, reset_conflicts,
check_conflict_numbers, remember_web_was_spilled, handle_asm_insn,
ra_build_free): Use gcc_assert and gcc_unreachable instead of abort.
* ra-colorize.c (push_list, put_web, reset_lists, put_web_at_end,
put_move, remove_move, combine, select_spill, colorize_one_web,
try_recolor_web, insert_coalesced_conflicts, check_colors,
break_precolored_alias, restore_conflicts_from_coalesce,
sort_and_combine_web_pairs, check_uncoalesced_moves): Likewise.
* ra-rewrite.c (spill_coalescing, slots_overlap_p, emit_loads,
reloads_to_loads, rewrite_program2, emit_colors): Likewise.
* ra.c (first_hard_reg, create_insn_info, find_subweb, init_ra,
check_df): Likewise.
* real.c (do_add, do_multiply, do_divide, do_compare, do_fix_trunc,
real_arithmetic, real_compare, real_exponent, real_ldexp,
real_identical, real_to_integer, real_to_integer2, real_to_decimal,
real_to_hexadecimal, real_from_integer, ten_to_ptwo, ten_to_mptwo,
real_digit, real_nan, real_maxval, round_for_format, real_convert,
real_to_target, real_from_target, real_hash, encode_ieee_single,
encode_ieee_double, encode_ieee_extended, encode_ieee_quad,
encode_vax_f, encode_vax_d, encode_vax_g, encode_i370_single,
encode_i370_double, encode_c4x_single, encode_c4x_extended): Likewise.
* recog.c (validate_change, validate_replace_rtx_1, asm_operand_ok,
extract_insn, peep2_next_insn, peep2_reg_dead_p,
peep2_find_free_register, peephole2_optimize, store_data_bypass_p,
if_test_bypass_p): Likewise.
* reg-stack.c (record_label_references, get_asm_operand_n_inputs,
stack_result, remove_regno_note, get_hard_regnum, emit_pop_insn,
emit_swap_insn, swap_to_top, move_for_stack_reg,
subst_stack_regs_pat, subst_asm_stack_regs, change_stack,
compensate_edge, convert_regs_1): Likewise.
* regclass.c (init_reg_sets, init_reg_sets_1,
memory_move_secondary_cost): Likewise.
* regrename.c (note_sets, clear_dead_regs, scan_rtx_reg, scan_rtx):
Likewise.
* reload.c (push_secondary_reload, find_valid_class, push_reload,
operands_match_p, decompose, immune_p, find_reloads,
find_reloads_toplev, find_reloads_address_1, subst_reloads,
copy_replacements, refers_to_regno_for_reload_p,
reg_overlap_mentioned_for_reload_p): Likewise.
* reload1.c (compute_use_by_pseudos, replace_pseudos_in, reload,
count_pseudo, find_reg, eliminate_regs, eliminate_regs_in_insn,
verify_initial_elim_offsets, finish_spills, clear_reload_reg_in_use,
reload_reg_free_p, reload_reg_reaches_end_p, reloads_conflict,
choose_reload_regs, merge_assigned_reloads, emit_input_reload_insns,
do_output_reload, fixup_abnormal_edges): Likewise.
* reorg.c (stop_search_p, emit_delay_sequence, get_jump_flags,
fill_slots_from_thread, relax_delay_slots): Likewise.
* resource.c (mark_referenced_resources, mark_set_resources):
Likewise.
* rtl.c (copy_rtx, rtx_equal_p): Likewise.
* rtlanal.c (insn_dependent_p, reg_overlap_mentioned_p,
dead_or_set_p, find_reg_fusage, remove_note, replace_rtx,
subreg_lsb_1, subreg_regno_offset, subreg_offset_representable_p,
find_first_parameter_load, can_hoist_insn_p, hoist_update_store,
hoist_insn_after, hoist_insn_to_edge, nonzero_bits1): Likewise.
* rtlhooks.c (gen_lowpart_general): Likewise.
* sbitmap.c (sbitmap_difference): Likewise.
* sched-deps.c (add_dependence, sched_analyze_1, sched_analyze_2,
sched_analyze, add_forward_dependence): Likewise.
* sched-ebb.c (fix_basic_block_boundaries, schedule_ebb): Likewise.
* sched-rgn.c (debug_regions, compute_trg_info, schedule_region,
schedule_insns): Likewise.
* sched-vis.c (print_pattern): Likewise.
* sdbout.c (sdbout_symbol, sdbout_toplevel_data): Likewise.
* simplify-rtx.c (simplify_unary_operation, simplify_binary_operation,
simplify_const_relational_operation, simplify_ternary_operation,
simplify_immed_subreg, simplify_subreg, simplify_gen_subreg):
Likewise.
* sreal.c (copy, sreal_sub, sreal_div): Likewise.
* stmt.c (force_label_rtx, expand_goto, expand_asm_operands,
resolve_operand_name_1, expand_return, expand_decl,
expand_anon_union_decl, emit_case_bit_tests, expand_case): Likewise.
* stor-layout.c (put_pending_size, smallest_mode_for_size,
int_mode_for_mode, layout_decl, finish_builtin_struct, layout_type,
set_sizetype, get_mode_bounds): Likewise.
Index: ra-build.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/ra-build.c,v
retrieving revision 1.32
diff -c -3 -p -r1.32 ra-build.c
*** ra-build.c 3 Aug 2004 15:00:49 -0000 1.32
--- ra-build.c 9 Sep 2004 14:25:25 -0000
*************** copy_insn_p (rtx insn, rtx *source, rtx
*** 228,235 ****
unsigned int d_regno, s_regno;
int uid = INSN_UID (insn);
! if (!INSN_P (insn))
! abort ();
/* First look, if we already saw this insn. */
if (copy_cache[uid].seen)
--- 228,234 ----
unsigned int d_regno, s_regno;
int uid = INSN_UID (insn);
! gcc_assert (INSN_P (insn));
/* First look, if we already saw this insn. */
if (copy_cache[uid].seen)
*************** remember_move (rtx insn)
*** 541,564 ****
if (!TEST_BIT (move_handled, INSN_UID (insn)))
{
rtx s, d;
SET_BIT (move_handled, INSN_UID (insn));
! if (copy_insn_p (insn, &s, &d))
! {
! /* Some sanity test for the copy insn. */
! struct df_link *slink = DF_INSN_USES (df, insn);
! struct df_link *link = DF_INSN_DEFS (df, insn);
! if (!link || !link->ref || !slink || !slink->ref)
! abort ();
! /* The following (link->next != 0) happens when a hardreg
! is used in wider mode (REG:DI %eax). Then df.* creates
! a def/use for each hardreg contained therein. We only
! allow hardregs here. */
! if (link->next
! && DF_REF_REGNO (link->next->ref) >= FIRST_PSEUDO_REGISTER)
! abort ();
! }
! else
! abort ();
/* XXX for now we don't remember move insns involving any subregs.
Those would be difficult to coalesce (we would need to implement
handling of all the subwebs in the allocator, including that such
--- 540,564 ----
if (!TEST_BIT (move_handled, INSN_UID (insn)))
{
rtx s, d;
+ int ret;
+ struct df_link *slink = DF_INSN_USES (df, insn);
+ struct df_link *link = DF_INSN_DEFS (df, insn);
+
SET_BIT (move_handled, INSN_UID (insn));
! ret = copy_insn_p (insn, &s, &d);
! gcc_assert (ret);
!
! /* Some sanity test for the copy insn. */
! gcc_assert (link && link->ref);
! gcc_assert (slink && slink->ref);
! /* The following (link->next != 0) happens when a hardreg
! is used in wider mode (REG:DI %eax). Then df.* creates
! a def/use for each hardreg contained therein. We only
! allow hardregs here. */
! gcc_assert (!link->next
! || DF_REF_REGNO (link->next->ref)
! < FIRST_PSEUDO_REGISTER);
!
/* XXX for now we don't remember move insns involving any subregs.
Those would be difficult to coalesce (we would need to implement
handling of all the subwebs in the allocator, including that such
*************** defuse_overlap_p_1 (rtx def, struct curr
*** 669,675 ****
return (old_u != use->undefined) ? 4 : -1;
}
default:
! abort ();
}
}
--- 669,675 ----
return (old_u != use->undefined) ? 4 : -1;
}
default:
! gcc_unreachable ();
}
}
*************** live_out_1 (struct df *df ATTRIBUTE_UNUS
*** 821,828 ****
{
/* If this insn doesn't completely define the USE, increment also
it's spanned deaths count (if this insn contains a death). */
! if (uid >= death_insns_max_uid)
! abort ();
if (TEST_BIT (insns_with_deaths, uid))
wp->spanned_deaths++;
use->undefined = final_undef;
--- 821,827 ----
{
/* If this insn doesn't completely define the USE, increment also
it's spanned deaths count (if this insn contains a death). */
! gcc_assert (uid < death_insns_max_uid);
if (TEST_BIT (insns_with_deaths, uid))
wp->spanned_deaths++;
use->undefined = final_undef;
*************** prune_hardregs_for_mode (HARD_REG_SET *s
*** 1206,1213 ****
static void
init_one_web_common (struct web *web, rtx reg)
{
! if (!REG_P (reg))
! abort ();
/* web->id isn't initialized here. */
web->regno = REGNO (reg);
web->orig_x = reg;
--- 1205,1211 ----
static void
init_one_web_common (struct web *web, rtx reg)
{
! gcc_assert (REG_P (reg));
/* web->id isn't initialized here. */
web->regno = REGNO (reg);
web->orig_x = reg;
*************** init_one_web_common (struct web *web, rt
*** 1272,1279 ****
#endif
web->num_freedom = hard_regs_count (web->usable_regs);
web->num_freedom -= web->add_hardregs;
! if (!web->num_freedom)
! abort();
}
COPY_HARD_REG_SET (web->orig_usable_regs, web->usable_regs);
}
--- 1270,1276 ----
#endif
web->num_freedom = hard_regs_count (web->usable_regs);
web->num_freedom -= web->add_hardregs;
! gcc_assert (web->num_freedom);
}
COPY_HARD_REG_SET (web->orig_usable_regs, web->usable_regs);
}
*************** reinit_one_web (struct web *web, rtx reg
*** 1324,1333 ****
web->stack_slot = NULL;
web->pattern = NULL;
web->alias = NULL;
! if (web->moves)
! abort ();
! if (!web->useless_conflicts)
! abort ();
}
/* Insert and returns a subweb corresponding to REG into WEB (which
--- 1321,1328 ----
web->stack_slot = NULL;
web->pattern = NULL;
web->alias = NULL;
! gcc_assert (!web->moves);
! gcc_assert (web->useless_conflicts);
}
/* Insert and returns a subweb corresponding to REG into WEB (which
*************** static struct web *
*** 1337,1344 ****
add_subweb (struct web *web, rtx reg)
{
struct web *w;
! if (GET_CODE (reg) != SUBREG)
! abort ();
w = xmalloc (sizeof (struct web));
/* Copy most content from parent-web. */
*w = *web;
--- 1332,1338 ----
add_subweb (struct web *web, rtx reg)
{
struct web *w;
! gcc_assert (GET_CODE (reg) == SUBREG);
w = xmalloc (sizeof (struct web));
/* Copy most content from parent-web. */
*w = *web;
*************** add_subweb_2 (struct web *web, unsigned
*** 1376,1383 ****
mode = mode_for_size (size, GET_MODE_CLASS (GET_MODE (ref_rtx)), 0);
if (mode == BLKmode)
mode = mode_for_size (size, MODE_INT, 0);
! if (mode == BLKmode)
! abort ();
web = add_subweb (web, gen_rtx_SUBREG (mode, web->orig_x,
BYTE_BEGIN (size_word)));
web->artificial = 1;
--- 1370,1376 ----
mode = mode_for_size (size, GET_MODE_CLASS (GET_MODE (ref_rtx)), 0);
if (mode == BLKmode)
mode = mode_for_size (size, MODE_INT, 0);
! gcc_assert (mode != BLKmode);
web = add_subweb (web, gen_rtx_SUBREG (mode, web->orig_x,
BYTE_BEGIN (size_word)));
web->artificial = 1;
*************** init_web_parts (struct df *df)
*** 1396,1403 ****
{
if (df->defs[no])
{
! if (no < last_def_id && web_parts[no].ref != df->defs[no])
! abort ();
web_parts[no].ref = df->defs[no];
/* Uplink might be set from the last iteration. */
if (!web_parts[no].uplink)
--- 1389,1395 ----
{
if (df->defs[no])
{
! gcc_assert (no >= last_def_id || web_parts[no].ref == df->defs[no]);
web_parts[no].ref = df->defs[no];
/* Uplink might be set from the last iteration. */
if (!web_parts[no].uplink)
*************** init_web_parts (struct df *df)
*** 1414,1422 ****
{
if (df->uses[no])
{
! if (no < last_use_id
! && web_parts[no + df->def_id].ref != df->uses[no])
! abort ();
web_parts[no + df->def_id].ref = df->uses[no];
if (!web_parts[no + df->def_id].uplink)
num_webs++;
--- 1406,1413 ----
{
if (df->uses[no])
{
! gcc_assert (no >= last_use_id
! || web_parts[no + df->def_id].ref == df->uses[no]);
web_parts[no + df->def_id].ref = df->uses[no];
if (!web_parts[no + df->def_id].uplink)
num_webs++;
*************** static void
*** 1464,1471 ****
copy_conflict_list (struct web *web)
{
struct conflict_link *cl;
! if (web->orig_conflict_list || web->have_orig_conflicts)
! abort ();
web->have_orig_conflicts = 1;
for (cl = web->conflict_list; cl; cl = cl->next)
{
--- 1455,1462 ----
copy_conflict_list (struct web *web)
{
struct conflict_link *cl;
! gcc_assert (!web->orig_conflict_list);
! gcc_assert (!web->have_orig_conflicts);
web->have_orig_conflicts = 1;
for (cl = web->conflict_list; cl; cl = cl->next)
{
*************** record_conflict (struct web *web1, struc
*** 1572,1579 ****
/* Trivial non-conflict or already recorded conflict. */
if (web1 == web2 || TEST_BIT (igraph, index))
return;
! if (id1 == id2)
! abort ();
/* As fixed_regs are no targets for allocation, conflicts with them
are pointless. */
if ((web1->regno < FIRST_PSEUDO_REGISTER && fixed_regs[web1->regno])
--- 1563,1569 ----
/* Trivial non-conflict or already recorded conflict. */
if (web1 == web2 || TEST_BIT (igraph, index))
return;
! gcc_assert (id1 != id2);
/* As fixed_regs are no targets for allocation, conflicts with them
are pointless. */
if ((web1->regno < FIRST_PSEUDO_REGISTER && fixed_regs[web1->regno])
*************** compare_and_free_webs (struct web_link *
*** 1663,1694 ****
{
struct web *web1 = wl->web;
struct web *web2 = ID2WEB (web1->id);
! if (web1->regno != web2->regno
! || web1->mode_changed != web2->mode_changed
! || !rtx_equal_p (web1->orig_x, web2->orig_x)
! || web1->type != web2->type
! /* Only compare num_defs/num_uses with non-hardreg webs.
! E.g. the number of uses of the framepointer changes due to
! inserting spill code. */
! || (web1->type != PRECOLORED
! && (web1->num_uses != web2->num_uses
! || web1->num_defs != web2->num_defs))
! /* Similarly, if the framepointer was unreferenced originally
! but we added spills, these fields may not match. */
! || (web1->type != PRECOLORED
! && web1->crosses_call != web2->crosses_call)
! || (web1->type != PRECOLORED
! && web1->live_over_abnormal != web2->live_over_abnormal))
! abort ();
if (web1->type != PRECOLORED)
{
unsigned int i;
for (i = 0; i < web1->num_defs; i++)
! if (web1->defs[i] != web2->defs[i])
! abort ();
for (i = 0; i < web1->num_uses; i++)
! if (web1->uses[i] != web2->uses[i])
! abort ();
}
if (web1->type == PRECOLORED)
{
--- 1653,1679 ----
{
struct web *web1 = wl->web;
struct web *web2 = ID2WEB (web1->id);
! gcc_assert (web1->regno == web2->regno);
! gcc_assert (web1->mode_changed == web2->mode_changed);
! gcc_assert (rtx_equal_p (web1->orig_x, web2->orig_x));
! gcc_assert (web1->type == web2->type);
if (web1->type != PRECOLORED)
{
unsigned int i;
+
+ /* Only compare num_defs/num_uses with non-hardreg webs.
+ E.g. the number of uses of the framepointer changes due to
+ inserting spill code. */
+ gcc_assert (web1->num_uses == web2->num_uses);
+ gcc_assert (web1->num_defs == web2->num_defs);
+ /* Similarly, if the framepointer was unreferenced originally
+ but we added spills, these fields may not match. */
+ gcc_assert (web1->crosses_call == web2->crosses_call);
+ gcc_assert (web1->live_over_abnormal == web2->live_over_abnormal);
for (i = 0; i < web1->num_defs; i++)
! gcc_assert (web1->defs[i] == web2->defs[i]);
for (i = 0; i < web1->num_uses; i++)
! gcc_assert (web1->uses[i] == web2->uses[i]);
}
if (web1->type == PRECOLORED)
{
*************** init_webs_defs_uses (void)
*** 1733,1740 ****
web->uses[use_i++] = link->ref;
}
web->temp_refs = NULL;
! if (def_i != web->num_defs || use_i != web->num_uses)
! abort ();
}
}
--- 1718,1725 ----
web->uses[use_i++] = link->ref;
}
web->temp_refs = NULL;
! gcc_assert (def_i == web->num_defs);
! gcc_assert (use_i == web->num_uses);
}
}
*************** parts_to_webs_1 (struct df *df, struct w
*** 1834,1844 ****
web->id = newid;
web->temp_refs = NULL;
webnum++;
! if (web->regno < FIRST_PSEUDO_REGISTER && !hardreg2web[web->regno])
! hardreg2web[web->regno] = web;
! else if (web->regno < FIRST_PSEUDO_REGISTER
! && hardreg2web[web->regno] != web)
! abort ();
}
/* If this reference already had a web assigned, we are done.
--- 1819,1831 ----
web->id = newid;
web->temp_refs = NULL;
webnum++;
! if (web->regno < FIRST_PSEUDO_REGISTER)
! {
! if (!hardreg2web[web->regno])
! hardreg2web[web->regno] = web;
! else
! gcc_assert (hardreg2web[web->regno] == web);
! }
}
/* If this reference already had a web assigned, we are done.
*************** parts_to_webs_1 (struct df *df, struct w
*** 1861,1868 ****
web->live_over_abnormal = 1;
/* And check, that it's not a newly allocated web. This would be
an inconsistency. */
! if (!web->old_web || web->type == PRECOLORED)
! abort ();
continue;
}
/* In case this was no web part root, we need to initialize WEB
--- 1848,1855 ----
web->live_over_abnormal = 1;
/* And check, that it's not a newly allocated web. This would be
an inconsistency. */
! gcc_assert (web->old_web);
! gcc_assert (web->type != PRECOLORED);
continue;
}
/* In case this was no web part root, we need to initialize WEB
*************** parts_to_webs_1 (struct df *df, struct w
*** 1884,1891 ****
/* And the test, that if def2web[i] was NULL above, that we are _not_
an old web. */
! if (web->old_web && web->type != PRECOLORED)
! abort ();
/* Possible create a subweb, if this ref was a subreg. */
if (GET_CODE (reg) == SUBREG)
--- 1871,1877 ----
/* And the test, that if def2web[i] was NULL above, that we are _not_
an old web. */
! gcc_assert (!web->old_web || web->type == PRECOLORED);
/* Possible create a subweb, if this ref was a subreg. */
if (GET_CODE (reg) == SUBREG)
*************** parts_to_webs_1 (struct df *df, struct w
*** 1894,1901 ****
if (!subweb)
{
subweb = add_subweb (web, reg);
! if (web->old_web)
! abort ();
}
}
else
--- 1880,1886 ----
if (!subweb)
{
subweb = add_subweb (web, reg);
! gcc_assert (!web->old_web);
}
}
else
*************** parts_to_webs_1 (struct df *df, struct w
*** 1917,1930 ****
{
struct web *compare = def2web[i];
if (i < last_def_id)
! {
! if (web->old_web && compare != subweb)
! abort ();
! }
! if (!web->old_web && compare)
! abort ();
! if (compare && compare != subweb)
! abort ();
}
def2web[i] = subweb;
web->num_defs++;
--- 1902,1910 ----
{
struct web *compare = def2web[i];
if (i < last_def_id)
! gcc_assert (!web->old_web || compare == subweb);
! gcc_assert (web->old_web || !compare);
! gcc_assert (!compare || compare == subweb);
}
def2web[i] = subweb;
web->num_defs++;
*************** parts_to_webs_1 (struct df *df, struct w
*** 1934,1948 ****
if (ra_pass > 1)
{
struct web *compare = use2web[ref_id];
! if (ref_id < last_use_id)
! {
! if (web->old_web && compare != subweb)
! abort ();
! }
! if (!web->old_web && compare)
! abort ();
! if (compare && compare != subweb)
! abort ();
}
use2web[ref_id] = subweb;
web->num_uses++;
--- 1914,1924 ----
if (ra_pass > 1)
{
struct web *compare = use2web[ref_id];
!
! gcc_assert (ref_id >= last_use_id
! || !web->old_web || compare == subweb);
! gcc_assert (web->old_web || !compare);
! gcc_assert (!compare || compare == subweb);
}
use2web[ref_id] = subweb;
web->num_uses++;
*************** parts_to_webs_1 (struct df *df, struct w
*** 1952,1959 ****
}
/* We better now have exactly as many webs as we had web part roots. */
! if (webnum != num_webs)
! abort ();
return webnum;
}
--- 1928,1934 ----
}
/* We better now have exactly as many webs as we had web part roots. */
! gcc_assert (webnum == num_webs);
return webnum;
}
*************** parts_to_webs (struct df *df)
*** 2001,2008 ****
struct web *web;
if (wp->uplink || !wp->ref)
{
! if (wp->sub_conflicts)
! abort ();
continue;
}
web = def2web[i];
--- 1976,1982 ----
struct web *web;
if (wp->uplink || !wp->ref)
{
! gcc_assert (!wp->sub_conflicts);
continue;
}
web = def2web[i];
*************** reset_conflicts (void)
*** 2087,2094 ****
web->conflict_list = web->orig_conflict_list;
web->orig_conflict_list = NULL;
}
! if (web->orig_conflict_list)
! abort ();
/* New non-precolored webs, have no conflict list. */
if (web->type != PRECOLORED && !web->old_web)
--- 2061,2067 ----
web->conflict_list = web->orig_conflict_list;
web->orig_conflict_list = NULL;
}
! gcc_assert (!web->orig_conflict_list);
/* New non-precolored webs, have no conflict list. */
if (web->type != PRECOLORED && !web->old_web)
*************** reset_conflicts (void)
*** 2097,2104 ****
/* Useless conflicts will be rebuilt completely. But check
for cleanliness, as the web might have come from the
free list. */
! if (bitmap_first_set_bit (web->useless_conflicts) >= 0)
! abort ();
}
else
{
--- 2070,2076 ----
/* Useless conflicts will be rebuilt completely. But check
for cleanliness, as the web might have come from the
free list. */
! gcc_assert (bitmap_first_set_bit (web->useless_conflicts) < 0);
}
else
{
*************** check_conflict_numbers (void)
*** 2153,2160 ****
for (cl = web->conflict_list; cl; cl = cl->next)
if (cl->t->type != SELECT && cl->t->type != COALESCED)
new_conf += 1 + cl->t->add_hardregs;
! if (web->type != PRECOLORED && new_conf != web->num_conflicts)
! abort ();
}
}
#endif
--- 2125,2131 ----
for (cl = web->conflict_list; cl; cl = cl->next)
if (cl->t->type != SELECT && cl->t->type != COALESCED)
new_conf += 1 + cl->t->add_hardregs;
! gcc_assert (web->type == PRECOLORED || new_conf == web->num_conflicts);
}
}
#endif
*************** remember_web_was_spilled (struct web *we
*** 2316,2323 ****
AND_COMPL_HARD_REG_SET (web->usable_regs, invalid_mode_change_regs);
#endif
web->num_freedom = hard_regs_count (web->usable_regs);
! if (!web->num_freedom)
! abort();
COPY_HARD_REG_SET (web->orig_usable_regs, web->usable_regs);
/* Now look for a class, which is subset of our constraints, to
setup add_hardregs, and regclass for debug output. */
--- 2287,2293 ----
AND_COMPL_HARD_REG_SET (web->usable_regs, invalid_mode_change_regs);
#endif
web->num_freedom = hard_regs_count (web->usable_regs);
! gcc_assert (web->num_freedom);
COPY_HARD_REG_SET (web->orig_usable_regs, web->usable_regs);
/* Now look for a class, which is subset of our constraints, to
setup add_hardregs, and regclass for debug output. */
*************** remember_web_was_spilled (struct web *we
*** 2345,2352 ****
web->add_hardregs =
CLASS_MAX_NREGS (web->regclass, PSEUDO_REGNO_MODE (web->regno)) - 1;
web->num_freedom -= web->add_hardregs;
! if (!web->num_freedom)
! abort();
adjust -= 0 * web->add_hardregs;
web->num_conflicts -= adjust;
}
--- 2315,2321 ----
web->add_hardregs =
CLASS_MAX_NREGS (web->regclass, PSEUDO_REGNO_MODE (web->regno)) - 1;
web->num_freedom -= web->add_hardregs;
! gcc_assert (web->num_freedom);
adjust -= 0 * web->add_hardregs;
web->num_conflicts -= adjust;
}
*************** handle_asm_insn (struct df *df, rtx insn
*** 2853,2862 ****
link = link->next;
if (!link || !link->ref)
{
! if (in_output)
! in_output = 0;
! else
! abort ();
}
else
break;
--- 2822,2829 ----
link = link->next;
if (!link || !link->ref)
{
! gcc_assert (in_output);
! in_output = 0;
}
else
break;
*************** ra_build_free (void)
*** 3124,3134 ****
for (i = 0; i < num_webs; i++)
{
struct web *web = ID2WEB (i);
! if (!web)
! abort ();
! if (i >= num_webs - num_subwebs
! && (web->conflict_list || web->orig_conflict_list))
! abort ();
web->moves = NULL;
}
/* All webs in the free list have no defs or uses anymore. */
--- 3091,3099 ----
for (i = 0; i < num_webs; i++)
{
struct web *web = ID2WEB (i);
! gcc_assert (web);
! gcc_assert (i < num_webs - num_subwebs
! || (!web->conflict_list && !web->orig_conflict_list));
web->moves = NULL;
}
/* All webs in the free list have no defs or uses anymore. */
Index: ra.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/ra.c,v
retrieving revision 1.19
diff -c -3 -p -r1.19 ra.c
*** ra.c 29 Jul 2004 14:49:21 -0000 1.19
--- ra.c 9 Sep 2004 14:25:25 -0000
*************** static int
*** 221,229 ****
first_hard_reg (HARD_REG_SET rs)
{
int c;
! for (c = 0; c < FIRST_PSEUDO_REGISTER && !TEST_HARD_REG_BIT (rs, c); c++)
! if (c == FIRST_PSEUDO_REGISTER)
! abort();
return c;
}
--- 221,231 ----
first_hard_reg (HARD_REG_SET rs)
{
int c;
!
! for (c = 0; c < FIRST_PSEUDO_REGISTER; c++)
! if (TEST_HARD_REG_BIT (rs, c))
! break;
! gcc_assert (c < FIRST_PSEUDO_REGISTER);
return c;
}
*************** create_insn_info (struct df *df)
*** 291,298 ****
act_refs += n;
insn_df[uid].num_uses = n;
}
! if (refs_for_insn_df + (df->def_id + df->use_id) < act_refs)
! abort ();
}
/* Free the insn_df structures. */
--- 293,299 ----
act_refs += n;
insn_df[uid].num_uses = n;
}
! gcc_assert (refs_for_insn_df + (df->def_id + df->use_id) >= act_refs);
}
/* Free the insn_df structures. */
*************** struct web *
*** 315,322 ****
find_subweb (struct web *web, rtx reg)
{
struct web *w;
! if (GET_CODE (reg) != SUBREG)
! abort ();
for (w = web->subreg_next; w; w = w->subreg_next)
if (GET_MODE (w->orig_x) == GET_MODE (reg)
&& SUBREG_BYTE (w->orig_x) == SUBREG_BYTE (reg))
--- 316,322 ----
find_subweb (struct web *web, rtx reg)
{
struct web *w;
! gcc_assert (GET_CODE (reg) == SUBREG);
for (w = web->subreg_next; w; w = w->subreg_next)
if (GET_MODE (w->orig_x) == GET_MODE (reg)
&& SUBREG_BYTE (w->orig_x) == SUBREG_BYTE (reg))
*************** init_ra (void)
*** 577,584 ****
an_unusable_color++)
if (TEST_HARD_REG_BIT (never_use_colors, an_unusable_color))
break;
! if (an_unusable_color == FIRST_PSEUDO_REGISTER)
! abort ();
orig_max_uid = get_max_uid ();
compute_bb_for_insn ();
--- 577,583 ----
an_unusable_color++)
if (TEST_HARD_REG_BIT (never_use_colors, an_unusable_color))
break;
! gcc_assert (an_unusable_color != FIRST_PSEUDO_REGISTER);
orig_max_uid = get_max_uid ();
compute_bb_for_insn ();
*************** init_ra (void)
*** 589,595 ****
gcc_obstack_init (&ra_obstack);
}
! /* Check the consistency of DF. This aborts if it violates some
invariances we expect. */
static void
--- 588,594 ----
gcc_obstack_init (&ra_obstack);
}
! /* Check the consistency of DF. This asserts if it violates some
invariances we expect. */
static void
*************** check_df (struct df *df)
*** 620,638 ****
{
bitmap_clear (b);
for (link = DF_INSN_DEFS (df, insn); link; link = link->next)
! if (!link->ref || bitmap_bit_p (empty_defs, DF_REF_ID (link->ref))
! || bitmap_bit_p (b, DF_REF_ID (link->ref)))
! abort ();
! else
bitmap_set_bit (b, DF_REF_ID (link->ref));
bitmap_clear (b);
for (link = DF_INSN_USES (df, insn); link; link = link->next)
! if (!link->ref || bitmap_bit_p (empty_uses, DF_REF_ID (link->ref))
! || bitmap_bit_p (b, DF_REF_ID (link->ref)))
! abort ();
! else
bitmap_set_bit (b, DF_REF_ID (link->ref));
}
/* Now the same for the chains per register number. */
--- 619,639 ----
{
bitmap_clear (b);
for (link = DF_INSN_DEFS (df, insn); link; link = link->next)
! {
! gcc_assert (link->ref);
! gcc_assert (!bitmap_bit_p (empty_defs, DF_REF_ID (link->ref)));
! gcc_assert (!bitmap_bit_p (b, DF_REF_ID (link->ref)));
bitmap_set_bit (b, DF_REF_ID (link->ref));
+ }
bitmap_clear (b);
for (link = DF_INSN_USES (df, insn); link; link = link->next)
! {
! gcc_assert (link->ref);
! gcc_assert (!bitmap_bit_p (empty_uses, DF_REF_ID (link->ref)));
! gcc_assert (!bitmap_bit_p (b, DF_REF_ID (link->ref)));
bitmap_set_bit (b, DF_REF_ID (link->ref));
+ }
}
/* Now the same for the chains per register number. */
*************** check_df (struct df *df)
*** 640,658 ****
{
bitmap_clear (b);
for (link = df->regs[regno].defs; link; link = link->next)
! if (!link->ref || bitmap_bit_p (empty_defs, DF_REF_ID (link->ref))
! || bitmap_bit_p (b, DF_REF_ID (link->ref)))
! abort ();
! else
bitmap_set_bit (b, DF_REF_ID (link->ref));
bitmap_clear (b);
for (link = df->regs[regno].uses; link; link = link->next)
! if (!link->ref || bitmap_bit_p (empty_uses, DF_REF_ID (link->ref))
! || bitmap_bit_p (b, DF_REF_ID (link->ref)))
! abort ();
! else
bitmap_set_bit (b, DF_REF_ID (link->ref));
}
BITMAP_XFREE (empty_uses);
--- 641,661 ----
{
bitmap_clear (b);
for (link = df->regs[regno].defs; link; link = link->next)
! {
! gcc_assert (link->ref);
! gcc_assert (!bitmap_bit_p (empty_defs, DF_REF_ID (link->ref)));
! gcc_assert (!bitmap_bit_p (b, DF_REF_ID (link->ref)));
bitmap_set_bit (b, DF_REF_ID (link->ref));
+ }
bitmap_clear (b);
for (link = df->regs[regno].uses; link; link = link->next)
! {
! gcc_assert (link->ref);
! gcc_assert (!bitmap_bit_p (empty_uses, DF_REF_ID (link->ref)));
! gcc_assert (!bitmap_bit_p (b, DF_REF_ID (link->ref)));
bitmap_set_bit (b, DF_REF_ID (link->ref));
+ }
}
BITMAP_XFREE (empty_uses);
Index: ra-colorize.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/ra-colorize.c,v
retrieving revision 1.20
diff -c -3 -p -r1.20 ra-colorize.c
*** ra-colorize.c 29 Jul 2004 14:49:22 -0000 1.20
--- ra-colorize.c 9 Sep 2004 14:25:30 -0000
*************** static struct dlist *mv_frozen, *mv_acti
*** 105,112 ****
static void
push_list (struct dlist *x, struct dlist **list)
{
! if (x->next || x->prev)
! abort ();
x->next = *list;
if (*list)
(*list)->prev = x;
--- 105,112 ----
static void
push_list (struct dlist *x, struct dlist **list)
{
! gcc_assert (!x->next);
! gcc_assert (!x->prev);
x->next = *list;
if (*list)
(*list)->prev = x;
*************** push_list (struct dlist *x, struct dlist
*** 116,123 ****
static void
push_list_end (struct dlist *x, struct dlist **list)
{
! if (x->prev || x->next)
! abort ();
if (!*list)
{
*list = x;
--- 116,123 ----
static void
push_list_end (struct dlist *x, struct dlist **list)
{
! gcc_assert (!x->prev);
! gcc_assert (!x->next);
if (!*list)
{
*list = x;
*************** put_web (struct web *web, enum ra_node_t
*** 195,201 ****
push_list (web->dlink, &WEBS(SIMPLIFY));
break;
default:
! abort ();
}
web->type = type;
}
--- 195,201 ----
push_list (web->dlink, &WEBS(SIMPLIFY));
break;
default:
! gcc_unreachable ();
}
web->type = type;
}
*************** reset_lists (void)
*** 211,219 ****
{
struct dlist *d;
unsigned int i;
! if (WEBS(SIMPLIFY) || WEBS(SIMPLIFY_SPILL) || WEBS(SIMPLIFY_FAT)
! || WEBS(FREEZE) || WEBS(SPILL) || WEBS(SELECT))
! abort ();
while ((d = pop_list (&WEBS(COALESCED))) != NULL)
{
--- 211,223 ----
{
struct dlist *d;
unsigned int i;
!
! gcc_assert (!WEBS(SIMPLIFY));
! gcc_assert (!WEBS(SIMPLIFY_SPILL));
! gcc_assert (!WEBS(SIMPLIFY_FAT));
! gcc_assert (!WEBS(FREEZE));
! gcc_assert (!WEBS(SPILL));
! gcc_assert (!WEBS(SELECT));
while ((d = pop_list (&WEBS(COALESCED))) != NULL)
{
*************** reset_lists (void)
*** 243,255 ****
web->useless_conflicts = NULL;
}
! /* Sanity check, that we only have free, initial or precolored webs. */
for (i = 0; i < num_webs; i++)
{
struct web *web = ID2WEB (i);
! if (web->type != INITIAL && web->type != FREE && web->type != PRECOLORED)
! abort ();
}
free_dlist (&mv_worklist);
free_dlist (&mv_coalesced);
free_dlist (&mv_constrained);
--- 247,262 ----
web->useless_conflicts = NULL;
}
! #ifdef ENABLE_CHECKING
! /* Sanity check, that we only have free, initial or precolored webs. */
for (i = 0; i < num_webs; i++)
{
struct web *web = ID2WEB (i);
!
! gcc_assert (web->type == INITIAL || web->type == FREE
! || web->type == PRECOLORED);
}
+ #endif
free_dlist (&mv_worklist);
free_dlist (&mv_coalesced);
free_dlist (&mv_constrained);
*************** put_web_at_end (struct web *web, enum ra
*** 265,272 ****
{
if (type == PRECOLORED)
type = INITIAL;
! else if (type == SIMPLIFY)
! abort ();
push_list_end (web->dlink, &WEBS(type));
web->type = type;
}
--- 272,279 ----
{
if (type == PRECOLORED)
type = INITIAL;
! else
! gcc_assert (type != SIMPLIFY);
push_list_end (web->dlink, &WEBS(type));
web->type = type;
}
*************** put_move (struct move *move, enum move_t
*** 306,312 ****
push_list (move->dlink, &mv_active);
break;
default:
! abort ();
}
move->type = type;
}
--- 313,319 ----
push_list (move->dlink, &mv_active);
break;
default:
! gcc_unreachable ();
}
move->type = type;
}
*************** remove_move (struct web *web, struct mov
*** 501,508 ****
struct move_list *ml;
remove_move_1 (web, move);
for (ml = web->moves; ml; ml = ml->next)
! if (ml->move == move)
! abort ();
}
/* Merge the moves for the two webs into the first web's movelist. */
--- 508,514 ----
struct move_list *ml;
remove_move_1 (web, move);
for (ml = web->moves; ml; ml = ml->next)
! gcc_assert (ml->move != move);
}
/* Merge the moves for the two webs into the first web's movelist. */
*************** combine (struct web *u, struct web *v)
*** 696,705 ****
{
int i;
struct conflict_link *wl;
! if (u == v || v->type == COALESCED)
! abort ();
! if ((u->regno >= max_normal_pseudo) != (v->regno >= max_normal_pseudo))
! abort ();
remove_web_from_list (v);
put_web (v, COALESCED);
v->alias = u;
--- 702,711 ----
{
int i;
struct conflict_link *wl;
! gcc_assert (u != v);
! gcc_assert (v->type != COALESCED);
! gcc_assert ((u->regno >= max_normal_pseudo)
! == (v->regno >= max_normal_pseudo));
remove_web_from_list (v);
put_web (v, COALESCED);
v->alias = u;
*************** combine (struct web *u, struct web *v)
*** 793,802 ****
conflicts. */
u->num_freedom = hard_regs_count (u->usable_regs);
u->num_freedom -= u->add_hardregs;
! /* The next would mean an invalid coalesced move (both webs have no
! possible hardreg in common), so abort. */
! if (!u->num_freedom)
! abort();
if (u->num_conflicts >= NUM_REGS (u)
&& (u->type == FREEZE || simplify_p (u->type)))
--- 799,807 ----
conflicts. */
u->num_freedom = hard_regs_count (u->usable_regs);
u->num_freedom -= u->add_hardregs;
! /* The next checks for an invalid coalesced move (both webs must have
! possible hardregs in common). */
! gcc_assert (u->num_freedom);
if (u->num_conflicts >= NUM_REGS (u)
&& (u->type == FREEZE || simplify_p (u->type)))
*************** select_spill (void)
*** 970,977 ****
bestd = bestd2;
best = best2;
}
! if (!bestd)
! abort ();
/* Note the potential spill. */
DLIST_WEB (bestd)->was_spilled = 1;
--- 975,981 ----
bestd = bestd2;
best = best2;
}
! gcc_assert (bestd);
/* Note the potential spill. */
DLIST_WEB (bestd)->was_spilled = 1;
*************** colorize_one_web (struct web *web, int h
*** 1429,1435 ****
if (c < 0)
{
/* Guard against a simplified node being spilled. */
! /* Don't abort. This can happen, when e.g. enough registers
are available in colors, but they are not consecutive. This is a
very serious issue if this web is a short live one, because
even if we spill this one here, the situation won't become better
--- 1433,1439 ----
if (c < 0)
{
/* Guard against a simplified node being spilled. */
! /* Don't assert. This can happen, when e.g. enough registers
are available in colors, but they are not consecutive. This is a
very serious issue if this web is a short live one, because
even if we spill this one here, the situation won't become better
*************** colorize_one_web (struct web *web, int h
*** 1440,1447 ****
again. That's why we try to find a neighbor, which spans more
instructions that ourself, and got a color, and try to spill _that_.
! if (DLIST_WEB (d)->was_spilled < 0)
! abort (); */
if (hard && (!web->was_spilled || web->spill_temp))
{
unsigned int loop;
--- 1444,1450 ----
again. That's why we try to find a neighbor, which spans more
instructions that ourself, and got a color, and try to spill _that_.
! gcc_assert (DLIST_WEB (d)->was_spilled >= 0); */
if (hard && (!web->was_spilled || web->spill_temp))
{
unsigned int loop;
*************** colorize_one_web (struct web *web, int h
*** 1536,1543 ****
int old_c = try->color;
if (try->type == COALESCED)
{
! if (alias (try)->type != PRECOLORED)
! abort ();
ra_debug_msg (DUMP_COLORIZE, " breaking alias %d -> %d\n",
try->id, alias (try)->id);
break_precolored_alias (try);
--- 1539,1545 ----
int old_c = try->color;
if (try->type == COALESCED)
{
! gcc_assert (alias (try)->type == PRECOLORED);
ra_debug_msg (DUMP_COLORIZE, " breaking alias %d -> %d\n",
try->id, alias (try)->id);
break_precolored_alias (try);
*************** try_recolor_web (struct web *web)
*** 1800,1808 ****
above what happens, when wide webs are involved, and why in that
case there might actually be some webs spilled although thought to
be colorable. */
! if (cost > cost_neighbors[newcol]
! && nregs == 1 && !TEST_HARD_REG_BIT (wide_seen, newcol))
! abort ();
/* But if the new spill-cost is higher than our own, then really loose.
Respill us and recolor neighbors as before. */
if (cost > web->spill_cost)
--- 1802,1809 ----
above what happens, when wide webs are involved, and why in that
case there might actually be some webs spilled although thought to
be colorable. */
! gcc_assert (cost <= cost_neighbors[newcol]
! || nregs != 1 || TEST_HARD_REG_BIT (wide_seen, newcol));
/* But if the new spill-cost is higher than our own, then really loose.
Respill us and recolor neighbors as before. */
if (cost > web->spill_cost)
*************** try_recolor_web (struct web *web)
*** 1817,1842 ****
struct web *web2 = alias (wl->t);
if (old_colors[web2->id])
{
! if (web2->type == SPILLED)
{
remove_list (web2->dlink, &WEBS(SPILLED));
web2->color = old_colors[web2->id] - 1;
put_web (web2, COLORED);
}
- else if (web2->type == COLORED)
- web2->color = old_colors[web2->id] - 1;
- else if (web2->type == SELECT)
- /* This means, that WEB2 once was a part of a coalesced
- web, which got spilled in the above colorize_one_web()
- call, and whose parts then got split and put back
- onto the SELECT stack. As the cause for that splitting
- (the coloring of WEB) was worthless, we should again
- coalesce the parts, as they were before. For now we
- simply leave them SELECTed, for our caller to take
- care. */
- ;
- else
- abort ();
}
}
}
--- 1818,1846 ----
struct web *web2 = alias (wl->t);
if (old_colors[web2->id])
{
! switch (web2->type)
{
+ case SPILLED:
remove_list (web2->dlink, &WEBS(SPILLED));
web2->color = old_colors[web2->id] - 1;
put_web (web2, COLORED);
+ break;
+ case COLORED:
+ web2->color = old_colors[web2->id] - 1;
+ break;
+ case SELECT:
+ /* This means, that WEB2 once was a part of a coalesced
+ web, which got spilled in the above colorize_one_web()
+ call, and whose parts then got split and put back
+ onto the SELECT stack. As the cause for that splitting
+ (the coloring of WEB) was worthless, we should again
+ coalesce the parts, as they were before. For now we
+ simply leave them SELECTed, for our caller to take
+ care. */
+ break;
+ default:
+ gcc_unreachable ();
}
}
}
}
*************** insert_coalesced_conflicts (void)
*** 1878,1893 ****
when first some webs were coalesced and conflicts
propagated, then some combining narrowed usable_regs and
further coalescing ignored those conflicts. Now there are
! some edges to COALESCED webs but not to it's alias.
! So abort only when they really should conflict. */
! if ((!(tweb->type == PRECOLORED
! || TEST_BIT (sup_igraph, tweb->id * num_webs + wl->t->id))
! || !(wl->t->type == PRECOLORED
! || TEST_BIT (sup_igraph,
! wl->t->id * num_webs + tweb->id)))
! && hard_regs_intersect_p (&tweb->usable_regs,
! &wl->t->usable_regs))
! abort ();
/*if (wl->sub == NULL)
record_conflict (tweb, wl->t);
else
--- 1882,1897 ----
when first some webs were coalesced and conflicts
propagated, then some combining narrowed usable_regs and
further coalescing ignored those conflicts. Now there are
! some edges to COALESCED webs but not to its alias.
! So assert they really don not conflict. */
! gcc_assert (((tweb->type == PRECOLORED
! || TEST_BIT (sup_igraph,
! tweb->id * num_webs + wl->t->id))
! && (wl->t->type == PRECOLORED
! || TEST_BIT (sup_igraph,
! wl->t->id * num_webs + tweb->id)))
! || !hard_regs_intersect_p (&tweb->usable_regs,
! &wl->t->usable_regs));
/*if (wl->sub == NULL)
record_conflict (tweb, wl->t);
else
*************** check_colors (void)
*** 1970,1987 ****
struct web *aweb = alias (web);
struct conflict_link *wl;
int nregs, c;
! if (aweb->type == SPILLED || web->regno >= max_normal_pseudo)
continue;
! else if (aweb->type == COLORED)
! nregs = hard_regno_nregs[aweb->color][GET_MODE (web->orig_x)];
! else if (aweb->type == PRECOLORED)
! nregs = 1;
! else
! abort ();
/* The color must be valid for the original usable_regs. */
for (c = 0; c < nregs; c++)
! if (!TEST_HARD_REG_BIT (web->usable_regs, aweb->color + c))
! abort ();
/* Search the original (pre-coalesce) conflict list. In the current
one some imprecise conflicts may be noted (due to combine() or
insert_coalesced_conflicts() relocating partial conflicts) making
--- 1974,2005 ----
struct web *aweb = alias (web);
struct conflict_link *wl;
int nregs, c;
!
! if (web->regno >= max_normal_pseudo)
continue;
!
! switch (aweb->type)
! {
! case SPILLED:
! continue;
!
! case COLORED:
! nregs = hard_regno_nregs[aweb->color][GET_MODE (web->orig_x)];
! break;
!
! case PRECOLORED:
! nregs = 1;
! break;
!
! default:
! gcc_unreachable ();
! }
!
! #ifdef ENABLE_CHECKING
/* The color must be valid for the original usable_regs. */
for (c = 0; c < nregs; c++)
! gcc_assert (TEST_HARD_REG_BIT (web->usable_regs, aweb->color + c));
! #endif
/* Search the original (pre-coalesce) conflict list. In the current
one some imprecise conflicts may be noted (due to combine() or
insert_coalesced_conflicts() relocating partial conflicts) making
*************** check_colors (void)
*** 2002,2011 ****
nregs2 = 1;
else
continue;
! if (aweb->color >= web2->color + nregs2
! || web2->color >= aweb->color + nregs)
! continue;
! abort ();
}
else
{
--- 2020,2028 ----
nregs2 = 1;
else
continue;
! gcc_assert (aweb->color >= web2->color + nregs2
! || web2->color >= aweb->color + nregs);
! continue;
}
else
{
*************** check_colors (void)
*** 2026,2035 ****
&& GET_MODE_SIZE (GET_MODE (sl->s->orig_x))
>= UNITS_PER_WORD)
sofs = (SUBREG_BYTE (sl->s->orig_x) / UNITS_PER_WORD);
! if ((tcol + tofs >= scol + sofs + ssize)
! || (scol + sofs >= tcol + tofs + tsize))
! continue;
! abort ();
}
}
}
--- 2043,2051 ----
&& GET_MODE_SIZE (GET_MODE (sl->s->orig_x))
>= UNITS_PER_WORD)
sofs = (SUBREG_BYTE (sl->s->orig_x) / UNITS_PER_WORD);
! gcc_assert ((tcol + tofs >= scol + sofs + ssize)
! || (scol + sofs >= tcol + tofs + tsize));
! continue;
}
}
}
*************** static void
*** 2070,2077 ****
break_aliases_to_web (struct web *web)
{
struct dlist *d, *d_next;
! if (web->type != SPILLED)
! abort ();
for (d = WEBS(COALESCED); d; d = d_next)
{
struct web *other = DLIST_WEB (d);
--- 2086,2092 ----
break_aliases_to_web (struct web *web)
{
struct dlist *d, *d_next;
! gcc_assert (web->type == SPILLED);
for (d = WEBS(COALESCED); d; d = d_next)
{
struct web *other = DLIST_WEB (d);
*************** break_precolored_alias (struct web *web)
*** 2115,2122 ****
struct conflict_link *wl;
unsigned int c = pre->color;
unsigned int nregs = hard_regno_nregs[c][GET_MODE (web->orig_x)];
! if (pre->type != PRECOLORED)
! abort ();
unalias_web (web);
/* Now we need to look at each conflict X of WEB, if it conflicts
with [PRE, PRE+nregs), and remove such conflicts, of X has not other
--- 2130,2136 ----
struct conflict_link *wl;
unsigned int c = pre->color;
unsigned int nregs = hard_regno_nregs[c][GET_MODE (web->orig_x)];
! gcc_assert (pre->type == PRECOLORED);
unalias_web (web);
/* Now we need to look at each conflict X of WEB, if it conflicts
with [PRE, PRE+nregs), and remove such conflicts, of X has not other
*************** restore_conflicts_from_coalesce (struct
*** 2208,2220 ****
struct sub_conflict *sl;
wl = *pcl;
*pcl = wl->next;
! if (!other->have_orig_conflicts && other->type != PRECOLORED)
! abort ();
for (owl = other->orig_conflict_list; owl; owl = owl->next)
if (owl->t == web)
break;
! if (owl)
! abort ();
opcl = &(other->conflict_list);
while (*opcl)
{
--- 2222,2233 ----
struct sub_conflict *sl;
wl = *pcl;
*pcl = wl->next;
! gcc_assert (other->have_orig_conflicts
! || other->type == PRECOLORED);
for (owl = other->orig_conflict_list; owl; owl = owl->next)
if (owl->t == web)
break;
! gcc_assert (!owl);
opcl = &(other->conflict_list);
while (*opcl)
{
*************** restore_conflicts_from_coalesce (struct
*** 2229,2236 ****
opcl = &((*opcl)->next);
}
}
! if (!owl && other->type != PRECOLORED)
! abort ();
/* wl and owl contain the edge data to be deleted. */
RESET_BIT (sup_igraph, web->id * num_webs + other->id);
RESET_BIT (sup_igraph, other->id * num_webs + web->id);
--- 2242,2248 ----
opcl = &((*opcl)->next);
}
}
! gcc_assert (owl || other->type == PRECOLORED);
/* wl and owl contain the edge data to be deleted. */
RESET_BIT (sup_igraph, web->id * num_webs + other->id);
RESET_BIT (sup_igraph, other->id * num_webs + web->id);
*************** sort_and_combine_web_pairs (int for_move
*** 2429,2436 ****
sorted = xmalloc (num_web_pairs * sizeof (sorted[0]));
for (p = web_pair_list, i = 0; p; p = p->next_list)
sorted[i++] = p;
! if (i != num_web_pairs)
! abort ();
qsort (sorted, num_web_pairs, sizeof (sorted[0]), comp_web_pairs);
/* After combining one pair, we actually should adjust the savings
--- 2441,2447 ----
sorted = xmalloc (num_web_pairs * sizeof (sorted[0]));
for (p = web_pair_list, i = 0; p; p = p->next_list)
sorted[i++] = p;
! gcc_assert (i == num_web_pairs);
qsort (sorted, num_web_pairs, sizeof (sorted[0]), comp_web_pairs);
/* After combining one pair, we actually should adjust the savings
*************** check_uncoalesced_moves (void)
*** 2624,2640 ****
s = t;
t = h;
}
! if (s != t
! && m->type != CONSTRAINED
! /* Following can happen when a move was coalesced, but later
! broken up again. Then s!=t, but m is still MV_COALESCED. */
! && m->type != MV_COALESCED
! && t->type != PRECOLORED
! && ((s->type == PRECOLORED && ok (t, s))
! || s->type != PRECOLORED)
! && !TEST_BIT (sup_igraph, s->id * num_webs + t->id)
! && !TEST_BIT (sup_igraph, t->id * num_webs + s->id))
! abort ();
}
}
--- 2635,2650 ----
s = t;
t = h;
}
! gcc_assert (s == t
! || m->type == CONSTRAINED
! /* Following can happen when a move was coalesced, but
! later broken up again. Then s!=t, but m is still
! MV_COALESCED. */
! || m->type == MV_COALESCED
! || t->type == PRECOLORED
! || (s->type == PRECOLORED && !ok (t, s))
! || TEST_BIT (sup_igraph, s->id * num_webs + t->id)
! || TEST_BIT (sup_igraph, t->id * num_webs + s->id));
}
}
Index: ra-rewrite.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/ra-rewrite.c,v
retrieving revision 1.25
diff -c -3 -p -r1.25 ra-rewrite.c
*** ra-rewrite.c 18 Aug 2004 08:24:02 -0000 1.25
--- ra-rewrite.c 9 Sep 2004 14:25:34 -0000
*************** spill_coalescing (sbitmap coalesce, sbit
*** 119,126 ****
T from the web which was coalesced into T, which at the time
of combine() were not already on the SELECT stack or were
itself coalesced to something other. */
! if (t->type != SPILLED || s->type != SPILLED)
! abort ();
remove_list (t->dlink, &WEBS(SPILLED));
put_web (t, COALESCED);
t->alias = s;
--- 119,126 ----
T from the web which was coalesced into T, which at the time
of combine() were not already on the SELECT stack or were
itself coalesced to something other. */
! gcc_assert (t->type == SPILLED
! && s->type == SPILLED);
remove_list (t->dlink, &WEBS(SPILLED));
put_web (t, COALESCED);
t->alias = s;
*************** slots_overlap_p (rtx s1, rtx s2)
*** 570,577 ****
return 0;
return 1;
}
! if (!MEM_P (s1) || GET_CODE (s2) != MEM)
! abort ();
s1 = XEXP (s1, 0);
s2 = XEXP (s2, 0);
if (GET_CODE (s1) != PLUS || !REG_P (XEXP (s1, 0))
--- 570,576 ----
return 0;
return 1;
}
! gcc_assert (MEM_P (s1) && GET_CODE (s2) == MEM);
s1 = XEXP (s1, 0);
s2 = XEXP (s2, 0);
if (GET_CODE (s1) != PLUS || !REG_P (XEXP (s1, 0))
*************** emit_loads (struct rewrite_info *ri, int
*** 873,880 ****
if (!web)
continue;
supweb = find_web_for_subweb (web);
! if (supweb->regno >= max_normal_pseudo)
! abort ();
/* Check for web being a spilltemp, if we only want to
load spilltemps. Also remember, that we emitted that
load, which we don't need to do when we have a death,
--- 872,878 ----
if (!web)
continue;
supweb = find_web_for_subweb (web);
! gcc_assert (supweb->regno < max_normal_pseudo);
/* Check for web being a spilltemp, if we only want to
load spilltemps. Also remember, that we emitted that
load, which we don't need to do when we have a death,
*************** emit_loads (struct rewrite_info *ri, int
*** 900,913 ****
(at least then disallow spilling them, which we already ensure
when flag_ra_break_aliases), or not take the pattern but a
stackslot. */
! if (aweb != supweb)
! abort ();
slot = copy_rtx (supweb->pattern);
reg = copy_rtx (supweb->orig_x);
/* Sanity check. orig_x should be a REG rtx, which should be
shared over all RTL, so copy_rtx should have no effect. */
! if (reg != supweb->orig_x)
! abort ();
}
else
{
--- 898,909 ----
(at least then disallow spilling them, which we already ensure
when flag_ra_break_aliases), or not take the pattern but a
stackslot. */
! gcc_assert (aweb == supweb);
slot = copy_rtx (supweb->pattern);
reg = copy_rtx (supweb->orig_x);
/* Sanity check. orig_x should be a REG rtx, which should be
shared over all RTL, so copy_rtx should have no effect. */
! gcc_assert (reg == supweb->orig_x);
}
else
{
*************** reloads_to_loads (struct rewrite_info *r
*** 1022,1029 ****
{
struct web *web2 = ID2WEB (j);
struct web *aweb2 = alias (find_web_for_subweb (web2));
! if (spill_is_free (&(ri->colors_in_use), aweb2) == 0)
! abort ();
if (spill_same_color_p (supweb, aweb2)
/* && interfere (web, web2) */)
{
--- 1018,1024 ----
{
struct web *web2 = ID2WEB (j);
struct web *aweb2 = alias (find_web_for_subweb (web2));
! gcc_assert (spill_is_free (&(ri->colors_in_use), aweb2) != 0);
if (spill_same_color_p (supweb, aweb2)
/* && interfere (web, web2) */)
{
*************** rewrite_program2 (bitmap new_deaths)
*** 1396,1403 ****
ri.need_load = 1;
emit_loads (&ri, nl_first_reload, last_block_insn);
! if (ri.nl_size != 0 /*|| ri.num_reloads != 0*/)
! abort ();
if (!insn)
break;
}
--- 1391,1397 ----
ri.need_load = 1;
emit_loads (&ri, nl_first_reload, last_block_insn);
! gcc_assert (ri.nl_size == 0);
if (!insn)
break;
}
*************** emit_colors (struct df *df)
*** 1677,1684 ****
continue;
if (web->type == COALESCED && alias (web)->type == COLORED)
continue;
! if (web->reg_rtx || web->regno < FIRST_PSEUDO_REGISTER)
! abort ();
if (web->regno >= max_normal_pseudo)
{
--- 1671,1678 ----
continue;
if (web->type == COALESCED && alias (web)->type == COLORED)
continue;
! gcc_assert (!web->reg_rtx);
! gcc_assert (web->regno >= FIRST_PSEUDO_REGISTER);
if (web->regno >= max_normal_pseudo)
{
Index: real.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/real.c,v
retrieving revision 1.146
diff -c -3 -p -r1.146 real.c
*** real.c 25 Jul 2004 17:57:23 -0000 1.146
--- real.c 9 Sep 2004 14:25:41 -0000
*************** do_add (REAL_VALUE_TYPE *r, const REAL_V
*** 577,583 ****
break;
default:
! abort ();
}
/* Swap the arguments such that A has the larger exponent. */
--- 577,583 ----
break;
default:
! gcc_unreachable ();
}
/* Swap the arguments such that A has the larger exponent. */
*************** do_multiply (REAL_VALUE_TYPE *r, const R
*** 708,714 ****
break;
default:
! abort ();
}
if (r == a || r == b)
--- 708,714 ----
break;
default:
! gcc_unreachable ();
}
if (r == a || r == b)
*************** do_divide (REAL_VALUE_TYPE *r, const REA
*** 850,856 ****
break;
default:
! abort ();
}
if (r == a || r == b)
--- 850,856 ----
break;
default:
! gcc_unreachable ();
}
if (r == a || r == b)
*************** do_compare (const REAL_VALUE_TYPE *a, co
*** 929,935 ****
break;
default:
! abort ();
}
if (a->sign != b->sign)
--- 929,935 ----
break;
default:
! gcc_unreachable ();
}
if (a->sign != b->sign)
*************** do_fix_trunc (REAL_VALUE_TYPE *r, const
*** 967,973 ****
break;
default:
! abort ();
}
}
--- 967,973 ----
break;
default:
! gcc_unreachable ();
}
}
*************** real_arithmetic (REAL_VALUE_TYPE *r, int
*** 1031,1037 ****
break;
default:
! abort ();
}
}
--- 1031,1037 ----
break;
default:
! gcc_unreachable ();
}
}
*************** real_compare (int icode, const REAL_VALU
*** 1084,1090 ****
return do_compare (op0, op1, 0) != 0;
default:
! abort ();
}
}
--- 1084,1090 ----
return do_compare (op0, op1, 0) != 0;
default:
! gcc_unreachable ();
}
}
*************** real_exponent (const REAL_VALUE_TYPE *r)
*** 1103,1109 ****
case rvc_normal:
return REAL_EXP (r);
default:
! abort ();
}
}
--- 1103,1109 ----
case rvc_normal:
return REAL_EXP (r);
default:
! gcc_unreachable ();
}
}
*************** real_ldexp (REAL_VALUE_TYPE *r, const RE
*** 1131,1137 ****
break;
default:
! abort ();
}
}
--- 1131,1137 ----
break;
default:
! gcc_unreachable ();
}
}
*************** real_identical (const REAL_VALUE_TYPE *a
*** 1199,1205 ****
break;
default:
! abort ();
}
for (i = 0; i < SIGSZ; ++i)
--- 1199,1205 ----
break;
default:
! gcc_unreachable ();
}
for (i = 0; i < SIGSZ; ++i)
*************** real_to_integer (const REAL_VALUE_TYPE *
*** 1279,1292 ****
if (HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_LONG)
i = r->sig[SIGSZ-1];
! else if (HOST_BITS_PER_WIDE_INT == 2*HOST_BITS_PER_LONG)
{
i = r->sig[SIGSZ-1];
i = i << (HOST_BITS_PER_LONG - 1) << 1;
i |= r->sig[SIGSZ-2];
}
- else
- abort ();
i >>= HOST_BITS_PER_WIDE_INT - REAL_EXP (r);
--- 1279,1291 ----
if (HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_LONG)
i = r->sig[SIGSZ-1];
! else
{
+ gcc_assert (HOST_BITS_PER_WIDE_INT == 2 * HOST_BITS_PER_LONG);
i = r->sig[SIGSZ-1];
i = i << (HOST_BITS_PER_LONG - 1) << 1;
i |= r->sig[SIGSZ-2];
}
i >>= HOST_BITS_PER_WIDE_INT - REAL_EXP (r);
*************** real_to_integer (const REAL_VALUE_TYPE *
*** 1295,1301 ****
return i;
default:
! abort ();
}
}
--- 1294,1300 ----
return i;
default:
! gcc_unreachable ();
}
}
*************** real_to_integer2 (HOST_WIDE_INT *plow, H
*** 1346,1353 ****
high = t.sig[SIGSZ-1];
low = t.sig[SIGSZ-2];
}
! else if (HOST_BITS_PER_WIDE_INT == 2*HOST_BITS_PER_LONG)
{
high = t.sig[SIGSZ-1];
high = high << (HOST_BITS_PER_LONG - 1) << 1;
high |= t.sig[SIGSZ-2];
--- 1345,1353 ----
high = t.sig[SIGSZ-1];
low = t.sig[SIGSZ-2];
}
! else
{
+ gcc_assert (HOST_BITS_PER_WIDE_INT == 2*HOST_BITS_PER_LONG);
high = t.sig[SIGSZ-1];
high = high << (HOST_BITS_PER_LONG - 1) << 1;
high |= t.sig[SIGSZ-2];
*************** real_to_integer2 (HOST_WIDE_INT *plow, H
*** 1356,1363 ****
low = low << (HOST_BITS_PER_LONG - 1) << 1;
low |= t.sig[SIGSZ-4];
}
- else
- abort ();
if (r->sign)
{
--- 1356,1361 ----
*************** real_to_integer2 (HOST_WIDE_INT *plow, H
*** 1369,1375 ****
break;
default:
! abort ();
}
*plow = low;
--- 1367,1373 ----
break;
default:
! gcc_unreachable ();
}
*plow = low;
*************** real_to_decimal (char *str, const REAL_V
*** 1446,1452 ****
strcpy (str, (r.sign ? "-NaN" : "+NaN"));
return;
default:
! abort ();
}
/* Bound the number of digits printed by the size of the representation. */
--- 1444,1450 ----
strcpy (str, (r.sign ? "-NaN" : "+NaN"));
return;
default:
! gcc_unreachable ();
}
/* Bound the number of digits printed by the size of the representation. */
*************** real_to_decimal (char *str, const REAL_V
*** 1463,1470 ****
/* Bound the number of digits printed by the size of the output buffer. */
max_digits = buf_size - 1 - 1 - 2 - max_digits - 1;
! if (max_digits > buf_size)
! abort ();
if (digits > max_digits)
digits = max_digits;
--- 1461,1467 ----
/* Bound the number of digits printed by the size of the output buffer. */
max_digits = buf_size - 1 - 1 - 2 - max_digits - 1;
! gcc_assert (max_digits <= buf_size);
if (digits > max_digits)
digits = max_digits;
*************** real_to_decimal (char *str, const REAL_V
*** 1607,1614 ****
do_multiply (&r, &r, ten);
digit = rtd_divmod (&r, &pten);
dec_exp -= 1;
! if (digit == 0)
! abort ();
}
/* ... or overflow. */
--- 1604,1610 ----
do_multiply (&r, &r, ten);
digit = rtd_divmod (&r, &pten);
dec_exp -= 1;
! gcc_assert (digit != 0);
}
/* ... or overflow. */
*************** real_to_decimal (char *str, const REAL_V
*** 1619,1628 ****
*p++ = '0';
dec_exp += 1;
}
- else if (digit > 10)
- abort ();
else
! *p++ = digit + '0';
/* Generate subsequent digits. */
while (--digits > 0)
--- 1615,1625 ----
*p++ = '0';
dec_exp += 1;
}
else
! {
! gcc_assert (digit <= 10);
! *p++ = digit + '0';
! }
/* Generate subsequent digits. */
while (--digits > 0)
*************** real_to_hexadecimal (char *str, const RE
*** 1713,1719 ****
strcpy (str, (r->sign ? "-NaN" : "+NaN"));
return;
default:
! abort ();
}
if (digits == 0)
--- 1710,1716 ----
strcpy (str, (r->sign ? "-NaN" : "+NaN"));
return;
default:
! gcc_unreachable ();
}
if (digits == 0)
*************** real_to_hexadecimal (char *str, const RE
*** 1723,1730 ****
sprintf (exp_buf, "p%+d", exp);
max_digits = buf_size - strlen (exp_buf) - r->sign - 4 - 1;
! if (max_digits > buf_size)
! abort ();
if (digits > max_digits)
digits = max_digits;
--- 1720,1726 ----
sprintf (exp_buf, "p%+d", exp);
max_digits = buf_size - strlen (exp_buf) - r->sign - 4 - 1;
! gcc_assert (max_digits <= buf_size);
if (digits > max_digits)
digits = max_digits;
*************** real_from_integer (REAL_VALUE_TYPE *r, e
*** 1982,1989 ****
r->sig[SIGSZ-2] = low;
memset (r->sig, 0, sizeof(long)*(SIGSZ-2));
}
! else if (HOST_BITS_PER_LONG*2 == HOST_BITS_PER_WIDE_INT)
{
r->sig[SIGSZ-1] = high >> (HOST_BITS_PER_LONG - 1) >> 1;
r->sig[SIGSZ-2] = high;
r->sig[SIGSZ-3] = low >> (HOST_BITS_PER_LONG - 1) >> 1;
--- 1978,1986 ----
r->sig[SIGSZ-2] = low;
memset (r->sig, 0, sizeof(long)*(SIGSZ-2));
}
! else
{
+ gcc_assert (HOST_BITS_PER_LONG*2 == HOST_BITS_PER_WIDE_INT);
r->sig[SIGSZ-1] = high >> (HOST_BITS_PER_LONG - 1) >> 1;
r->sig[SIGSZ-2] = high;
r->sig[SIGSZ-3] = low >> (HOST_BITS_PER_LONG - 1) >> 1;
*************** real_from_integer (REAL_VALUE_TYPE *r, e
*** 1991,1998 ****
if (SIGSZ > 4)
memset (r->sig, 0, sizeof(long)*(SIGSZ-4));
}
- else
- abort ();
normalize (r);
}
--- 1988,1993 ----
*************** ten_to_ptwo (int n)
*** 2008,2015 ****
{
static REAL_VALUE_TYPE tens[EXP_BITS];
! if (n < 0 || n >= EXP_BITS)
! abort ();
if (tens[n].cl == rvc_zero)
{
--- 2003,2010 ----
{
static REAL_VALUE_TYPE tens[EXP_BITS];
! gcc_assert (n >= 0);
! gcc_assert (n < EXP_BITS);
if (tens[n].cl == rvc_zero)
{
*************** ten_to_mptwo (int n)
*** 2040,2047 ****
{
static REAL_VALUE_TYPE tens[EXP_BITS];
! if (n < 0 || n >= EXP_BITS)
! abort ();
if (tens[n].cl == rvc_zero)
do_divide (&tens[n], real_digit (1), ten_to_ptwo (n));
--- 2035,2042 ----
{
static REAL_VALUE_TYPE tens[EXP_BITS];
! gcc_assert (n >= 0);
! gcc_assert (n < EXP_BITS);
if (tens[n].cl == rvc_zero)
do_divide (&tens[n], real_digit (1), ten_to_ptwo (n));
*************** real_digit (int n)
*** 2056,2063 ****
{
static REAL_VALUE_TYPE num[10];
! if (n < 0 || n > 9)
! abort ();
if (n > 0 && num[n].cl == rvc_zero)
real_from_integer (&num[n], VOIDmode, n, 0, 1);
--- 2051,2058 ----
{
static REAL_VALUE_TYPE num[10];
! gcc_assert (n >= 0);
! gcc_assert (n <= 9);
if (n > 0 && num[n].cl == rvc_zero)
real_from_integer (&num[n], VOIDmode, n, 0, 1);
*************** real_nan (REAL_VALUE_TYPE *r, const char
*** 2111,2118 ****
const struct real_format *fmt;
fmt = REAL_MODE_FORMAT (mode);
! if (fmt == NULL)
! abort ();
if (*str == 0)
{
--- 2106,2112 ----
const struct real_format *fmt;
fmt = REAL_MODE_FORMAT (mode);
! gcc_assert (fmt);
if (*str == 0)
{
*************** real_nan (REAL_VALUE_TYPE *r, const char
*** 2163,2169 ****
add_significands (r, r, &u);
break;
default:
! abort ();
}
get_zero (&u, 0);
--- 2157,2163 ----
add_significands (r, r, &u);
break;
default:
! gcc_unreachable ();
}
get_zero (&u, 0);
*************** real_maxval (REAL_VALUE_TYPE *r, int sig
*** 2201,2208 ****
int np2;
fmt = REAL_MODE_FORMAT (mode);
! if (fmt == NULL)
! abort ();
r->cl = rvc_normal;
r->sign = sign;
--- 2195,2201 ----
int np2;
fmt = REAL_MODE_FORMAT (mode);
! gcc_assert (fmt);
r->cl = rvc_normal;
r->sign = sign;
*************** round_for_format (const struct real_form
*** 2271,2277 ****
break;
default:
! abort ();
}
/* If we're not base2, normalize the exponent to a multiple of
--- 2264,2270 ----
break;
default:
! gcc_unreachable ();
}
/* If we're not base2, normalize the exponent to a multiple of
*************** real_convert (REAL_VALUE_TYPE *r, enum m
*** 2375,2382 ****
const struct real_format *fmt;
fmt = REAL_MODE_FORMAT (mode);
! if (fmt == NULL)
! abort ();
*r = *a;
round_for_format (fmt, r);
--- 2368,2374 ----
const struct real_format *fmt;
fmt = REAL_MODE_FORMAT (mode);
! gcc_assert (fmt);
*r = *a;
round_for_format (fmt, r);
*************** real_to_target (long *buf, const REAL_VA
*** 2437,2444 ****
const struct real_format *fmt;
fmt = REAL_MODE_FORMAT (mode);
! if (fmt == NULL)
! abort ();
return real_to_target_fmt (buf, r, fmt);
}
--- 2429,2435 ----
const struct real_format *fmt;
fmt = REAL_MODE_FORMAT (mode);
! gcc_assert (fmt);
return real_to_target_fmt (buf, r, fmt);
}
*************** real_from_target (REAL_VALUE_TYPE *r, co
*** 2462,2469 ****
const struct real_format *fmt;
fmt = REAL_MODE_FORMAT (mode);
! if (fmt == NULL)
! abort ();
(*fmt->decode) (fmt, r, buf);
}
--- 2453,2459 ----
const struct real_format *fmt;
fmt = REAL_MODE_FORMAT (mode);
! gcc_assert (fmt);
(*fmt->decode) (fmt, r, buf);
}
*************** real_hash (const REAL_VALUE_TYPE *r)
*** 2512,2518 ****
break;
default:
! abort ();
}
if (sizeof(unsigned long) > sizeof(unsigned int))
--- 2502,2508 ----
break;
default:
! gcc_unreachable ();
}
if (sizeof(unsigned long) > sizeof(unsigned int))
*************** encode_ieee_single (const struct real_fo
*** 2596,2602 ****
break;
default:
! abort ();
}
buf[0] = image;
--- 2586,2592 ----
break;
default:
! gcc_unreachable ();
}
buf[0] = image;
*************** encode_ieee_double (const struct real_fo
*** 2781,2787 ****
break;
default:
! abort ();
}
if (FLOAT_WORDS_BIG_ENDIAN)
--- 2771,2777 ----
break;
default:
! gcc_unreachable ();
}
if (FLOAT_WORDS_BIG_ENDIAN)
*************** encode_ieee_extended (const struct real_
*** 3004,3011 ****
else
{
exp += 16383 - 1;
! if (exp < 0)
! abort ();
}
image_hi |= exp;
--- 2994,3000 ----
else
{
exp += 16383 - 1;
! gcc_assert (exp >= 0);
}
image_hi |= exp;
*************** encode_ieee_extended (const struct real_
*** 3024,3030 ****
break;
default:
! abort ();
}
buf[0] = sig_lo, buf[1] = sig_hi, buf[2] = image_hi;
--- 3013,3019 ----
break;
default:
! gcc_unreachable ();
}
buf[0] = sig_lo, buf[1] = sig_hi, buf[2] = image_hi;
*************** encode_ieee_quad (const struct real_form
*** 3521,3527 ****
break;
default:
! abort ();
}
if (FLOAT_WORDS_BIG_ENDIAN)
--- 3510,3516 ----
break;
default:
! gcc_unreachable ();
}
if (FLOAT_WORDS_BIG_ENDIAN)
*************** encode_vax_f (const struct real_format *
*** 3738,3744 ****
break;
default:
! abort ();
}
buf[0] = image;
--- 3727,3733 ----
break;
default:
! gcc_unreachable ();
}
buf[0] = image;
*************** encode_vax_d (const struct real_format *
*** 3809,3815 ****
break;
default:
! abort ();
}
if (FLOAT_WORDS_BIG_ENDIAN)
--- 3798,3804 ----
break;
default:
! gcc_unreachable ();
}
if (FLOAT_WORDS_BIG_ENDIAN)
*************** encode_vax_g (const struct real_format *
*** 3909,3915 ****
break;
default:
! abort ();
}
if (FLOAT_WORDS_BIG_ENDIAN)
--- 3898,3904 ----
break;
default:
! gcc_unreachable ();
}
if (FLOAT_WORDS_BIG_ENDIAN)
*************** encode_i370_single (const struct real_fo
*** 4060,4066 ****
break;
default:
! abort ();
}
buf[0] = image;
--- 4049,4055 ----
break;
default:
! gcc_unreachable ();
}
buf[0] = image;
*************** encode_i370_double (const struct real_fo
*** 4129,4135 ****
break;
default:
! abort ();
}
if (FLOAT_WORDS_BIG_ENDIAN)
--- 4118,4124 ----
break;
default:
! gcc_unreachable ();
}
if (FLOAT_WORDS_BIG_ENDIAN)
*************** encode_c4x_single (const struct real_for
*** 4272,4278 ****
break;
default:
! abort ();
}
image = ((exp & 0xff) << 24) | (sig & 0xffffff);
--- 4261,4267 ----
break;
default:
! gcc_unreachable ();
}
image = ((exp & 0xff) << 24) | (sig & 0xffffff);
*************** encode_c4x_extended (const struct real_f
*** 4350,4356 ****
break;
default:
! abort ();
}
exp = (exp & 0xff) << 24;
--- 4339,4345 ----
break;
default:
! gcc_unreachable ();
}
exp = (exp & 0xff) << 24;
Index: recog.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/recog.c,v
retrieving revision 1.209
diff -c -3 -p -r1.209 recog.c
*** recog.c 9 Aug 2004 17:43:17 -0000 1.209
--- recog.c 9 Sep 2004 14:25:47 -0000
*************** validate_change (rtx object, rtx *loc, r
*** 211,218 ****
if (old == new || rtx_equal_p (old, new))
return 1;
! if (in_group == 0 && num_changes != 0)
! abort ();
*loc = new;
--- 211,217 ----
if (old == new || rtx_equal_p (old, new))
return 1;
! gcc_assert (in_group != 0 || num_changes == 0);
*loc = new;
*************** validate_replace_rtx_1 (rtx *loc, rtx fr
*** 489,497 ****
&& GET_CODE (SET_SRC (XVECEXP (x, 0, j))) == ASM_OPERANDS)
{
/* Verify that operands are really shared. */
! if (ASM_OPERANDS_INPUT_VEC (SET_SRC (XVECEXP (x, 0, 0))) !=
! ASM_OPERANDS_INPUT_VEC (SET_SRC (XVECEXP (x, 0, j))))
! abort ();
validate_replace_rtx_1 (&SET_DEST (XVECEXP (x, 0, j)),
from, to, object);
}
--- 488,496 ----
&& GET_CODE (SET_SRC (XVECEXP (x, 0, j))) == ASM_OPERANDS)
{
/* Verify that operands are really shared. */
! gcc_assert (ASM_OPERANDS_INPUT_VEC (SET_SRC (XVECEXP (x, 0, 0)))
! == ASM_OPERANDS_INPUT_VEC (SET_SRC (XVECEXP
! (x, 0, j))));
validate_replace_rtx_1 (&SET_DEST (XVECEXP (x, 0, j)),
from, to, object);
}
*************** asm_operand_ok (rtx op, const char *cons
*** 1567,1574 ****
int result = 0;
/* Use constrain_operands after reload. */
! if (reload_completed)
! abort ();
while (*constraint)
{
--- 1566,1572 ----
int result = 0;
/* Use constrain_operands after reload. */
! gcc_assert (!reload_completed);
while (*constraint)
{
*************** extract_insn (rtx insn)
*** 2008,2015 ****
/* This insn is an `asm' with operands. */
/* expand_asm_operands makes sure there aren't too many operands. */
! if (noperands > MAX_RECOG_OPERANDS)
! abort ();
/* Now get the operand values and constraints out of the insn. */
decode_asm_operands (body, recog_data.operand,
--- 2006,2012 ----
/* This insn is an `asm' with operands. */
/* expand_asm_operands makes sure there aren't too many operands. */
! gcc_assert (noperands <= MAX_RECOG_OPERANDS);
/* Now get the operand values and constraints out of the insn. */
decode_asm_operands (body, recog_data.operand,
*************** extract_insn (rtx insn)
*** 2057,2064 ****
: recog_data.constraints[i][0] == '+' ? OP_INOUT
: OP_IN);
! if (recog_data.n_alternatives > MAX_RECOG_ALTERNATIVES)
! abort ();
}
/* After calling extract_insn, you can use this function to extract some
--- 2054,2060 ----
: recog_data.constraints[i][0] == '+' ? OP_INOUT
: OP_IN);
! gcc_assert (recog_data.n_alternatives <= MAX_RECOG_ALTERNATIVES);
}
/* After calling extract_insn, you can use this function to extract some
*************** static int peep2_current;
*** 2815,2822 ****
rtx
peep2_next_insn (int n)
{
! if (n >= MAX_INSNS_PER_PEEP2 + 1)
! abort ();
n += peep2_current;
if (n >= MAX_INSNS_PER_PEEP2 + 1)
--- 2811,2817 ----
rtx
peep2_next_insn (int n)
{
! gcc_assert (n < MAX_INSNS_PER_PEEP2 + 1);
n += peep2_current;
if (n >= MAX_INSNS_PER_PEEP2 + 1)
*************** peep2_next_insn (int n)
*** 2833,2847 ****
int
peep2_regno_dead_p (int ofs, int regno)
{
! if (ofs >= MAX_INSNS_PER_PEEP2 + 1)
! abort ();
ofs += peep2_current;
if (ofs >= MAX_INSNS_PER_PEEP2 + 1)
ofs -= MAX_INSNS_PER_PEEP2 + 1;
! if (peep2_insn_data[ofs].insn == NULL_RTX)
! abort ();
return ! REGNO_REG_SET_P (peep2_insn_data[ofs].live_before, regno);
}
--- 2828,2840 ----
int
peep2_regno_dead_p (int ofs, int regno)
{
! gcc_assert (ofs < MAX_INSNS_PER_PEEP2 + 1);
ofs += peep2_current;
if (ofs >= MAX_INSNS_PER_PEEP2 + 1)
ofs -= MAX_INSNS_PER_PEEP2 + 1;
! gcc_assert (peep2_insn_data[ofs].insn != NULL_RTX);
return ! REGNO_REG_SET_P (peep2_insn_data[ofs].live_before, regno);
}
*************** peep2_reg_dead_p (int ofs, rtx reg)
*** 2853,2867 ****
{
int regno, n;
! if (ofs >= MAX_INSNS_PER_PEEP2 + 1)
! abort ();
ofs += peep2_current;
if (ofs >= MAX_INSNS_PER_PEEP2 + 1)
ofs -= MAX_INSNS_PER_PEEP2 + 1;
! if (peep2_insn_data[ofs].insn == NULL_RTX)
! abort ();
regno = REGNO (reg);
n = hard_regno_nregs[regno][GET_MODE (reg)];
--- 2846,2858 ----
{
int regno, n;
! gcc_assert (ofs < MAX_INSNS_PER_PEEP2 + 1);
ofs += peep2_current;
if (ofs >= MAX_INSNS_PER_PEEP2 + 1)
ofs -= MAX_INSNS_PER_PEEP2 + 1;
! gcc_assert (peep2_insn_data[ofs].insn != NULL_RTX);
regno = REGNO (reg);
n = hard_regno_nregs[regno][GET_MODE (reg)];
*************** peep2_find_free_register (int from, int
*** 2891,2898 ****
HARD_REG_SET live;
int i;
! if (from >= MAX_INSNS_PER_PEEP2 + 1 || to >= MAX_INSNS_PER_PEEP2 + 1)
! abort ();
from += peep2_current;
if (from >= MAX_INSNS_PER_PEEP2 + 1)
--- 2882,2889 ----
HARD_REG_SET live;
int i;
! gcc_assert (from < MAX_INSNS_PER_PEEP2 + 1);
! gcc_assert (to < MAX_INSNS_PER_PEEP2 + 1);
from += peep2_current;
if (from >= MAX_INSNS_PER_PEEP2 + 1)
*************** peep2_find_free_register (int from, int
*** 2901,2908 ****
if (to >= MAX_INSNS_PER_PEEP2 + 1)
to -= MAX_INSNS_PER_PEEP2 + 1;
! if (peep2_insn_data[from].insn == NULL_RTX)
! abort ();
REG_SET_TO_HARD_REG_SET (live, peep2_insn_data[from].live_before);
while (from != to)
--- 2892,2898 ----
if (to >= MAX_INSNS_PER_PEEP2 + 1)
to -= MAX_INSNS_PER_PEEP2 + 1;
! gcc_assert (peep2_insn_data[from].insn != NULL_RTX);
REG_SET_TO_HARD_REG_SET (live, peep2_insn_data[from].live_before);
while (from != to)
*************** peep2_find_free_register (int from, int
*** 2911,2918 ****
if (++from >= MAX_INSNS_PER_PEEP2 + 1)
from = 0;
! if (peep2_insn_data[from].insn == NULL_RTX)
! abort ();
REG_SET_TO_HARD_REG_SET (this_live, peep2_insn_data[from].live_before);
IOR_HARD_REG_SET (live, this_live);
}
--- 2901,2907 ----
if (++from >= MAX_INSNS_PER_PEEP2 + 1)
from = 0;
! gcc_assert (peep2_insn_data[from].insn != NULL_RTX);
REG_SET_TO_HARD_REG_SET (this_live, peep2_insn_data[from].live_before);
IOR_HARD_REG_SET (live, this_live);
}
*************** peephole2_optimize (FILE *dump_file ATTR
*** 3076,3083 ****
new_insn = NEXT_INSN (new_insn);
}
! if (new_insn == NULL_RTX)
! abort ();
CALL_INSN_FUNCTION_USAGE (new_insn)
= CALL_INSN_FUNCTION_USAGE (old_insn);
--- 3065,3071 ----
new_insn = NEXT_INSN (new_insn);
}
! gcc_assert (new_insn != NULL_RTX);
CALL_INSN_FUNCTION_USAGE (new_insn)
= CALL_INSN_FUNCTION_USAGE (old_insn);
*************** peephole2_optimize (FILE *dump_file ATTR
*** 3106,3113 ****
if (j >= MAX_INSNS_PER_PEEP2 + 1)
j -= MAX_INSNS_PER_PEEP2 + 1;
old_insn = peep2_insn_data[j].insn;
! if (CALL_P (old_insn))
! abort ();
}
break;
}
--- 3094,3100 ----
if (j >= MAX_INSNS_PER_PEEP2 + 1)
j -= MAX_INSNS_PER_PEEP2 + 1;
old_insn = peep2_insn_data[j].insn;
! gcc_assert (!CALL_P (old_insn));
}
break;
}
*************** store_data_bypass_p (rtx out_insn, rtx i
*** 3277,3284 ****
rtx out_set, in_set;
in_set = single_set (in_insn);
! if (! in_set)
! abort ();
if (!MEM_P (SET_DEST (in_set)))
return false;
--- 3264,3270 ----
rtx out_set, in_set;
in_set = single_set (in_insn);
! gcc_assert (in_set);
if (!MEM_P (SET_DEST (in_set)))
return false;
*************** store_data_bypass_p (rtx out_insn, rtx i
*** 3295,3302 ****
int i;
out_pat = PATTERN (out_insn);
! if (GET_CODE (out_pat) != PARALLEL)
! abort ();
for (i = 0; i < XVECLEN (out_pat, 0); i++)
{
--- 3281,3287 ----
int i;
out_pat = PATTERN (out_insn);
! gcc_assert (GET_CODE (out_pat) == PARALLEL);
for (i = 0; i < XVECLEN (out_pat, 0); i++)
{
*************** store_data_bypass_p (rtx out_insn, rtx i
*** 3305,3312 ****
if (GET_CODE (exp) == CLOBBER)
continue;
! if (GET_CODE (exp) != SET)
! abort ();
if (reg_mentioned_p (SET_DEST (exp), SET_DEST (in_set)))
return false;
--- 3290,3296 ----
if (GET_CODE (exp) == CLOBBER)
continue;
! gcc_assert (GET_CODE (exp) == SET);
if (reg_mentioned_p (SET_DEST (exp), SET_DEST (in_set)))
return false;
*************** if_test_bypass_p (rtx out_insn, rtx in_i
*** 3329,3337 ****
in_set = single_set (in_insn);
if (! in_set)
{
! if (JUMP_P (in_insn) || CALL_P (in_insn))
! return false;
! abort ();
}
if (GET_CODE (SET_SRC (in_set)) != IF_THEN_ELSE)
--- 3313,3320 ----
in_set = single_set (in_insn);
if (! in_set)
{
! gcc_assert (JUMP_P (in_insn) || CALL_P (in_insn));
! return false;
}
if (GET_CODE (SET_SRC (in_set)) != IF_THEN_ELSE)
*************** if_test_bypass_p (rtx out_insn, rtx in_i
*** 3351,3358 ****
int i;
out_pat = PATTERN (out_insn);
! if (GET_CODE (out_pat) != PARALLEL)
! abort ();
for (i = 0; i < XVECLEN (out_pat, 0); i++)
{
--- 3334,3340 ----
int i;
out_pat = PATTERN (out_insn);
! gcc_assert (GET_CODE (out_pat) == PARALLEL);
for (i = 0; i < XVECLEN (out_pat, 0); i++)
{
*************** if_test_bypass_p (rtx out_insn, rtx in_i
*** 3361,3368 ****
if (GET_CODE (exp) == CLOBBER)
continue;
! if (GET_CODE (exp) != SET)
! abort ();
if (reg_mentioned_p (SET_DEST (out_set), XEXP (in_set, 1))
|| reg_mentioned_p (SET_DEST (out_set), XEXP (in_set, 2)))
--- 3343,3349 ----
if (GET_CODE (exp) == CLOBBER)
continue;
! gcc_assert (GET_CODE (exp) == SET);
if (reg_mentioned_p (SET_DEST (out_set), XEXP (in_set, 1))
|| reg_mentioned_p (SET_DEST (out_set), XEXP (in_set, 2)))
Index: regclass.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/regclass.c,v
retrieving revision 1.194
diff -c -3 -p -r1.194 regclass.c
*** regclass.c 19 Aug 2004 14:04:24 -0000 1.194
--- regclass.c 9 Sep 2004 14:25:52 -0000
*************** init_reg_sets (void)
*** 284,292 ****
/* Sanity check: make sure the target macros FIXED_REGISTERS and
CALL_USED_REGISTERS had the right number of initializers. */
! if (sizeof fixed_regs != sizeof initial_fixed_regs
! || sizeof call_used_regs != sizeof initial_call_used_regs)
! abort();
memcpy (fixed_regs, initial_fixed_regs, sizeof fixed_regs);
memcpy (call_used_regs, initial_call_used_regs, sizeof call_used_regs);
--- 284,291 ----
/* Sanity check: make sure the target macros FIXED_REGISTERS and
CALL_USED_REGISTERS had the right number of initializers. */
! gcc_assert (sizeof fixed_regs == sizeof initial_fixed_regs);
! gcc_assert (sizeof call_used_regs == sizeof initial_call_used_regs);
memcpy (fixed_regs, initial_fixed_regs, sizeof fixed_regs);
memcpy (call_used_regs, initial_call_used_regs, sizeof call_used_regs);
*************** init_reg_sets_1 (void)
*** 427,441 ****
for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
{
- #ifdef ENABLE_CHECKING
/* call_used_regs must include fixed_regs. */
! if (fixed_regs[i] && !call_used_regs[i])
! abort ();
#ifdef CALL_REALLY_USED_REGISTERS
/* call_used_regs must include call_really_used_regs. */
! if (call_really_used_regs[i] && !call_used_regs[i])
! abort ();
! #endif
#endif
if (fixed_regs[i])
--- 426,436 ----
for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
{
/* call_used_regs must include fixed_regs. */
! gcc_assert (!fixed_regs[i] || call_used_regs[i]);
#ifdef CALL_REALLY_USED_REGISTERS
/* call_used_regs must include call_really_used_regs. */
! gcc_assert (!call_really_used_regs[i] || call_used_regs[i]);
#endif
if (fixed_regs[i])
*************** memory_move_secondary_cost (enum machine
*** 656,662 ****
what it is, so MEMORY_MOVE_COST really ought not to be calling
here in that case.
! I'm tempted to put in an abort here, but returning this will
probably only give poor estimates, which is what we would've
had before this code anyways. */
return partial_cost;
--- 651,657 ----
what it is, so MEMORY_MOVE_COST really ought not to be calling
here in that case.
! I'm tempted to put in an assert here, but returning this will
probably only give poor estimates, which is what we would've
had before this code anyways. */
return partial_cost;
Index: regrename.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/regrename.c,v
retrieving revision 1.86
diff -c -3 -p -r1.86 regrename.c
*** regrename.c 20 Aug 2004 19:37:10 -0000 1.86
--- regrename.c 9 Sep 2004 14:25:56 -0000
*************** note_sets (rtx x, rtx set ATTRIBUTE_UNUS
*** 105,112 ****
nregs = hard_regno_nregs[regno][GET_MODE (x)];
/* There must not be pseudos at this point. */
! if (regno + nregs > FIRST_PSEUDO_REGISTER)
! abort ();
while (nregs-- > 0)
SET_HARD_REG_BIT (*pset, regno + nregs);
--- 105,111 ----
nregs = hard_regno_nregs[regno][GET_MODE (x)];
/* There must not be pseudos at this point. */
! gcc_assert (regno + nregs <= FIRST_PSEUDO_REGISTER);
while (nregs-- > 0)
SET_HARD_REG_BIT (*pset, regno + nregs);
*************** clear_dead_regs (HARD_REG_SET *pset, enu
*** 127,134 ****
int nregs = hard_regno_nregs[regno][GET_MODE (reg)];
/* There must not be pseudos at this point. */
! if (regno + nregs > FIRST_PSEUDO_REGISTER)
! abort ();
while (nregs-- > 0)
CLEAR_HARD_REG_BIT (*pset, regno + nregs);
--- 126,132 ----
int nregs = hard_regno_nregs[regno][GET_MODE (reg)];
/* There must not be pseudos at this point. */
! gcc_assert (regno + nregs <= FIRST_PSEUDO_REGISTER);
while (nregs-- > 0)
CLEAR_HARD_REG_BIT (*pset, regno + nregs);
*************** scan_rtx_reg (rtx insn, rtx *loc, enum r
*** 442,449 ****
if (action == mark_read)
{
! if (! exact_match)
! abort ();
/* ??? Class NO_REGS can happen if the md file makes use of
EXTRA_CONSTRAINTS to match registers. Which is arguably
--- 440,446 ----
if (action == mark_read)
{
! gcc_assert (exact_match);
/* ??? Class NO_REGS can happen if the md file makes use of
EXTRA_CONSTRAINTS to match registers. Which is arguably
*************** scan_rtx (rtx insn, rtx *loc, enum reg_c
*** 692,698 ****
case POST_MODIFY:
case PRE_MODIFY:
/* Should only happen inside MEM. */
! abort ();
case CLOBBER:
scan_rtx (insn, &SET_DEST (x), cl, action, OP_OUT, 1);
--- 689,695 ----
case POST_MODIFY:
case PRE_MODIFY:
/* Should only happen inside MEM. */
! gcc_unreachable ();
case CLOBBER:
scan_rtx (insn, &SET_DEST (x), cl, action, OP_OUT, 1);
Index: reg-stack.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/reg-stack.c,v
retrieving revision 1.162
diff -c -3 -p -r1.162 reg-stack.c
*** reg-stack.c 4 Sep 2004 07:55:04 -0000 1.162
--- reg-stack.c 9 Sep 2004 14:26:02 -0000
*************** record_label_references (rtx insn, rtx p
*** 506,513 ****
rtx label = XEXP (pat, 0);
rtx ref;
! if (!LABEL_P (label))
! abort ();
/* If this is an undefined label, LABEL_REFS (label) contains
garbage. */
--- 506,512 ----
rtx label = XEXP (pat, 0);
rtx ref;
! gcc_assert (LABEL_P (label));
/* If this is an undefined label, LABEL_REFS (label) contains
garbage. */
*************** check_asm_stack_operands (rtx insn)
*** 782,802 ****
static int
get_asm_operand_n_inputs (rtx body)
{
! if (GET_CODE (body) == SET && GET_CODE (SET_SRC (body)) == ASM_OPERANDS)
! return ASM_OPERANDS_INPUT_LENGTH (SET_SRC (body));
!
! else if (GET_CODE (body) == ASM_OPERANDS)
! return ASM_OPERANDS_INPUT_LENGTH (body);
!
! else if (GET_CODE (body) == PARALLEL
! && GET_CODE (XVECEXP (body, 0, 0)) == SET)
! return ASM_OPERANDS_INPUT_LENGTH (SET_SRC (XVECEXP (body, 0, 0)));
!
! else if (GET_CODE (body) == PARALLEL
! && GET_CODE (XVECEXP (body, 0, 0)) == ASM_OPERANDS)
! return ASM_OPERANDS_INPUT_LENGTH (XVECEXP (body, 0, 0));
!
! abort ();
}
/* If current function returns its result in an fp stack register,
--- 781,801 ----
static int
get_asm_operand_n_inputs (rtx body)
{
! switch (GET_CODE (body))
! {
! case SET:
! gcc_assert (GET_CODE (SET_SRC (body)) == ASM_OPERANDS);
! return ASM_OPERANDS_INPUT_LENGTH (SET_SRC (body));
!
! case ASM_OPERANDS:
! return ASM_OPERANDS_INPUT_LENGTH (body);
!
! case PARALLEL:
! return get_asm_operand_n_inputs (XVECEXP (body, 0, 0));
!
! default:
! gcc_unreachable ();
! }
}
/* If current function returns its result in an fp stack register,
*************** stack_result (tree decl)
*** 838,853 ****
static void
replace_reg (rtx *reg, int regno)
{
! if (regno < FIRST_STACK_REG || regno > LAST_STACK_REG
! || ! STACK_REG_P (*reg))
! abort ();
!
! switch (GET_MODE_CLASS (GET_MODE (*reg)))
! {
! default: abort ();
! case MODE_FLOAT:
! case MODE_COMPLEX_FLOAT:;
! }
*reg = FP_MODE_REG (regno, GET_MODE (*reg));
}
--- 837,848 ----
static void
replace_reg (rtx *reg, int regno)
{
! gcc_assert (regno >= FIRST_STACK_REG);
! gcc_assert (regno <= LAST_STACK_REG);
! gcc_assert (STACK_REG_P (*reg));
!
! gcc_assert (GET_MODE_CLASS (GET_MODE (*reg)) == MODE_FLOAT
! || GET_MODE_CLASS (GET_MODE (*reg)) == MODE_COMPLEX_FLOAT);
*reg = FP_MODE_REG (regno, GET_MODE (*reg));
}
*************** remove_regno_note (rtx insn, enum reg_no
*** 871,877 ****
else
note_link = &XEXP (this, 1);
! abort ();
}
/* Find the hard register number of virtual register REG in REGSTACK.
--- 866,872 ----
else
note_link = &XEXP (this, 1);
! gcc_unreachable ();
}
/* Find the hard register number of virtual register REG in REGSTACK.
*************** get_hard_regnum (stack regstack, rtx reg
*** 883,890 ****
{
int i;
! if (! STACK_REG_P (reg))
! abort ();
for (i = regstack->top; i >= 0; i--)
if (regstack->reg[i] == REGNO (reg))
--- 878,884 ----
{
int i;
! gcc_assert (STACK_REG_P (reg));
for (i = regstack->top; i >= 0; i--)
if (regstack->reg[i] == REGNO (reg))
*************** emit_pop_insn (rtx insn, stack regstack,
*** 918,932 ****
pop_insn = emit_pop_insn (insn, regstack, reg1, where);
if (get_hard_regnum (regstack, reg2) >= 0)
pop_insn = emit_pop_insn (insn, regstack, reg2, where);
! if (!pop_insn)
! abort ();
return pop_insn;
}
hard_regno = get_hard_regnum (regstack, reg);
! if (hard_regno < FIRST_STACK_REG)
! abort ();
pop_rtx = gen_rtx_SET (VOIDmode, FP_MODE_REG (hard_regno, DFmode),
FP_MODE_REG (FIRST_STACK_REG, DFmode));
--- 912,924 ----
pop_insn = emit_pop_insn (insn, regstack, reg1, where);
if (get_hard_regnum (regstack, reg2) >= 0)
pop_insn = emit_pop_insn (insn, regstack, reg2, where);
! gcc_assert (pop_insn);
return pop_insn;
}
hard_regno = get_hard_regnum (regstack, reg);
! gcc_assert (hard_regno >= FIRST_STACK_REG);
pop_rtx = gen_rtx_SET (VOIDmode, FP_MODE_REG (hard_regno, DFmode),
FP_MODE_REG (FIRST_STACK_REG, DFmode));
*************** emit_swap_insn (rtx insn, stack regstack
*** 966,973 ****
hard_regno = get_hard_regnum (regstack, reg);
! if (hard_regno < FIRST_STACK_REG)
! abort ();
if (hard_regno == FIRST_STACK_REG)
return;
--- 958,964 ----
hard_regno = get_hard_regnum (regstack, reg);
! gcc_assert (hard_regno >= FIRST_STACK_REG);
if (hard_regno == FIRST_STACK_REG)
return;
*************** swap_to_top (rtx insn, stack regstack, r
*** 1055,1062 ****
/* Place operand 1 at the top of stack. */
regno = get_hard_regnum (&temp_stack, src1);
! if (regno < 0)
! abort ();
if (regno != FIRST_STACK_REG)
{
k = temp_stack.top - (regno - FIRST_STACK_REG);
--- 1046,1052 ----
/* Place operand 1 at the top of stack. */
regno = get_hard_regnum (&temp_stack, src1);
! gcc_assert (regno >= 0);
if (regno != FIRST_STACK_REG)
{
k = temp_stack.top - (regno - FIRST_STACK_REG);
*************** swap_to_top (rtx insn, stack regstack, r
*** 1069,1076 ****
/* Place operand 2 next on the stack. */
regno = get_hard_regnum (&temp_stack, src2);
! if (regno < 0)
! abort ();
if (regno != FIRST_STACK_REG + 1)
{
k = temp_stack.top - (regno - FIRST_STACK_REG);
--- 1059,1065 ----
/* Place operand 2 next on the stack. */
regno = get_hard_regnum (&temp_stack, src2);
! gcc_assert (regno >= 0);
if (regno != FIRST_STACK_REG + 1)
{
k = temp_stack.top - (regno - FIRST_STACK_REG);
*************** move_for_stack_reg (rtx insn, stack regs
*** 1110,1125 ****
int i;
/* If this is a no-op move, there must not be a REG_DEAD note. */
! if (REGNO (src) == REGNO (dest))
! abort ();
for (i = regstack->top; i >= 0; i--)
if (regstack->reg[i] == REGNO (src))
break;
/* The source must be live, and the dest must be dead. */
! if (i < 0 || get_hard_regnum (regstack, dest) >= FIRST_STACK_REG)
! abort ();
/* It is possible that the dest is unused after this insn.
If so, just pop the src. */
--- 1099,1113 ----
int i;
/* If this is a no-op move, there must not be a REG_DEAD note. */
! gcc_assert (REGNO (src) != REGNO (dest));
for (i = regstack->top; i >= 0; i--)
if (regstack->reg[i] == REGNO (src))
break;
/* The source must be live, and the dest must be dead. */
! gcc_assert (i >= 0);
! gcc_assert (get_hard_regnum (regstack, dest) < FIRST_STACK_REG);
/* It is possible that the dest is unused after this insn.
If so, just pop the src. */
*************** move_for_stack_reg (rtx insn, stack regs
*** 1156,1163 ****
}
/* The destination ought to be dead. */
! if (get_hard_regnum (regstack, dest) >= FIRST_STACK_REG)
! abort ();
replace_reg (psrc, get_hard_regnum (regstack, src));
--- 1144,1150 ----
}
/* The destination ought to be dead. */
! gcc_assert (get_hard_regnum (regstack, dest) < FIRST_STACK_REG);
replace_reg (psrc, get_hard_regnum (regstack, src));
*************** move_for_stack_reg (rtx insn, stack regs
*** 1201,1226 ****
replace_reg (psrc, FIRST_STACK_REG);
}
! else if (STACK_REG_P (dest))
{
/* Load from MEM, or possibly integer REG or constant, into the
stack regs. The actual target is always the top of the
stack. The stack mapping is changed to reflect that DEST is
now at top of stack. */
/* The destination ought to be dead. */
! if (get_hard_regnum (regstack, dest) >= FIRST_STACK_REG)
! abort ();
! if (regstack->top >= REG_STACK_SIZE)
! abort ();
regstack->reg[++regstack->top] = REGNO (dest);
SET_HARD_REG_BIT (regstack->reg_set, REGNO (dest));
replace_reg (pdest, FIRST_STACK_REG);
}
- else
- abort ();
return control_flow_insn_deleted;
}
--- 1188,1211 ----
replace_reg (psrc, FIRST_STACK_REG);
}
! else
{
+ gcc_assert (STACK_REG_P (dest));
+
/* Load from MEM, or possibly integer REG or constant, into the
stack regs. The actual target is always the top of the
stack. The stack mapping is changed to reflect that DEST is
now at top of stack. */
/* The destination ought to be dead. */
! gcc_assert (get_hard_regnum (regstack, dest) < FIRST_STACK_REG);
! gcc_assert (regstack->top < REG_STACK_SIZE);
regstack->reg[++regstack->top] = REGNO (dest);
SET_HARD_REG_BIT (regstack->reg_set, REGNO (dest));
replace_reg (pdest, FIRST_STACK_REG);
}
return control_flow_insn_deleted;
}
*************** subst_stack_regs_pat (rtx insn, stack re
*** 1456,1463 ****
return control_flow_insn_deleted;
}
/* ??? Uninitialized USE should not happen. */
! else if (get_hard_regnum (regstack, *src) == -1)
! abort ();
break;
case CLOBBER:
--- 1441,1448 ----
return control_flow_insn_deleted;
}
/* ??? Uninitialized USE should not happen. */
! else
! gcc_assert (get_hard_regnum (regstack, *src) != -1);
break;
case CLOBBER:
*************** subst_stack_regs_pat (rtx insn, stack re
*** 1483,1490 ****
else
{
note = find_reg_note (insn, REG_UNUSED, *dest);
! if (!note)
! abort ();
}
remove_note (insn, note);
replace_reg (dest, FIRST_STACK_REG + 1);
--- 1468,1474 ----
else
{
note = find_reg_note (insn, REG_UNUSED, *dest);
! gcc_assert (note);
}
remove_note (insn, note);
replace_reg (dest, FIRST_STACK_REG + 1);
*************** subst_stack_regs_pat (rtx insn, stack re
*** 1560,1567 ****
case REG:
/* This is a `tstM2' case. */
! if (*dest != cc0_rtx)
! abort ();
src1 = src;
/* Fall through. */
--- 1544,1550 ----
case REG:
/* This is a `tstM2' case. */
! gcc_assert (*dest == cc0_rtx);
src1 = src;
/* Fall through. */
*************** subst_stack_regs_pat (rtx insn, stack re
*** 1636,1643 ****
src1_hard_regnum = get_hard_regnum (regstack, *src1);
src2_hard_regnum = get_hard_regnum (regstack, *src2);
! if (src1_hard_regnum == -1 || src2_hard_regnum == -1)
! abort ();
if (src1_hard_regnum != FIRST_STACK_REG
&& src2_hard_regnum != FIRST_STACK_REG)
--- 1619,1626 ----
src1_hard_regnum = get_hard_regnum (regstack, *src1);
src2_hard_regnum = get_hard_regnum (regstack, *src2);
! gcc_assert (src1_hard_regnum != -1);
! gcc_assert (src2_hard_regnum != -1);
if (src1_hard_regnum != FIRST_STACK_REG
&& src2_hard_regnum != FIRST_STACK_REG)
*************** subst_stack_regs_pat (rtx insn, stack re
*** 1743,1750 ****
/* Input should never die, it is
replaced with output. */
src1_note = find_regno_note (insn, REG_DEAD, REGNO (*src1));
! if (src1_note)
! abort();
if (STACK_REG_P (*dest))
replace_reg (dest, FIRST_STACK_REG);
--- 1726,1732 ----
/* Input should never die, it is
replaced with output. */
src1_note = find_regno_note (insn, REG_DEAD, REGNO (*src1));
! gcc_assert (!src1_note);
if (STACK_REG_P (*dest))
replace_reg (dest, FIRST_STACK_REG);
*************** subst_stack_regs_pat (rtx insn, stack re
*** 1800,1807 ****
/* Inputs should never die, they are
replaced with outputs. */
! if ((src1_note) || (src2_note))
! abort();
swap_to_top (insn, regstack, *src1, *src2);
--- 1782,1789 ----
/* Inputs should never die, they are
replaced with outputs. */
! gcc_assert (!src1_note);
! gcc_assert (!src2_note);
swap_to_top (insn, regstack, *src1, *src2);
*************** subst_stack_regs_pat (rtx insn, stack re
*** 1831,1838 ****
/* Inputs should never die, they are
replaced with outputs. */
! if ((src1_note) || (src2_note))
! abort();
swap_to_top (insn, regstack, *src1, *src2);
--- 1813,1820 ----
/* Inputs should never die, they are
replaced with outputs. */
! gcc_assert (!src1_note);
! gcc_assert (!src2_note);
swap_to_top (insn, regstack, *src1, *src2);
*************** subst_stack_regs_pat (rtx insn, stack re
*** 1861,1868 ****
/* Input should never die, it is
replaced with output. */
src1_note = find_regno_note (insn, REG_DEAD, REGNO (*src1));
! if (src1_note)
! abort();
/* Push the result back onto stack. Empty stack slot
will be filled in second part of insn. */
--- 1843,1849 ----
/* Input should never die, it is
replaced with output. */
src1_note = find_regno_note (insn, REG_DEAD, REGNO (*src1));
! gcc_assert (!src1_note);
/* Push the result back onto stack. Empty stack slot
will be filled in second part of insn. */
*************** subst_stack_regs_pat (rtx insn, stack re
*** 1888,1895 ****
/* Input should never die, it is
replaced with output. */
src1_note = find_regno_note (insn, REG_DEAD, REGNO (*src1));
! if (src1_note)
! abort();
/* Push the result back onto stack. Fill empty slot from
first part of insn and fix top of stack pointer. */
--- 1869,1875 ----
/* Input should never die, it is
replaced with output. */
src1_note = find_regno_note (insn, REG_DEAD, REGNO (*src1));
! gcc_assert (!src1_note);
/* Push the result back onto stack. Fill empty slot from
first part of insn and fix top of stack pointer. */
*************** subst_stack_regs_pat (rtx insn, stack re
*** 1909,1917 ****
The combination matches the PPRO fcomi instruction. */
pat_src = XVECEXP (pat_src, 0, 0);
! if (GET_CODE (pat_src) != UNSPEC
! || XINT (pat_src, 1) != UNSPEC_FNSTSW)
! abort ();
/* Fall through. */
case UNSPEC_FNSTSW:
--- 1889,1896 ----
The combination matches the PPRO fcomi instruction. */
pat_src = XVECEXP (pat_src, 0, 0);
! gcc_assert (GET_CODE (pat_src) == UNSPEC);
! gcc_assert (XINT (pat_src, 1) == UNSPEC_FNSTSW);
/* Fall through. */
case UNSPEC_FNSTSW:
*************** subst_stack_regs_pat (rtx insn, stack re
*** 1920,1933 ****
up before now. */
pat_src = XVECEXP (pat_src, 0, 0);
! if (GET_CODE (pat_src) != COMPARE)
! abort ();
compare_for_stack_reg (insn, regstack, pat_src);
break;
default:
! abort ();
}
break;
--- 1899,1911 ----
up before now. */
pat_src = XVECEXP (pat_src, 0, 0);
! gcc_assert (GET_CODE (pat_src) == COMPARE);
compare_for_stack_reg (insn, regstack, pat_src);
break;
default:
! gcc_unreachable ();
}
break;
*************** subst_stack_regs_pat (rtx insn, stack re
*** 1994,2010 ****
int regno = REGNO (XEXP (src_note[i], 0));
/* If the register that dies is not at the top of
! stack, then move the top of stack to the dead reg */
! if (regno != regstack->reg[regstack->top])
! {
! remove_regno_note (insn, REG_DEAD, regno);
! emit_pop_insn (insn, regstack, XEXP (src_note[i], 0),
! EMIT_AFTER);
! }
! else
! /* Top of stack never dies, as it is the
! destination. */
! abort ();
}
}
--- 1972,1984 ----
int regno = REGNO (XEXP (src_note[i], 0));
/* If the register that dies is not at the top of
! stack, then move the top of stack to the dead reg.
! Top of stack should never die, as it is the
! destination. */
! gcc_assert (regno != regstack->reg[regstack->top]);
! remove_regno_note (insn, REG_DEAD, regno);
! emit_pop_insn (insn, regstack, XEXP (src_note[i], 0),
! EMIT_AFTER);
}
}
*************** subst_stack_regs_pat (rtx insn, stack re
*** 2017,2023 ****
break;
default:
! abort ();
}
break;
}
--- 1991,1997 ----
break;
default:
! gcc_unreachable ();
}
break;
}
*************** subst_asm_stack_regs (rtx insn, stack re
*** 2074,2081 ****
n_inputs = get_asm_operand_n_inputs (body);
n_outputs = recog_data.n_operands - n_inputs;
! if (alt < 0)
! abort ();
/* Strip SUBREGs here to make the following code simpler. */
for (i = 0; i < recog_data.n_operands; i++)
--- 2048,2054 ----
n_inputs = get_asm_operand_n_inputs (body);
n_outputs = recog_data.n_operands - n_inputs;
! gcc_assert (alt >= 0);
/* Strip SUBREGs here to make the following code simpler. */
for (i = 0; i < recog_data.n_operands; i++)
*************** subst_asm_stack_regs (rtx insn, stack re
*** 2168,2175 ****
int regno = get_hard_regnum (&temp_stack, recog_data.operand[i]);
! if (regno < 0)
! abort ();
if ((unsigned int) regno != REGNO (recog_data.operand[i]))
{
--- 2141,2147 ----
int regno = get_hard_regnum (&temp_stack, recog_data.operand[i]);
! gcc_assert (regno >= 0);
if ((unsigned int) regno != REGNO (recog_data.operand[i]))
{
*************** subst_asm_stack_regs (rtx insn, stack re
*** 2202,2209 ****
{
int regnum = get_hard_regnum (regstack, recog_data.operand[i]);
! if (regnum < 0)
! abort ();
replace_reg (recog_data.operand_loc[i], regnum);
}
--- 2174,2180 ----
{
int regnum = get_hard_regnum (regstack, recog_data.operand[i]);
! gcc_assert (regnum >= 0);
replace_reg (recog_data.operand_loc[i], regnum);
}
*************** subst_asm_stack_regs (rtx insn, stack re
*** 2213,2220 ****
{
int regnum = get_hard_regnum (regstack, note_reg[i]);
! if (regnum < 0)
! abort ();
replace_reg (note_loc[i], regnum);
}
--- 2184,2190 ----
{
int regnum = get_hard_regnum (regstack, note_reg[i]);
! gcc_assert (regnum >= 0);
replace_reg (note_loc[i], regnum);
}
*************** subst_asm_stack_regs (rtx insn, stack re
*** 2228,2234 ****
if (regnum >= 0)
{
/* Sigh - clobbers always have QImode. But replace_reg knows
! that these regs can't be MODE_INT and will abort. Just put
the right reg there without calling replace_reg. */
*clobber_loc[i] = FP_MODE_REG (regnum, DFmode);
--- 2198,2204 ----
if (regnum >= 0)
{
/* Sigh - clobbers always have QImode. But replace_reg knows
! that these regs can't be MODE_INT and will assert. Just put
the right reg there without calling replace_reg. */
*clobber_loc[i] = FP_MODE_REG (regnum, DFmode);
*************** change_stack (rtx insn, stack old, stack
*** 2469,2478 ****
not their depth or liveliness. */
GO_IF_HARD_REG_EQUAL (old->reg_set, new->reg_set, win);
! abort ();
win:
! if (old->top != new->top)
! abort ();
/* If the stack is not empty (new->top != -1), loop here emitting
swaps until the stack is correct.
--- 2439,2447 ----
not their depth or liveliness. */
GO_IF_HARD_REG_EQUAL (old->reg_set, new->reg_set, win);
! gcc_unreachable ();
win:
! gcc_assert (old->top == new->top);
/* If the stack is not empty (new->top != -1), loop here emitting
swaps until the stack is correct.
*************** change_stack (rtx insn, stack old, stack
*** 2495,2502 ****
if (new->reg[reg] == old->reg[old->top])
break;
! if (reg == -1)
! abort ();
emit_swap_insn (insn, old,
FP_MODE_REG (old->reg[reg], DFmode));
--- 2464,2470 ----
if (new->reg[reg] == old->reg[old->top])
break;
! gcc_assert (reg != -1);
emit_swap_insn (insn, old,
FP_MODE_REG (old->reg[reg], DFmode));
*************** change_stack (rtx insn, stack old, stack
*** 2518,2525 ****
/* At this point there must be no differences. */
for (reg = old->top; reg >= 0; reg--)
! if (old->reg[reg] != new->reg[reg])
! abort ();
}
if (update_end)
--- 2486,2492 ----
/* At this point there must be no differences. */
for (reg = old->top; reg >= 0; reg--)
! gcc_assert (old->reg[reg] == new->reg[reg]);
}
if (update_end)
*************** compensate_edge (edge e, FILE *file)
*** 2731,2737 ****
CLEAR_HARD_REG_SET (tmp);
GO_IF_HARD_REG_EQUAL (target_stack->reg_set, tmp, eh1);
! abort ();
eh1:
/* We are sure that there is st(0) live, otherwise we won't compensate.
--- 2698,2704 ----
CLEAR_HARD_REG_SET (tmp);
GO_IF_HARD_REG_EQUAL (target_stack->reg_set, tmp, eh1);
! gcc_unreachable ();
eh1:
/* We are sure that there is st(0) live, otherwise we won't compensate.
*************** compensate_edge (edge e, FILE *file)
*** 2740,2746 ****
if (TEST_HARD_REG_BIT (regstack.reg_set, FIRST_STACK_REG + 1))
SET_HARD_REG_BIT (tmp, FIRST_STACK_REG + 1);
GO_IF_HARD_REG_EQUAL (regstack.reg_set, tmp, eh2);
! abort ();
eh2:
target_stack->top = -1;
--- 2707,2713 ----
if (TEST_HARD_REG_BIT (regstack.reg_set, FIRST_STACK_REG + 1))
SET_HARD_REG_BIT (tmp, FIRST_STACK_REG + 1);
GO_IF_HARD_REG_EQUAL (regstack.reg_set, tmp, eh2);
! gcc_unreachable ();
eh2:
target_stack->top = -1;
*************** compensate_edge (edge e, FILE *file)
*** 2766,2773 ****
/* We don't support abnormal edges. Global takes care to
avoid any live register across them, so we should never
have to insert instructions on such edges. */
! if (e->flags & EDGE_ABNORMAL)
! abort ();
current_block = NULL;
start_sequence ();
--- 2733,2739 ----
/* We don't support abnormal edges. Global takes care to
avoid any live register across them, so we should never
have to insert instructions on such edges. */
! gcc_assert (!(e->flags & EDGE_ABNORMAL));
current_block = NULL;
start_sequence ();
*************** convert_regs_1 (FILE *file, basic_block
*** 2870,2877 ****
next = NEXT_INSN (insn);
/* Ensure we have not missed a block boundary. */
! if (next == NULL)
! abort ();
if (insn == BB_END (block))
next = NULL;
--- 2836,2842 ----
next = NEXT_INSN (insn);
/* Ensure we have not missed a block boundary. */
! gcc_assert (next);
if (insn == BB_END (block))
next = NULL;
*************** convert_regs_1 (FILE *file, basic_block
*** 2953,2960 ****
asms, we zapped the instruction itself, but that didn't produce the
same pattern of register kills as before. */
GO_IF_HARD_REG_EQUAL (regstack.reg_set, bi->out_reg_set, win);
! if (!any_malformed_asm)
! abort ();
win:
bi->stack_out = regstack;
--- 2918,2924 ----
asms, we zapped the instruction itself, but that didn't produce the
same pattern of register kills as before. */
GO_IF_HARD_REG_EQUAL (regstack.reg_set, bi->out_reg_set, win);
! gcc_assert (any_malformed_asm);
win:
bi->stack_out = regstack;
*************** convert_regs_1 (FILE *file, basic_block
*** 2964,2972 ****
if (e->flags & EDGE_DFS_BACK
|| (e->dest == EXIT_BLOCK_PTR))
{
! if (!BLOCK_INFO (e->dest)->done
! && e->dest != block)
! abort ();
inserted |= compensate_edge (e, file);
}
}
--- 2928,2935 ----
if (e->flags & EDGE_DFS_BACK
|| (e->dest == EXIT_BLOCK_PTR))
{
! gcc_assert (BLOCK_INFO (e->dest)->done
! || e->dest == block);
inserted |= compensate_edge (e, file);
}
}
*************** convert_regs_1 (FILE *file, basic_block
*** 2975,2982 ****
if (e != beste && !(e->flags & EDGE_DFS_BACK)
&& e->src != ENTRY_BLOCK_PTR)
{
! if (!BLOCK_INFO (e->src)->done)
! abort ();
inserted |= compensate_edge (e, file);
}
}
--- 2938,2944 ----
if (e != beste && !(e->flags & EDGE_DFS_BACK)
&& e->src != ENTRY_BLOCK_PTR)
{
! gcc_assert (BLOCK_INFO (e->src)->done);
inserted |= compensate_edge (e, file);
}
}
Index: reload1.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/reload1.c,v
retrieving revision 1.443
diff -c -3 -p -r1.443 reload1.c
*** reload1.c 18 Aug 2004 08:24:08 -0000 1.443
--- reload1.c 9 Sep 2004 14:26:20 -0000
*************** compute_use_by_pseudos (HARD_REG_SET *to
*** 536,543 ****
BASIC_BLOCK->global_live_at_start, which might still
contain registers that have not actually been allocated
since they have an equivalence. */
! if (! reload_completed)
! abort ();
}
else
{
--- 536,542 ----
BASIC_BLOCK->global_live_at_start, which might still
contain registers that have not actually been allocated
since they have an equivalence. */
! gcc_assert (reload_completed);
}
else
{
*************** replace_pseudos_in (rtx *loc, enum machi
*** 584,594 ****
*loc = reg_equiv_mem[regno];
else if (reg_equiv_address[regno])
*loc = gen_rtx_MEM (GET_MODE (x), reg_equiv_address[regno]);
- else if (!REG_P (regno_reg_rtx[regno])
- || REGNO (regno_reg_rtx[regno]) != regno)
- *loc = regno_reg_rtx[regno];
else
! abort ();
return;
}
--- 583,594 ----
*loc = reg_equiv_mem[regno];
else if (reg_equiv_address[regno])
*loc = gen_rtx_MEM (GET_MODE (x), reg_equiv_address[regno]);
else
! {
! gcc_assert (!REG_P (regno_reg_rtx[regno])
! || REGNO (regno_reg_rtx[regno]) != regno);
! *loc = regno_reg_rtx[regno];
! }
return;
}
*************** reload (rtx first, int global)
*** 1071,1078 ****
reload_as_needed (global);
! if (old_frame_size != get_frame_size ())
! abort ();
if (num_eliminable)
verify_initial_elim_offsets ();
--- 1071,1077 ----
reload_as_needed (global);
! gcc_assert (old_frame_size == get_frame_size ());
if (num_eliminable)
verify_initial_elim_offsets ();
*************** count_pseudo (int reg)
*** 1576,1583 ****
SET_REGNO_REG_SET (&pseudos_counted, reg);
! if (r < 0)
! abort ();
spill_add_cost[r] += freq;
--- 1575,1581 ----
SET_REGNO_REG_SET (&pseudos_counted, reg);
! gcc_assert (r >= 0);
spill_add_cost[r] += freq;
*************** find_reg (struct insn_chain *chain, int
*** 1750,1758 ****
for (i = 0; i < rl->nregs; i++)
{
! if (spill_cost[best_reg + i] != 0
! || spill_add_cost[best_reg + i] != 0)
! abort ();
SET_HARD_REG_BIT (used_spill_regs_local, best_reg + i);
}
return 1;
--- 1748,1755 ----
for (i = 0; i < rl->nregs; i++)
{
! gcc_assert (spill_cost[best_reg + i] == 0);
! gcc_assert (spill_add_cost[best_reg + i] == 0);
SET_HARD_REG_BIT (used_spill_regs_local, best_reg + i);
}
return 1;
*************** eliminate_regs (rtx x, enum machine_mode
*** 2555,2561 ****
case CLOBBER:
case ASM_OPERANDS:
case SET:
! abort ();
default:
break;
--- 2552,2558 ----
case CLOBBER:
case ASM_OPERANDS:
case SET:
! gcc_unreachable ();
default:
break;
*************** eliminate_regs_in_insn (rtx insn, int re
*** 2867,2879 ****
if (! insn_is_asm && icode < 0)
{
! if (GET_CODE (PATTERN (insn)) == USE
! || GET_CODE (PATTERN (insn)) == CLOBBER
! || GET_CODE (PATTERN (insn)) == ADDR_VEC
! || GET_CODE (PATTERN (insn)) == ADDR_DIFF_VEC
! || GET_CODE (PATTERN (insn)) == ASM_INPUT)
! return 0;
! abort ();
}
if (old_set != 0 && REG_P (SET_DEST (old_set))
--- 2864,2875 ----
if (! insn_is_asm && icode < 0)
{
! gcc_assert (GET_CODE (PATTERN (insn)) == USE
! || GET_CODE (PATTERN (insn)) == CLOBBER
! || GET_CODE (PATTERN (insn)) == ADDR_VEC
! || GET_CODE (PATTERN (insn)) == ADDR_DIFF_VEC
! || GET_CODE (PATTERN (insn)) == ASM_INPUT);
! return 0;
}
if (old_set != 0 && REG_P (SET_DEST (old_set))
*************** eliminate_regs_in_insn (rtx insn, int re
*** 3027,3034 ****
PATTERN (insn) = gen_rtx_PARALLEL (VOIDmode, vec);
add_clobbers (PATTERN (insn), INSN_CODE (insn));
}
! if (INSN_CODE (insn) < 0)
! abort ();
}
/* If we have a nonzero offset, and the source is already
a simple REG, the following transformation would
--- 3023,3029 ----
PATTERN (insn) = gen_rtx_PARALLEL (VOIDmode, vec);
add_clobbers (PATTERN (insn), INSN_CODE (insn));
}
! gcc_assert (INSN_CODE (insn) >= 0);
}
/* If we have a nonzero offset, and the source is already
a simple REG, the following transformation would
*************** verify_initial_elim_offsets (void)
*** 3299,3311 ****
for (ep = reg_eliminate; ep < ®_eliminate[NUM_ELIMINABLE_REGS]; ep++)
{
INITIAL_ELIMINATION_OFFSET (ep->from, ep->to, t);
! if (t != ep->initial_offset)
! abort ();
}
#else
INITIAL_FRAME_POINTER_OFFSET (t);
! if (t != reg_eliminate[0].initial_offset)
! abort ();
#endif
}
--- 3294,3304 ----
for (ep = reg_eliminate; ep < ®_eliminate[NUM_ELIMINABLE_REGS]; ep++)
{
INITIAL_ELIMINATION_OFFSET (ep->from, ep->to, t);
! gcc_assert (t == ep->initial_offset);
}
#else
INITIAL_FRAME_POINTER_OFFSET (t);
! gcc_assert (t == reg_eliminate[0].initial_offset);
#endif
}
*************** finish_spills (int global)
*** 3590,3597 ****
/* Record the current hard register the pseudo is allocated to in
pseudo_previous_regs so we avoid reallocating it to the same
hard reg in a later pass. */
! if (reg_renumber[i] < 0)
! abort ();
SET_HARD_REG_BIT (pseudo_previous_regs[i], reg_renumber[i]);
/* Mark it as no longer having a hard register home. */
--- 3583,3589 ----
/* Record the current hard register the pseudo is allocated to in
pseudo_previous_regs so we avoid reallocating it to the same
hard reg in a later pass. */
! gcc_assert (reg_renumber[i] >= 0);
SET_HARD_REG_BIT (pseudo_previous_regs[i], reg_renumber[i]);
/* Mark it as no longer having a hard register home. */
*************** finish_spills (int global)
*** 3670,3676 ****
/* Make sure we only enlarge the set. */
GO_IF_HARD_REG_SUBSET (used_by_pseudos2, chain->used_spill_regs, ok);
! abort ();
ok:;
}
}
--- 3662,3668 ----
/* Make sure we only enlarge the set. */
GO_IF_HARD_REG_SUBSET (used_by_pseudos2, chain->used_spill_regs, ok);
! gcc_unreachable ();
ok:;
}
}
*************** clear_reload_reg_in_use (unsigned int re
*** 4265,4271 ****
used_in_set = &reload_reg_used_in_insn;
break;
default:
! abort ();
}
/* We resolve conflicts with remaining reloads of the same type by
excluding the intervals of reload registers by them from the
--- 4257,4263 ----
used_in_set = &reload_reg_used_in_insn;
break;
default:
! gcc_unreachable ();
}
/* We resolve conflicts with remaining reloads of the same type by
excluding the intervals of reload registers by them from the
*************** reload_reg_free_p (unsigned int regno, i
*** 4461,4468 ****
case RELOAD_FOR_OTHER_ADDRESS:
return ! TEST_HARD_REG_BIT (reload_reg_used_in_other_addr, regno);
}
- abort ();
}
/* Return 1 if the value in reload reg REGNO, as used by a reload
--- 4453,4462 ----
case RELOAD_FOR_OTHER_ADDRESS:
return ! TEST_HARD_REG_BIT (reload_reg_used_in_other_addr, regno);
+
+ default:
+ gcc_unreachable ();
}
}
/* Return 1 if the value in reload reg REGNO, as used by a reload
*************** reload_reg_reaches_end_p (unsigned int r
*** 4594,4602 ****
return 0;
return 1;
- }
! abort ();
}
/* Return 1 if the reloads denoted by R1 and R2 cannot share a register.
--- 4588,4597 ----
return 0;
return 1;
! default:
! gcc_unreachable ();
! }
}
/* Return 1 if the reloads denoted by R1 and R2 cannot share a register.
*************** reloads_conflict (int r1, int r2)
*** 4671,4677 ****
return 1;
default:
! abort ();
}
}
--- 4666,4672 ----
return 1;
default:
! gcc_unreachable ();
}
}
*************** choose_reload_regs (struct insn_chain *c
*** 5591,5607 ****
{
if (REG_P (equiv))
regno = REGNO (equiv);
! else if (GET_CODE (equiv) == SUBREG)
{
/* This must be a SUBREG of a hard register.
Make a new REG since this might be used in an
address and not all machines support SUBREGs
there. */
regno = subreg_regno (equiv);
equiv = gen_rtx_REG (rld[r].mode, regno);
}
- else
- abort ();
}
/* If we found a spill reg, reject it unless it is free
--- 5586,5601 ----
{
if (REG_P (equiv))
regno = REGNO (equiv);
! else
{
/* This must be a SUBREG of a hard register.
Make a new REG since this might be used in an
address and not all machines support SUBREGs
there. */
+ gcc_assert (GET_CODE (equiv) == SUBREG);
regno = subreg_regno (equiv);
equiv = gen_rtx_REG (rld[r].mode, regno);
}
}
/* If we found a spill reg, reject it unless it is free
*************** choose_reload_regs (struct insn_chain *c
*** 5805,5819 ****
/* Some sanity tests to verify that the reloads found in the first
pass are identical to the ones we have now. */
! if (chain->n_reloads != n_reloads)
! abort ();
for (i = 0; i < n_reloads; i++)
{
if (chain->rld[i].regno < 0 || chain->rld[i].reg_rtx != 0)
continue;
! if (chain->rld[i].when_needed != rld[i].when_needed)
! abort ();
for (j = 0; j < n_spills; j++)
if (spill_regs[j] == chain->rld[i].regno)
if (! set_reload_reg (j, i))
--- 5799,5811 ----
/* Some sanity tests to verify that the reloads found in the first
pass are identical to the ones we have now. */
! gcc_assert (chain->n_reloads == n_reloads);
for (i = 0; i < n_reloads; i++)
{
if (chain->rld[i].regno < 0 || chain->rld[i].reg_rtx != 0)
continue;
! gcc_assert (chain->rld[i].when_needed == rld[i].when_needed);
for (j = 0; j < n_spills; j++)
if (spill_regs[j] == chain->rld[i].regno)
if (! set_reload_reg (j, i))
*************** choose_reload_regs (struct insn_chain *c
*** 5926,5935 ****
SET_HARD_REG_BIT (reg_is_output_reload, i + nr);
}
! if (rld[r].when_needed != RELOAD_OTHER
! && rld[r].when_needed != RELOAD_FOR_OUTPUT
! && rld[r].when_needed != RELOAD_FOR_INSN)
! abort ();
}
}
}
--- 5918,5926 ----
SET_HARD_REG_BIT (reg_is_output_reload, i + nr);
}
! gcc_assert (rld[r].when_needed == RELOAD_OTHER
! || rld[r].when_needed == RELOAD_FOR_OUTPUT
! || rld[r].when_needed == RELOAD_FOR_INSN);
}
}
}
*************** merge_assigned_reloads (rtx insn)
*** 6075,6085 ****
so abort. */
if (rld[j].reg_rtx)
for (k = 0; k < j; k++)
! if (rld[k].in != 0 && rld[k].reg_rtx != 0
! && rld[k].when_needed == rld[j].when_needed
! && rtx_equal_p (rld[k].reg_rtx, rld[j].reg_rtx)
! && ! rtx_equal_p (rld[k].in, rld[j].in))
! abort ();
}
}
}
--- 6066,6077 ----
so abort. */
if (rld[j].reg_rtx)
for (k = 0; k < j; k++)
! gcc_assert (rld[k].in == 0 || rld[k].reg_rtx == 0
! || rld[k].when_needed != rld[j].when_needed
! || !rtx_equal_p (rld[k].reg_rtx,
! rld[j].reg_rtx)
! || rtx_equal_p (rld[k].in,
! rld[j].in));
}
}
}
*************** emit_input_reload_insns (struct insn_cha
*** 6293,6299 ****
where = &other_input_address_reload_insns;
break;
default:
! abort ();
}
push_to_sequence (*where);
--- 6285,6291 ----
where = &other_input_address_reload_insns;
break;
default:
! gcc_unreachable ();
}
push_to_sequence (*where);
*************** emit_input_reload_insns (struct insn_cha
*** 6304,6311 ****
/* We are not going to bother supporting the case where a
incremented register can't be copied directly from
OLDEQUIV since this seems highly unlikely. */
! if (rl->secondary_in_reload >= 0)
! abort ();
if (reload_inherited[j])
oldequiv = reloadreg;
--- 6296,6302 ----
/* We are not going to bother supporting the case where a
incremented register can't be copied directly from
OLDEQUIV since this seems highly unlikely. */
! gcc_assert (rl->secondary_in_reload < 0);
if (reload_inherited[j])
oldequiv = reloadreg;
*************** do_output_reload (struct insn_chain *cha
*** 6921,6928 ****
return;
/* If is a JUMP_INSN, we can't support output reloads yet. */
! if (JUMP_P (insn))
! abort ();
emit_output_reload_insns (chain, rld + j, j);
}
--- 6912,6918 ----
return;
/* If is a JUMP_INSN, we can't support output reloads yet. */
! gcc_assert (!JUMP_P (insn));
emit_output_reload_insns (chain, rld + j, j);
}
*************** fixup_abnormal_edges (void)
*** 8066,8073 ****
&& !can_throw_internal (insn)
&& insn != BB_HEAD (bb))
insn = PREV_INSN (insn);
! if (!CALL_P (insn) && !can_throw_internal (insn))
! abort ();
BB_END (bb) = insn;
inserted = true;
insn = NEXT_INSN (insn);
--- 8056,8062 ----
&& !can_throw_internal (insn)
&& insn != BB_HEAD (bb))
insn = PREV_INSN (insn);
! gcc_assert (CALL_P (insn) || can_throw_internal (insn));
BB_END (bb) = insn;
inserted = true;
insn = NEXT_INSN (insn);
Index: reload.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/reload.c,v
retrieving revision 1.252
diff -c -3 -p -r1.252 reload.c
*** reload.c 3 Sep 2004 19:34:15 -0000 1.252
--- reload.c 9 Sep 2004 14:26:36 -0000
*************** push_secondary_reload (int in_p, rtx x,
*** 388,404 ****
: REG_CLASS_FROM_CONSTRAINT ((unsigned char) insn_letter,
insn_constraint));
! if (insn_class == NO_REGS)
! abort ();
! if (in_p
! && insn_data[(int) icode].operand[!in_p].constraint[0] != '=')
! abort ();
}
/* The scratch register's constraint must start with "=&". */
! if (insn_data[(int) icode].operand[2].constraint[0] != '='
! || insn_data[(int) icode].operand[2].constraint[1] != '&')
! abort ();
if (reg_class_subset_p (reload_class, insn_class))
mode = insn_data[(int) icode].operand[2].mode;
--- 388,402 ----
: REG_CLASS_FROM_CONSTRAINT ((unsigned char) insn_letter,
insn_constraint));
! gcc_assert (insn_class != NO_REGS);
! gcc_assert (!in_p
! || insn_data[(int) icode].operand[!in_p].constraint[0]
! == '=');
}
/* The scratch register's constraint must start with "=&". */
! gcc_assert (insn_data[(int) icode].operand[2].constraint[0] == '='
! && insn_data[(int) icode].operand[2].constraint[1] == '&');
if (reg_class_subset_p (reload_class, insn_class))
mode = insn_data[(int) icode].operand[2].mode;
*************** push_secondary_reload (int in_p, rtx x,
*** 431,439 ****
Allow this when a reload_in/out pattern is being used. I.e. assume
that the generated code handles this case. */
! if (in_p && class == reload_class && icode == CODE_FOR_nothing
! && t_icode == CODE_FOR_nothing)
! abort ();
/* If we need a tertiary reload, see if we have one we can reuse or else
make a new one. */
--- 429,436 ----
Allow this when a reload_in/out pattern is being used. I.e. assume
that the generated code handles this case. */
! gcc_assert (!in_p || class != reload_class || icode != CODE_FOR_nothing
! || t_icode != CODE_FOR_nothing);
/* If we need a tertiary reload, see if we have one we can reuse or else
make a new one. */
*************** find_valid_class (enum machine_mode m1 A
*** 706,713 ****
}
}
! if (best_size == 0)
! abort ();
return best_class;
}
--- 703,709 ----
}
}
! gcc_assert (best_size != 0);
return best_class;
}
*************** push_reload (rtx in, rtx out, rtx *inloc
*** 1071,1078 ****
if (MEM_P (in))
/* This is supposed to happen only for paradoxical subregs made by
combine.c. (SUBREG (MEM)) isn't supposed to occur other ways. */
! if (GET_MODE_SIZE (GET_MODE (in)) > GET_MODE_SIZE (inmode))
! abort ();
#endif
inmode = GET_MODE (in);
}
--- 1067,1073 ----
if (MEM_P (in))
/* This is supposed to happen only for paradoxical subregs made by
combine.c. (SUBREG (MEM)) isn't supposed to occur other ways. */
! gcc_assert (GET_MODE_SIZE (GET_MODE (in)) <= GET_MODE_SIZE (inmode));
#endif
inmode = GET_MODE (in);
}
*************** push_reload (rtx in, rtx out, rtx *inloc
*** 1166,1174 ****
outloc = &SUBREG_REG (out);
out = *outloc;
#if ! defined (LOAD_EXTEND_OP) && ! defined (WORD_REGISTER_OPERATIONS)
! if (MEM_P (out)
! && GET_MODE_SIZE (GET_MODE (out)) > GET_MODE_SIZE (outmode))
! abort ();
#endif
outmode = GET_MODE (out);
}
--- 1161,1169 ----
outloc = &SUBREG_REG (out);
out = *outloc;
#if ! defined (LOAD_EXTEND_OP) && ! defined (WORD_REGISTER_OPERATIONS)
! gcc_assert (!MEM_P (out)
! || GET_MODE_SIZE (GET_MODE (out))
! <= GET_MODE_SIZE (outmode));
#endif
outmode = GET_MODE (out);
}
*************** push_reload (rtx in, rtx out, rtx *inloc
*** 1289,1297 ****
/* Optional output reloads are always OK even if we have no register class,
since the function of these reloads is only to have spill_reg_store etc.
set, so that the storing insn can be deleted later. */
! if (class == NO_REGS
! && (optional == 0 || type != RELOAD_FOR_OUTPUT))
! abort ();
i = find_reusable_reload (&in, out, class, type, opnum, dont_share);
--- 1284,1291 ----
/* Optional output reloads are always OK even if we have no register class,
since the function of these reloads is only to have spill_reg_store etc.
set, so that the storing insn can be deleted later. */
! gcc_assert (class != NO_REGS
! || (optional != 0 && type == RELOAD_FOR_OUTPUT));
i = find_reusable_reload (&in, out, class, type, opnum, dont_share);
*************** push_reload (rtx in, rtx out, rtx *inloc
*** 1445,1452 ****
/* If we did not find a nonzero amount-to-increment-by,
that contradicts the belief that IN is being incremented
in an address in this insn. */
! if (rld[i].inc == 0)
! abort ();
}
#endif
--- 1439,1445 ----
/* If we did not find a nonzero amount-to-increment-by,
that contradicts the belief that IN is being incremented
in an address in this insn. */
! gcc_assert (rld[i].inc != 0);
}
#endif
*************** operands_match_p (rtx x, rtx y)
*** 2246,2252 ****
contain anything but integers and other rtx's,
except for within LABEL_REFs and SYMBOL_REFs. */
default:
! abort ();
}
}
return 1 + success_2;
--- 2239,2245 ----
contain anything but integers and other rtx's,
except for within LABEL_REFs and SYMBOL_REFs. */
default:
! gcc_unreachable ();
}
}
return 1 + success_2;
*************** decompose (rtx x)
*** 2268,2365 ****
memset (&val, 0, sizeof (val));
! if (MEM_P (x))
! {
! rtx base = NULL_RTX, offset = 0;
! rtx addr = XEXP (x, 0);
!
! if (GET_CODE (addr) == PRE_DEC || GET_CODE (addr) == PRE_INC
! || GET_CODE (addr) == POST_DEC || GET_CODE (addr) == POST_INC)
! {
! val.base = XEXP (addr, 0);
! val.start = -GET_MODE_SIZE (GET_MODE (x));
! val.end = GET_MODE_SIZE (GET_MODE (x));
! val.safe = REGNO (val.base) == STACK_POINTER_REGNUM;
! return val;
! }
!
! if (GET_CODE (addr) == PRE_MODIFY || GET_CODE (addr) == POST_MODIFY)
! {
! if (GET_CODE (XEXP (addr, 1)) == PLUS
! && XEXP (addr, 0) == XEXP (XEXP (addr, 1), 0)
! && CONSTANT_P (XEXP (XEXP (addr, 1), 1)))
! {
! val.base = XEXP (addr, 0);
! val.start = -INTVAL (XEXP (XEXP (addr, 1), 1));
! val.end = INTVAL (XEXP (XEXP (addr, 1), 1));
! val.safe = REGNO (val.base) == STACK_POINTER_REGNUM;
! return val;
! }
! }
!
! if (GET_CODE (addr) == CONST)
! {
! addr = XEXP (addr, 0);
! all_const = 1;
! }
! if (GET_CODE (addr) == PLUS)
! {
! if (CONSTANT_P (XEXP (addr, 0)))
! {
! base = XEXP (addr, 1);
! offset = XEXP (addr, 0);
! }
! else if (CONSTANT_P (XEXP (addr, 1)))
! {
! base = XEXP (addr, 0);
! offset = XEXP (addr, 1);
! }
! }
!
! if (offset == 0)
! {
! base = addr;
! offset = const0_rtx;
! }
! if (GET_CODE (offset) == CONST)
! offset = XEXP (offset, 0);
! if (GET_CODE (offset) == PLUS)
! {
! if (GET_CODE (XEXP (offset, 0)) == CONST_INT)
! {
! base = gen_rtx_PLUS (GET_MODE (base), base, XEXP (offset, 1));
! offset = XEXP (offset, 0);
! }
! else if (GET_CODE (XEXP (offset, 1)) == CONST_INT)
! {
! base = gen_rtx_PLUS (GET_MODE (base), base, XEXP (offset, 0));
! offset = XEXP (offset, 1);
! }
! else
! {
! base = gen_rtx_PLUS (GET_MODE (base), base, offset);
! offset = const0_rtx;
! }
! }
! else if (GET_CODE (offset) != CONST_INT)
! {
! base = gen_rtx_PLUS (GET_MODE (base), base, offset);
! offset = const0_rtx;
! }
!
! if (all_const && GET_CODE (base) == PLUS)
! base = gen_rtx_CONST (GET_MODE (base), base);
!
! if (GET_CODE (offset) != CONST_INT)
! abort ();
!
! val.start = INTVAL (offset);
! val.end = val.start + GET_MODE_SIZE (GET_MODE (x));
! val.base = base;
! return val;
! }
! else if (REG_P (x))
{
val.reg_flag = 1;
val.start = true_regnum (x);
if (val.start < 0)
--- 2261,2359 ----
memset (&val, 0, sizeof (val));
! switch (GET_CODE (x))
{
+ case MEM:
+ {
+ rtx base = NULL_RTX, offset = 0;
+ rtx addr = XEXP (x, 0);
+
+ if (GET_CODE (addr) == PRE_DEC || GET_CODE (addr) == PRE_INC
+ || GET_CODE (addr) == POST_DEC || GET_CODE (addr) == POST_INC)
+ {
+ val.base = XEXP (addr, 0);
+ val.start = -GET_MODE_SIZE (GET_MODE (x));
+ val.end = GET_MODE_SIZE (GET_MODE (x));
+ val.safe = REGNO (val.base) == STACK_POINTER_REGNUM;
+ return val;
+ }
+
+ if (GET_CODE (addr) == PRE_MODIFY || GET_CODE (addr) == POST_MODIFY)
+ {
+ if (GET_CODE (XEXP (addr, 1)) == PLUS
+ && XEXP (addr, 0) == XEXP (XEXP (addr, 1), 0)
+ && CONSTANT_P (XEXP (XEXP (addr, 1), 1)))
+ {
+ val.base = XEXP (addr, 0);
+ val.start = -INTVAL (XEXP (XEXP (addr, 1), 1));
+ val.end = INTVAL (XEXP (XEXP (addr, 1), 1));
+ val.safe = REGNO (val.base) == STACK_POINTER_REGNUM;
+ return val;
+ }
+ }
+
+ if (GET_CODE (addr) == CONST)
+ {
+ addr = XEXP (addr, 0);
+ all_const = 1;
+ }
+ if (GET_CODE (addr) == PLUS)
+ {
+ if (CONSTANT_P (XEXP (addr, 0)))
+ {
+ base = XEXP (addr, 1);
+ offset = XEXP (addr, 0);
+ }
+ else if (CONSTANT_P (XEXP (addr, 1)))
+ {
+ base = XEXP (addr, 0);
+ offset = XEXP (addr, 1);
+ }
+ }
+
+ if (offset == 0)
+ {
+ base = addr;
+ offset = const0_rtx;
+ }
+ if (GET_CODE (offset) == CONST)
+ offset = XEXP (offset, 0);
+ if (GET_CODE (offset) == PLUS)
+ {
+ if (GET_CODE (XEXP (offset, 0)) == CONST_INT)
+ {
+ base = gen_rtx_PLUS (GET_MODE (base), base, XEXP (offset, 1));
+ offset = XEXP (offset, 0);
+ }
+ else if (GET_CODE (XEXP (offset, 1)) == CONST_INT)
+ {
+ base = gen_rtx_PLUS (GET_MODE (base), base, XEXP (offset, 0));
+ offset = XEXP (offset, 1);
+ }
+ else
+ {
+ base = gen_rtx_PLUS (GET_MODE (base), base, offset);
+ offset = const0_rtx;
+ }
+ }
+ else if (GET_CODE (offset) != CONST_INT)
+ {
+ base = gen_rtx_PLUS (GET_MODE (base), base, offset);
+ offset = const0_rtx;
+ }
+
+ if (all_const && GET_CODE (base) == PLUS)
+ base = gen_rtx_CONST (GET_MODE (base), base);
+
+ gcc_assert (GET_CODE (offset) == CONST_INT);
+
+ val.start = INTVAL (offset);
+ val.end = val.start + GET_MODE_SIZE (GET_MODE (x));
+ val.base = base;
+ }
+ break;
+
+ case REG:
val.reg_flag = 1;
val.start = true_regnum (x);
if (val.start < 0)
*************** decompose (rtx x)
*** 2371,2379 ****
else
/* A hard reg. */
val.end = val.start + hard_regno_nregs[val.start][GET_MODE (x)];
! }
! else if (GET_CODE (x) == SUBREG)
! {
if (!REG_P (SUBREG_REG (x)))
/* This could be more precise, but it's good enough. */
return decompose (SUBREG_REG (x));
--- 2365,2373 ----
else
/* A hard reg. */
val.end = val.start + hard_regno_nregs[val.start][GET_MODE (x)];
! break;
!
! case SUBREG:
if (!REG_P (SUBREG_REG (x)))
/* This could be more precise, but it's good enough. */
return decompose (SUBREG_REG (x));
*************** decompose (rtx x)
*** 2384,2396 ****
else
/* A hard reg. */
val.end = val.start + hard_regno_nregs[val.start][GET_MODE (x)];
}
- else if (CONSTANT_P (x)
- /* This hasn't been assigned yet, so it can't conflict yet. */
- || GET_CODE (x) == SCRATCH)
- val.safe = 1;
- else
- abort ();
return val;
}
--- 2378,2395 ----
else
/* A hard reg. */
val.end = val.start + hard_regno_nregs[val.start][GET_MODE (x)];
+ break;
+
+ case SCRATCH:
+ /* This hasn't been assigned yet, so it can't conflict yet. */
+ val.safe = 1;
+ break;
+
+ default:
+ gcc_assert (CONSTANT_P (x));
+ val.safe = 1;
+ break;
}
return val;
}
*************** immune_p (rtx x, rtx y, struct decomposi
*** 2407,2414 ****
if (ydata.safe)
return 1;
! if (!MEM_P (y))
! abort ();
/* If Y is memory and X is not, Y can't affect X. */
if (!MEM_P (x))
return 1;
--- 2406,2412 ----
if (ydata.safe)
return 1;
! gcc_assert (MEM_P (y));
/* If Y is memory and X is not, Y can't affect X. */
if (!MEM_P (x))
return 1;
*************** find_reloads (rtx insn, int replace, int
*** 2623,2630 ****
case '%':
{
/* The last operand should not be marked commutative. */
! if (i == noperands - 1)
! abort ();
/* We currently only support one commutative pair of
operands. Some existing asm code currently uses more
--- 2621,2627 ----
case '%':
{
/* The last operand should not be marked commutative. */
! gcc_assert (i != noperands - 1);
/* We currently only support one commutative pair of
operands. Some existing asm code currently uses more
*************** find_reloads (rtx insn, int replace, int
*** 2635,2642 ****
future we may handle it correctly. */
if (commutative < 0)
commutative = i;
! else if (!this_insn_is_asm)
! abort ();
}
break;
/* Use of ISDIGIT is tempting here, but it may get expensive because
--- 2632,2639 ----
future we may handle it correctly. */
if (commutative < 0)
commutative = i;
! else
! gcc_assert (this_insn_is_asm);
}
break;
/* Use of ISDIGIT is tempting here, but it may get expensive because
*************** find_reloads (rtx insn, int replace, int
*** 2651,2658 ****
recog_data.operand[i]);
/* An operand may not match itself. */
! if (c == i)
! abort ();
/* If C can be commuted with C+1, and C might need to match I,
then C+1 might also need to match I. */
--- 2648,2654 ----
recog_data.operand[i]);
/* An operand may not match itself. */
! gcc_assert (c != i);
/* If C can be commuted with C+1, and C might need to match I,
then C+1 might also need to match I. */
*************** find_reloads (rtx insn, int replace, int
*** 3510,3526 ****
early_data = decompose (recog_data.operand[i]);
! if (modified[i] == RELOAD_READ)
! abort ();
if (this_alternative[i] == NO_REGS)
{
this_alternative_earlyclobber[i] = 0;
! if (this_insn_is_asm)
! error_for_asm (this_insn,
! "`&' constraint used with no register class");
! else
! abort ();
}
for (j = 0; j < noperands; j++)
--- 3506,3519 ----
early_data = decompose (recog_data.operand[i]);
! gcc_assert (modified[i] != RELOAD_READ);
if (this_alternative[i] == NO_REGS)
{
this_alternative_earlyclobber[i] = 0;
! gcc_assert (this_insn_is_asm);
! error_for_asm (this_insn,
! "`&' constraint used with no register class");
}
for (j = 0; j < noperands; j++)
*************** find_reloads (rtx insn, int replace, int
*** 3895,3904 ****
0, 0, i, RELOAD_OTHER);
operand_reloadnum[i] = output_reloadnum;
}
- else if (insn_code_number >= 0)
- abort ();
else
{
error_for_asm (insn, "inconsistent operand constraints in an `asm'");
/* Avoid further trouble with this insn. */
PATTERN (insn) = gen_rtx_USE (VOIDmode, const0_rtx);
--- 3888,3896 ----
0, 0, i, RELOAD_OTHER);
operand_reloadnum[i] = output_reloadnum;
}
else
{
+ gcc_assert (insn_code_number < 0);
error_for_asm (insn, "inconsistent operand constraints in an `asm'");
/* Avoid further trouble with this insn. */
PATTERN (insn) = gen_rtx_USE (VOIDmode, const0_rtx);
*************** find_reloads (rtx insn, int replace, int
*** 4354,4363 ****
do after the insn (such as for output addresses) are fine. */
if (no_input_reloads)
for (i = 0; i < n_reloads; i++)
! if (rld[i].in != 0
! && rld[i].when_needed != RELOAD_FOR_OUTADDR_ADDRESS
! && rld[i].when_needed != RELOAD_FOR_OUTPUT_ADDRESS)
! abort ();
#endif
/* Compute reload_mode and reload_nregs. */
--- 4346,4354 ----
do after the insn (such as for output addresses) are fine. */
if (no_input_reloads)
for (i = 0; i < n_reloads; i++)
! gcc_assert (rld[i].in == 0
! || rld[i].when_needed == RELOAD_FOR_OUTADDR_ADDRESS
! || rld[i].when_needed == RELOAD_FOR_OUTPUT_ADDRESS);
#endif
/* Compute reload_mode and reload_nregs. */
*************** find_reloads_toplev (rtx x, int opnum, e
*** 4533,4540 ****
tem =
simplify_gen_subreg (GET_MODE (x), reg_equiv_constant[regno],
GET_MODE (SUBREG_REG (x)), SUBREG_BYTE (x));
! if (!tem)
! abort ();
return tem;
}
--- 4524,4530 ----
tem =
simplify_gen_subreg (GET_MODE (x), reg_equiv_constant[regno],
GET_MODE (SUBREG_REG (x)), SUBREG_BYTE (x));
! gcc_assert (tem);
return tem;
}
*************** find_reloads_address_1 (enum machine_mod
*** 5392,5397 ****
--- 5382,5389 ----
{
rtx op0 = XEXP (x, 0);
rtx op1 = XEXP (x, 1);
+ int regno;
+ int reloadnum;
if (GET_CODE (op1) != PLUS && GET_CODE (op1) != MINUS)
return 0;
*************** find_reloads_address_1 (enum machine_mod
*** 5400,5407 ****
where a base register is {inc,dec}remented by the contents
of another register or by a constant value. Thus, these
operands must match. */
! if (op0 != XEXP (op1, 0))
! abort ();
/* Require index register (or constant). Let's just handle the
register case in the meantime... If the target allows
--- 5392,5398 ----
where a base register is {inc,dec}remented by the contents
of another register or by a constant value. Thus, these
operands must match. */
! gcc_assert (op0 == XEXP (op1, 0));
/* Require index register (or constant). Let's just handle the
register case in the meantime... If the target allows
*************** find_reloads_address_1 (enum machine_mod
*** 5412,5478 ****
find_reloads_address_1 (mode, XEXP (op1, 1), 1, &XEXP (op1, 1),
opnum, type, ind_levels, insn);
! if (REG_P (XEXP (op1, 0)))
{
! int regno = REGNO (XEXP (op1, 0));
! int reloadnum;
! /* A register that is incremented cannot be constant! */
! if (regno >= FIRST_PSEUDO_REGISTER
! && reg_equiv_constant[regno] != 0)
! abort ();
!
! /* Handle a register that is equivalent to a memory location
! which cannot be addressed directly. */
! if (reg_equiv_memory_loc[regno] != 0
! && (reg_equiv_address[regno] != 0
! || num_not_at_initial_offset))
{
! rtx tem = make_memloc (XEXP (x, 0), regno);
! if (reg_equiv_address[regno]
! || ! rtx_equal_p (tem, reg_equiv_mem[regno]))
! {
! /* First reload the memory location's address.
! We can't use ADDR_TYPE (type) here, because we need to
! write back the value after reading it, hence we actually
! need two registers. */
! find_reloads_address (GET_MODE (tem), &tem, XEXP (tem, 0),
! &XEXP (tem, 0), opnum,
! RELOAD_OTHER,
! ind_levels, insn);
!
! /* Then reload the memory location into a base
! register. */
! reloadnum = push_reload (tem, tem, &XEXP (x, 0),
! &XEXP (op1, 0),
! MODE_BASE_REG_CLASS (mode),
! GET_MODE (x), GET_MODE (x), 0,
! 0, opnum, RELOAD_OTHER);
! update_auto_inc_notes (this_insn, regno, reloadnum);
! return 0;
! }
}
! if (reg_renumber[regno] >= 0)
! regno = reg_renumber[regno];
! /* We require a base register here... */
! if (!REGNO_MODE_OK_FOR_BASE_P (regno, GET_MODE (x)))
! {
! reloadnum = push_reload (XEXP (op1, 0), XEXP (x, 0),
! &XEXP (op1, 0), &XEXP (x, 0),
! MODE_BASE_REG_CLASS (mode),
! GET_MODE (x), GET_MODE (x), 0, 0,
! opnum, RELOAD_OTHER);
! update_auto_inc_notes (this_insn, regno, reloadnum);
! return 0;
! }
}
- else
- abort ();
}
return 0;
--- 5403,5464 ----
find_reloads_address_1 (mode, XEXP (op1, 1), 1, &XEXP (op1, 1),
opnum, type, ind_levels, insn);
! gcc_assert (REG_P (XEXP (op1, 0)));
!
! regno = REGNO (XEXP (op1, 0));
!
! /* A register that is incremented cannot be constant! */
! gcc_assert (regno < FIRST_PSEUDO_REGISTER
! || reg_equiv_constant[regno] == 0);
!
! /* Handle a register that is equivalent to a memory location
! which cannot be addressed directly. */
! if (reg_equiv_memory_loc[regno] != 0
! && (reg_equiv_address[regno] != 0
! || num_not_at_initial_offset))
{
! rtx tem = make_memloc (XEXP (x, 0), regno);
! if (reg_equiv_address[regno]
! || ! rtx_equal_p (tem, reg_equiv_mem[regno]))
{
! /* First reload the memory location's address.
! We can't use ADDR_TYPE (type) here, because we need to
! write back the value after reading it, hence we actually
! need two registers. */
! find_reloads_address (GET_MODE (tem), &tem, XEXP (tem, 0),
! &XEXP (tem, 0), opnum,
! RELOAD_OTHER,
! ind_levels, insn);
! /* Then reload the memory location into a base
! register. */
! reloadnum = push_reload (tem, tem, &XEXP (x, 0),
! &XEXP (op1, 0),
! MODE_BASE_REG_CLASS (mode),
! GET_MODE (x), GET_MODE (x), 0,
! 0, opnum, RELOAD_OTHER);
! update_auto_inc_notes (this_insn, regno, reloadnum);
! return 0;
}
+ }
! if (reg_renumber[regno] >= 0)
! regno = reg_renumber[regno];
! /* We require a base register here... */
! if (!REGNO_MODE_OK_FOR_BASE_P (regno, GET_MODE (x)))
! {
! reloadnum = push_reload (XEXP (op1, 0), XEXP (x, 0),
! &XEXP (op1, 0), &XEXP (x, 0),
! MODE_BASE_REG_CLASS (mode),
! GET_MODE (x), GET_MODE (x), 0, 0,
! opnum, RELOAD_OTHER);
! update_auto_inc_notes (this_insn, regno, reloadnum);
! return 0;
}
}
return 0;
*************** find_reloads_address_1 (enum machine_mod
*** 5487,5495 ****
rtx x_orig = x;
/* A register that is incremented cannot be constant! */
! if (regno >= FIRST_PSEUDO_REGISTER
! && reg_equiv_constant[regno] != 0)
! abort ();
/* Handle a register that is equivalent to a memory location
which cannot be addressed directly. */
--- 5473,5480 ----
rtx x_orig = x;
/* A register that is incremented cannot be constant! */
! gcc_assert (regno < FIRST_PSEUDO_REGISTER
! || reg_equiv_constant[regno] == 0);
/* Handle a register that is equivalent to a memory location
which cannot be addressed directly. */
*************** subst_reloads (rtx insn)
*** 5953,5962 ****
for (check_regno = 0; check_regno < max_regno; check_regno++)
{
#define CHECK_MODF(ARRAY) \
! if (ARRAY[check_regno] \
! && loc_mentioned_in_p (r->where, \
! ARRAY[check_regno])) \
! abort ()
CHECK_MODF (reg_equiv_constant);
CHECK_MODF (reg_equiv_memory_loc);
--- 5938,5946 ----
for (check_regno = 0; check_regno < max_regno; check_regno++)
{
#define CHECK_MODF(ARRAY) \
! gcc_assert (!ARRAY[check_regno] \
! || !loc_mentioned_in_p (r->where, \
! ARRAY[check_regno]))
CHECK_MODF (reg_equiv_constant);
CHECK_MODF (reg_equiv_memory_loc);
*************** subst_reloads (rtx insn)
*** 6011,6018 ****
*r->where = reloadreg;
}
/* If reload got no reg and isn't optional, something's wrong. */
! else if (! rld[r->what].optional)
! abort ();
}
}
--- 5995,6002 ----
*r->where = reloadreg;
}
/* If reload got no reg and isn't optional, something's wrong. */
! else
! gcc_assert (rld[r->what].optional);
}
}
*************** copy_replacements (rtx x, rtx y)
*** 6024,6031 ****
{
/* We can't support X being a SUBREG because we might then need to know its
location if something inside it was replaced. */
! if (GET_CODE (x) == SUBREG)
! abort ();
copy_replacements_1 (&x, &y, n_replacements);
}
--- 6008,6014 ----
{
/* We can't support X being a SUBREG because we might then need to know its
location if something inside it was replaced. */
! gcc_assert (GET_CODE (x) != SUBREG);
copy_replacements_1 (&x, &y, n_replacements);
}
*************** refers_to_regno_for_reload_p (unsigned i
*** 6194,6203 ****
reg_equiv_memory_loc[r],
(rtx*) 0);
! if (reg_equiv_constant[r])
! return 0;
!
! abort ();
}
return (endregno > r
--- 6177,6184 ----
reg_equiv_memory_loc[r],
(rtx*) 0);
! gcc_assert (reg_equiv_constant[r]);
! return 0;
}
return (endregno > r
*************** reg_overlap_mentioned_for_reload_p (rtx
*** 6322,6330 ****
{
if (reg_equiv_memory_loc[regno])
return refers_to_mem_for_reload_p (in);
! else if (reg_equiv_constant[regno])
! return 0;
! abort ();
}
}
else if (MEM_P (x))
--- 6303,6310 ----
{
if (reg_equiv_memory_loc[regno])
return refers_to_mem_for_reload_p (in);
! gcc_assert (reg_equiv_constant[regno]);
! return 0;
}
}
else if (MEM_P (x))
*************** reg_overlap_mentioned_for_reload_p (rtx
*** 6332,6339 ****
else if (GET_CODE (x) == SCRATCH || GET_CODE (x) == PC
|| GET_CODE (x) == CC0)
return reg_mentioned_p (x, in);
! else if (GET_CODE (x) == PLUS)
{
/* We actually want to know if X is mentioned somewhere inside IN.
We must not say that (plus (sp) (const_int 124)) is in
(plus (sp) (const_int 64)), since that can lead to incorrect reload
--- 6312,6321 ----
else if (GET_CODE (x) == SCRATCH || GET_CODE (x) == PC
|| GET_CODE (x) == CC0)
return reg_mentioned_p (x, in);
! else
{
+ gcc_assert (GET_CODE (x) == PLUS);
+
/* We actually want to know if X is mentioned somewhere inside IN.
We must not say that (plus (sp) (const_int 124)) is in
(plus (sp) (const_int 64)), since that can lead to incorrect reload
*************** reg_overlap_mentioned_for_reload_p (rtx
*** 6349,6356 ****
else return (reg_overlap_mentioned_for_reload_p (XEXP (x, 0), in)
|| reg_overlap_mentioned_for_reload_p (XEXP (x, 1), in));
}
- else
- abort ();
endregno = regno + (regno < FIRST_PSEUDO_REGISTER
? hard_regno_nregs[regno][GET_MODE (x)] : 1);
--- 6331,6336 ----
Index: reorg.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/reorg.c,v
retrieving revision 1.101
diff -c -3 -p -r1.101 reorg.c
*** reorg.c 25 Aug 2004 08:20:11 -0000 1.101
--- reorg.c 9 Sep 2004 14:26:44 -0000
*************** stop_search_p (rtx insn, int labels_p)
*** 253,259 ****
|| asm_noperands (PATTERN (insn)) >= 0);
default:
! abort ();
}
}
--- 253,259 ----
|| asm_noperands (PATTERN (insn)) >= 0);
default:
! gcc_unreachable ();
}
}
*************** emit_delay_sequence (rtx insn, rtx list,
*** 564,571 ****
if (had_barrier)
emit_barrier_after (seq_insn);
! if (i != length + 1)
! abort ();
return seq_insn;
}
--- 564,570 ----
if (had_barrier)
emit_barrier_after (seq_insn);
! gcc_assert (i == length + 1);
return seq_insn;
}
*************** get_jump_flags (rtx insn, rtx label)
*** 887,893 ****
break;
default:
! abort ();
}
}
else
--- 886,892 ----
break;
default:
! gcc_unreachable ();
}
}
else
*************** fill_slots_from_thread (rtx insn, rtx co
*** 2549,2557 ****
int flags;
/* Validate our arguments. */
! if ((condition == const_true_rtx && ! thread_if_true)
! || (! own_thread && ! thread_if_true))
! abort ();
flags = get_jump_flags (insn, JUMP_LABEL (insn));
--- 2548,2555 ----
int flags;
/* Validate our arguments. */
! gcc_assert(condition != const_true_rtx || thread_if_true);
! gcc_assert(own_thread || thread_if_true);
flags = get_jump_flags (insn, JUMP_LABEL (insn));
*************** fill_slots_from_thread (rtx insn, rtx co
*** 2921,2928 ****
{
rtx label;
! if (! thread_if_true)
! abort ();
if (new_thread && JUMP_P (new_thread)
&& (simplejump_p (new_thread)
--- 2919,2925 ----
{
rtx label;
! gcc_assert (thread_if_true);
if (new_thread && JUMP_P (new_thread)
&& (simplejump_p (new_thread)
*************** relax_delay_slots (rtx first)
*** 3228,3235 ****
trial = PREV_INSN (insn);
delete_related_insns (insn);
! if (GET_CODE (pat) != SEQUENCE)
! abort ();
after = trial;
for (i = 0; i < XVECLEN (pat, 0); i++)
{
--- 3225,3231 ----
trial = PREV_INSN (insn);
delete_related_insns (insn);
! gcc_assert (GET_CODE (pat) == SEQUENCE);
after = trial;
for (i = 0; i < XVECLEN (pat, 0); i++)
{
*************** relax_delay_slots (rtx first)
*** 3347,3354 ****
trial = PREV_INSN (insn);
delete_related_insns (insn);
! if (GET_CODE (pat) != SEQUENCE)
! abort ();
after = trial;
for (i = 0; i < XVECLEN (pat, 0); i++)
{
--- 3343,3349 ----
trial = PREV_INSN (insn);
delete_related_insns (insn);
! gcc_assert (GET_CODE (pat) == SEQUENCE);
after = trial;
for (i = 0; i < XVECLEN (pat, 0); i++)
{
Index: resource.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/resource.c,v
retrieving revision 1.73
diff -c -3 -p -r1.73 resource.c
*** resource.c 18 Aug 2004 08:24:11 -0000 1.73
--- resource.c 9 Sep 2004 14:26:47 -0000
*************** mark_referenced_resources (rtx x, struct
*** 233,240 ****
unsigned int last_regno
= regno + hard_regno_nregs[regno][GET_MODE (x)];
! if (last_regno > FIRST_PSEUDO_REGISTER)
! abort ();
for (r = regno; r < last_regno; r++)
SET_HARD_REG_BIT (res->regs, r);
}
--- 233,239 ----
unsigned int last_regno
= regno + hard_regno_nregs[regno][GET_MODE (x)];
! gcc_assert (last_regno <= FIRST_PSEUDO_REGISTER);
for (r = regno; r < last_regno; r++)
SET_HARD_REG_BIT (res->regs, r);
}
*************** mark_referenced_resources (rtx x, struct
*** 246,253 ****
unsigned int last_regno
= regno + hard_regno_nregs[regno][GET_MODE (x)];
! if (last_regno > FIRST_PSEUDO_REGISTER)
! abort ();
for (r = regno; r < last_regno; r++)
SET_HARD_REG_BIT (res->regs, r);
}
--- 245,251 ----
unsigned int last_regno
= regno + hard_regno_nregs[regno][GET_MODE (x)];
! gcc_assert (last_regno <= FIRST_PSEUDO_REGISTER);
for (r = regno; r < last_regno; r++)
SET_HARD_REG_BIT (res->regs, r);
}
*************** mark_referenced_resources (rtx x, struct
*** 340,347 ****
{
sequence = PATTERN (NEXT_INSN (insn));
seq_size = XVECLEN (sequence, 0);
! if (GET_CODE (sequence) != SEQUENCE)
! abort ();
}
res->memory = 1;
--- 338,344 ----
{
sequence = PATTERN (NEXT_INSN (insn));
seq_size = XVECLEN (sequence, 0);
! gcc_assert (GET_CODE (sequence) == SEQUENCE);
}
res->memory = 1;
*************** mark_set_resources (rtx x, struct resour
*** 771,778 ****
unsigned int last_regno
= regno + hard_regno_nregs[regno][GET_MODE (x)];
! if (last_regno > FIRST_PSEUDO_REGISTER)
! abort ();
for (r = regno; r < last_regno; r++)
SET_HARD_REG_BIT (res->regs, r);
}
--- 768,774 ----
unsigned int last_regno
= regno + hard_regno_nregs[regno][GET_MODE (x)];
! gcc_assert (last_regno <= FIRST_PSEUDO_REGISTER);
for (r = regno; r < last_regno; r++)
SET_HARD_REG_BIT (res->regs, r);
}
*************** mark_set_resources (rtx x, struct resour
*** 786,793 ****
unsigned int last_regno
= regno + hard_regno_nregs[regno][GET_MODE (x)];
! if (last_regno > FIRST_PSEUDO_REGISTER)
! abort ();
for (r = regno; r < last_regno; r++)
SET_HARD_REG_BIT (res->regs, r);
}
--- 782,788 ----
unsigned int last_regno
= regno + hard_regno_nregs[regno][GET_MODE (x)];
! gcc_assert (last_regno <= FIRST_PSEUDO_REGISTER);
for (r = regno; r < last_regno; r++)
SET_HARD_REG_BIT (res->regs, r);
}
Index: rtlanal.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/rtlanal.c,v
retrieving revision 1.199
diff -c -3 -p -r1.199 rtlanal.c
*** rtlanal.c 18 Aug 2004 08:24:12 -0000 1.199
--- rtlanal.c 9 Sep 2004 14:26:55 -0000
*************** insn_dependent_p (rtx x, rtx y)
*** 1123,1130 ****
{
rtx tmp;
! if (! INSN_P (x) || ! INSN_P (y))
! abort ();
tmp = PATTERN (y);
note_stores (PATTERN (x), insn_dependent_p_1, &tmp);
--- 1123,1130 ----
{
rtx tmp;
! gcc_assert (INSN_P (x));
! gcc_assert (INSN_P (y));
tmp = PATTERN (y);
note_stores (PATTERN (x), insn_dependent_p_1, &tmp);
*************** reg_overlap_mentioned_p (rtx x, rtx in)
*** 1578,1588 ****
}
default:
! #ifdef ENABLE_CHECKING
! if (!CONSTANT_P (x))
! abort ();
! #endif
!
return 0;
}
}
--- 1578,1584 ----
}
default:
! gcc_assert (CONSTANT_P (x));
return 0;
}
}
*************** dead_or_set_p (rtx insn, rtx x)
*** 1744,1751 ****
if (GET_CODE (x) == CC0)
return 1;
! if (!REG_P (x))
! abort ();
regno = REGNO (x);
last_regno = (regno >= FIRST_PSEUDO_REGISTER ? regno
--- 1740,1746 ----
if (GET_CODE (x) == CC0)
return 1;
! gcc_assert (REG_P (x));
regno = REGNO (x);
last_regno = (regno >= FIRST_PSEUDO_REGISTER ? regno
*************** find_reg_fusage (rtx insn, enum rtx_code
*** 1927,1934 ****
if (!CALL_P (insn))
return 0;
! if (! datum)
! abort ();
if (!REG_P (datum))
{
--- 1922,1928 ----
if (!CALL_P (insn))
return 0;
! gcc_assert (datum);
if (!REG_P (datum))
{
*************** remove_note (rtx insn, rtx note)
*** 2040,2046 ****
return;
}
! abort ();
}
/* Search LISTP (an EXPR_LIST) for an entry whose first operand is NODE and
--- 2034,2040 ----
return;
}
! gcc_unreachable ();
}
/* Search LISTP (an EXPR_LIST) for an entry whose first operand is NODE and
*************** replace_rtx (rtx x, rtx from, rtx to)
*** 2520,2527 ****
x = simplify_subreg (GET_MODE (x), new,
GET_MODE (SUBREG_REG (x)),
SUBREG_BYTE (x));
! if (! x)
! abort ();
}
else
SUBREG_REG (x) = new;
--- 2514,2520 ----
x = simplify_subreg (GET_MODE (x), new,
GET_MODE (SUBREG_REG (x)),
SUBREG_BYTE (x));
! gcc_assert (x);
}
else
SUBREG_REG (x) = new;
*************** replace_rtx (rtx x, rtx from, rtx to)
*** 2536,2543 ****
{
x = simplify_unary_operation (ZERO_EXTEND, GET_MODE (x),
new, GET_MODE (XEXP (x, 0)));
! if (! x)
! abort ();
}
else
XEXP (x, 0) = new;
--- 2529,2535 ----
{
x = simplify_unary_operation (ZERO_EXTEND, GET_MODE (x),
new, GET_MODE (XEXP (x, 0)));
! gcc_assert (x);
}
else
XEXP (x, 0) = new;
*************** subreg_lsb_1 (enum machine_mode outer_mo
*** 3189,3199 ****
if (WORDS_BIG_ENDIAN != BYTES_BIG_ENDIAN)
/* If the subreg crosses a word boundary ensure that
it also begins and ends on a word boundary. */
! if ((subreg_byte % UNITS_PER_WORD
! + GET_MODE_SIZE (outer_mode)) > UNITS_PER_WORD
! && (subreg_byte % UNITS_PER_WORD
! || GET_MODE_SIZE (outer_mode) % UNITS_PER_WORD))
! abort ();
if (WORDS_BIG_ENDIAN)
word = (GET_MODE_SIZE (inner_mode)
--- 3181,3190 ----
if (WORDS_BIG_ENDIAN != BYTES_BIG_ENDIAN)
/* If the subreg crosses a word boundary ensure that
it also begins and ends on a word boundary. */
! gcc_assert (!((subreg_byte % UNITS_PER_WORD
! + GET_MODE_SIZE (outer_mode)) > UNITS_PER_WORD
! && (subreg_byte % UNITS_PER_WORD
! || GET_MODE_SIZE (outer_mode) % UNITS_PER_WORD)));
if (WORDS_BIG_ENDIAN)
word = (GET_MODE_SIZE (inner_mode)
*************** subreg_regno_offset (unsigned int xregno
*** 3236,3243 ****
int mode_multiple, nregs_multiple;
int y_offset;
! if (xregno >= FIRST_PSEUDO_REGISTER)
! abort ();
nregs_xmode = hard_regno_nregs[xregno][xmode];
nregs_ymode = hard_regno_nregs[xregno][ymode];
--- 3227,3233 ----
int mode_multiple, nregs_multiple;
int y_offset;
! gcc_assert (xregno < FIRST_PSEUDO_REGISTER);
nregs_xmode = hard_regno_nregs[xregno][xmode];
nregs_ymode = hard_regno_nregs[xregno][ymode];
*************** subreg_regno_offset (unsigned int xregno
*** 3256,3263 ****
/* size of ymode must not be greater than the size of xmode. */
mode_multiple = GET_MODE_SIZE (xmode) / GET_MODE_SIZE (ymode);
! if (mode_multiple == 0)
! abort ();
y_offset = offset / GET_MODE_SIZE (ymode);
nregs_multiple = nregs_xmode / nregs_ymode;
--- 3246,3252 ----
/* size of ymode must not be greater than the size of xmode. */
mode_multiple = GET_MODE_SIZE (xmode) / GET_MODE_SIZE (ymode);
! gcc_assert (mode_multiple != 0);
y_offset = offset / GET_MODE_SIZE (ymode);
nregs_multiple = nregs_xmode / nregs_ymode;
*************** subreg_offset_representable_p (unsigned
*** 3279,3286 ****
int mode_multiple, nregs_multiple;
int y_offset;
! if (xregno >= FIRST_PSEUDO_REGISTER)
! abort ();
nregs_xmode = hard_regno_nregs[xregno][xmode];
nregs_ymode = hard_regno_nregs[xregno][ymode];
--- 3268,3274 ----
int mode_multiple, nregs_multiple;
int y_offset;
! gcc_assert (xregno < FIRST_PSEUDO_REGISTER);
nregs_xmode = hard_regno_nregs[xregno][xmode];
nregs_ymode = hard_regno_nregs[xregno][ymode];
*************** subreg_offset_representable_p (unsigned
*** 3296,3310 ****
if (offset == subreg_lowpart_offset (ymode, xmode))
return true;
- #ifdef ENABLE_CHECKING
/* This should always pass, otherwise we don't know how to verify the
constraint. These conditions may be relaxed but subreg_offset would
need to be redesigned. */
! if (GET_MODE_SIZE (xmode) % GET_MODE_SIZE (ymode)
! || GET_MODE_SIZE (ymode) % nregs_ymode
! || nregs_xmode % nregs_ymode)
! abort ();
! #endif
/* The XMODE value can be seen as a vector of NREGS_XMODE
values. The subreg must represent a lowpart of given field.
--- 3284,3295 ----
if (offset == subreg_lowpart_offset (ymode, xmode))
return true;
/* This should always pass, otherwise we don't know how to verify the
constraint. These conditions may be relaxed but subreg_offset would
need to be redesigned. */
! gcc_assert ((GET_MODE_SIZE (xmode) % GET_MODE_SIZE (ymode)) == 0);
! gcc_assert ((GET_MODE_SIZE (ymode) % nregs_ymode) == 0);
! gcc_assert ((nregs_xmode % nregs_ymode) == 0);
/* The XMODE value can be seen as a vector of NREGS_XMODE
values. The subreg must represent a lowpart of given field.
*************** subreg_offset_representable_p (unsigned
*** 3316,3331 ****
/* size of ymode must not be greater than the size of xmode. */
mode_multiple = GET_MODE_SIZE (xmode) / GET_MODE_SIZE (ymode);
! if (mode_multiple == 0)
! abort ();
y_offset = offset / GET_MODE_SIZE (ymode);
nregs_multiple = nregs_xmode / nregs_ymode;
! #ifdef ENABLE_CHECKING
! if (offset % GET_MODE_SIZE (ymode)
! || mode_multiple % nregs_multiple)
! abort ();
! #endif
return (!(y_offset % (mode_multiple / nregs_multiple)));
}
--- 3301,3314 ----
/* size of ymode must not be greater than the size of xmode. */
mode_multiple = GET_MODE_SIZE (xmode) / GET_MODE_SIZE (ymode);
! gcc_assert (mode_multiple != 0);
y_offset = offset / GET_MODE_SIZE (ymode);
nregs_multiple = nregs_xmode / nregs_ymode;
!
! gcc_assert ((offset % GET_MODE_SIZE (ymode)) == 0);
! gcc_assert ((mode_multiple % nregs_multiple) == 0);
!
return (!(y_offset % (mode_multiple / nregs_multiple)));
}
*************** find_first_parameter_load (rtx call_insn
*** 3380,3387 ****
if (GET_CODE (XEXP (p, 0)) == USE
&& REG_P (XEXP (XEXP (p, 0), 0)))
{
! if (REGNO (XEXP (XEXP (p, 0), 0)) >= FIRST_PSEUDO_REGISTER)
! abort ();
/* We only care about registers which can hold function
arguments. */
--- 3363,3369 ----
if (GET_CODE (XEXP (p, 0)) == USE
&& REG_P (XEXP (XEXP (p, 0), 0)))
{
! gcc_assert (REGNO (XEXP (XEXP (p, 0), 0)) < FIRST_PSEUDO_REGISTER);
/* We only care about registers which can hold function
arguments. */
*************** find_first_parameter_load (rtx call_insn
*** 3409,3416 ****
CODE_LABEL. */
if (LABEL_P (before))
{
! if (before != boundary)
! abort ();
break;
}
--- 3391,3397 ----
CODE_LABEL. */
if (LABEL_P (before))
{
! gcc_assert (before == boundary);
break;
}
*************** can_hoist_insn_p (rtx insn, rtx val, reg
*** 3571,3577 ****
}
break;
default:
! abort ();
}
return true;
}
--- 3552,3558 ----
}
break;
default:
! gcc_unreachable ();
}
return true;
}
*************** hoist_update_store (rtx insn, rtx *xp, r
*** 3603,3610 ****
x = *xp;
}
! if (!REG_P (x))
! abort ();
/* We've verified that hard registers are dead, so we may keep the side
effect. Otherwise replace it by new pseudo. */
--- 3584,3590 ----
x = *xp;
}
! gcc_assert (REG_P (x));
/* We've verified that hard registers are dead, so we may keep the side
effect. Otherwise replace it by new pseudo. */
*************** hoist_insn_after (rtx insn, rtx after, r
*** 3623,3628 ****
--- 3603,3609 ----
rtx pat;
int i;
rtx note;
+ int applied;
insn = emit_copy_of_insn_after (insn, after);
pat = PATTERN (insn);
*************** hoist_insn_after (rtx insn, rtx after, r
*** 3673,3682 ****
}
break;
default:
! abort ();
}
! if (!apply_change_group ())
! abort ();
return insn;
}
--- 3654,3663 ----
}
break;
default:
! gcc_unreachable ();
}
! applied = apply_change_group ();
! gcc_assert (applied);
return insn;
}
*************** hoist_insn_to_edge (rtx insn, edge e, rt
*** 3688,3695 ****
/* We cannot insert instructions on an abnormal critical edge.
It will be easier to find the culprit if we die now. */
! if ((e->flags & EDGE_ABNORMAL) && EDGE_CRITICAL_P (e))
! abort ();
/* Do not use emit_insn_on_edge as we want to preserve notes and similar
stuff. We also emit CALL_INSNS and firends. */
--- 3669,3675 ----
/* We cannot insert instructions on an abnormal critical edge.
It will be easier to find the culprit if we die now. */
! gcc_assert (!(e->flags & EDGE_ABNORMAL) || !EDGE_CRITICAL_P (e));
/* Do not use emit_insn_on_edge as we want to preserve notes and similar
stuff. We also emit CALL_INSNS and firends. */
*************** nonzero_bits1 (rtx x, enum machine_mode
*** 4178,4184 ****
result_low = MIN (low0, low1);
break;
default:
! abort ();
}
if (result_width < mode_width)
--- 4158,4164 ----
result_low = MIN (low0, low1);
break;
default:
! gcc_unreachable ();
}
if (result_width < mode_width)
Index: rtl.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/rtl.c,v
retrieving revision 1.147
diff -c -3 -p -r1.147 rtl.c
*** rtl.c 18 Aug 2004 22:31:01 -0000 1.147
--- rtl.c 9 Sep 2004 14:26:57 -0000
*************** copy_rtx (rtx orig)
*** 296,302 ****
break;
default:
! abort ();
}
}
return copy;
--- 296,302 ----
break;
default:
! gcc_unreachable ();
}
}
return copy;
*************** rtx_equal_p (rtx x, rtx y)
*** 427,433 ****
contain anything but integers and other rtx's,
except for within LABEL_REFs and SYMBOL_REFs. */
default:
! abort ();
}
}
return 1;
--- 427,433 ----
contain anything but integers and other rtx's,
except for within LABEL_REFs and SYMBOL_REFs. */
default:
! gcc_unreachable ();
}
}
return 1;
Index: rtlhooks.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/rtlhooks.c,v
retrieving revision 2.4
diff -c -3 -p -r2.4 rtlhooks.c
*** rtlhooks.c 4 Jul 2004 08:06:55 -0000 2.4
--- rtlhooks.c 9 Sep 2004 14:26:57 -0000
*************** gen_lowpart_general (enum machine_mode m
*** 47,61 ****
{
/* Must be a hard reg that's not valid in MODE. */
result = gen_lowpart_common (mode, copy_to_reg (x));
! if (result == 0)
! abort ();
return result;
}
! else if (MEM_P (x))
{
- /* The only additional case we can do is MEM. */
int offset = 0;
/* The following exposes the use of "x" to CSE. */
if (GET_MODE_SIZE (GET_MODE (x)) <= UNITS_PER_WORD
&& SCALAR_INT_MODE_P (GET_MODE (x))
--- 47,62 ----
{
/* Must be a hard reg that's not valid in MODE. */
result = gen_lowpart_common (mode, copy_to_reg (x));
! gcc_assert (result != 0);
return result;
}
! else
{
int offset = 0;
+ /* The only additional case we can do is MEM. */
+ gcc_assert (MEM_P (x));
+
/* The following exposes the use of "x" to CSE. */
if (GET_MODE_SIZE (GET_MODE (x)) <= UNITS_PER_WORD
&& SCALAR_INT_MODE_P (GET_MODE (x))
*************** gen_lowpart_general (enum machine_mode m
*** 76,83 ****
return adjust_address (x, mode, offset);
}
- else
- abort ();
}
rtx
--- 77,82 ----
Index: sbitmap.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/sbitmap.c,v
retrieving revision 1.31
diff -c -3 -p -r1.31 sbitmap.c
*** sbitmap.c 13 May 2004 06:39:45 -0000 1.31
--- sbitmap.c 9 Sep 2004 14:26:58 -0000
*************** sbitmap_difference (sbitmap dst, sbitmap
*** 301,308 ****
sbitmap_ptr bp = b->elms;
/* A should be at least as large as DEST, to have a defined source. */
! if (a->size < dst_size)
! abort ();
/* If minuend is smaller, we simply pretend it to be zero bits, i.e.
only copy the subtrahend into dest. */
if (b->size < min_size)
--- 301,307 ----
sbitmap_ptr bp = b->elms;
/* A should be at least as large as DEST, to have a defined source. */
! gcc_assert (a->size >= dst_size);
/* If minuend is smaller, we simply pretend it to be zero bits, i.e.
only copy the subtrahend into dest. */
if (b->size < min_size)
Index: sched-deps.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/sched-deps.c,v
retrieving revision 1.79
diff -c -3 -p -r1.79 sched-deps.c
*** sched-deps.c 30 Aug 2004 12:43:19 -0000 1.79
--- sched-deps.c 9 Sep 2004 14:27:01 -0000
*************** add_dependence (rtx insn, rtx elem, enum
*** 252,259 ****
{
enum reg_note present_dep_type = 0;
! if (anti_dependency_cache == NULL || output_dependency_cache == NULL)
! abort ();
if (bitmap_bit_p (&true_dependency_cache[INSN_LUID (insn)],
INSN_LUID (elem)))
/* Do nothing (present_set_type is already 0). */
--- 252,259 ----
{
enum reg_note present_dep_type = 0;
! gcc_assert (anti_dependency_cache);
! gcc_assert (output_dependency_cache);
if (bitmap_bit_p (&true_dependency_cache[INSN_LUID (insn)],
INSN_LUID (elem)))
/* Do nothing (present_set_type is already 0). */
*************** add_dependence (rtx insn, rtx elem, enum
*** 281,295 ****
may be changed. */
if (true_dependency_cache != NULL)
{
! if (REG_NOTE_KIND (link) == REG_DEP_ANTI)
! bitmap_clear_bit (&anti_dependency_cache[INSN_LUID (insn)],
! INSN_LUID (elem));
! else if (REG_NOTE_KIND (link) == REG_DEP_OUTPUT
! && output_dependency_cache)
! bitmap_clear_bit (&output_dependency_cache[INSN_LUID (insn)],
! INSN_LUID (elem));
! else
! abort ();
}
#endif
--- 281,301 ----
may be changed. */
if (true_dependency_cache != NULL)
{
! enum reg_note kind = REG_NOTE_KIND (link);
! switch (kind)
! {
! case REG_DEP_ANTI:
! bitmap_clear_bit (&anti_dependency_cache[INSN_LUID (insn)],
! INSN_LUID (elem));
! break;
! case REG_DEP_OUTPUT:
! gcc_assert (output_dependency_cache);
! bitmap_clear_bit (&output_dependency_cache[INSN_LUID (insn)],
! INSN_LUID (elem));
! break;
! default:
! gcc_unreachable ();
! }
}
#endif
*************** sched_analyze_1 (struct deps *deps, rtx
*** 518,526 ****
purpose already. */
else if (regno >= deps->max_reg)
{
! if (GET_CODE (PATTERN (insn)) != USE
! && GET_CODE (PATTERN (insn)) != CLOBBER)
! abort ();
}
else
{
--- 524,531 ----
purpose already. */
else if (regno >= deps->max_reg)
{
! gcc_assert (GET_CODE (PATTERN (insn)) == USE
! || GET_CODE (PATTERN (insn)) == CLOBBER);
}
else
{
*************** sched_analyze_2 (struct deps *deps, rtx
*** 659,667 ****
purpose already. */
else if (regno >= deps->max_reg)
{
! if (GET_CODE (PATTERN (insn)) != USE
! && GET_CODE (PATTERN (insn)) != CLOBBER)
! abort ();
}
else
{
--- 664,671 ----
purpose already. */
else if (regno >= deps->max_reg)
{
! gcc_assert (GET_CODE (PATTERN (insn)) == USE
! || GET_CODE (PATTERN (insn)) == CLOBBER);
}
else
{
*************** sched_analyze (struct deps *deps, rtx he
*** 1363,1369 ****
return;
}
}
! abort ();
}
--- 1367,1373 ----
return;
}
}
! gcc_unreachable ();
}
*************** add_forward_dependence (rtx from, rtx to
*** 1382,1395 ****
However, if we have enabled checking we might as well go
ahead and verify that add_dependence worked properly. */
! if (NOTE_P (from)
! || INSN_DELETED_P (from)
! || (forward_dependency_cache != NULL
! && bitmap_bit_p (&forward_dependency_cache[INSN_LUID (from)],
! INSN_LUID (to)))
! || (forward_dependency_cache == NULL
! && find_insn_list (to, INSN_DEPEND (from))))
! abort ();
if (forward_dependency_cache != NULL)
bitmap_bit_p (&forward_dependency_cache[INSN_LUID (from)],
INSN_LUID (to));
--- 1386,1400 ----
However, if we have enabled checking we might as well go
ahead and verify that add_dependence worked properly. */
! gcc_assert (!NOTE_P (from));
! gcc_assert (!INSN_DELETED_P (from));
! if (forward_dependency_cache)
! gcc_assert (!bitmap_bit_p (&forward_dependency_cache[INSN_LUID (from)],
! INSN_LUID (to)));
! else
! gcc_assert (!find_insn_list (to, INSN_DEPEND (from)));
!
! /* ??? If bitmap_bit_p is a predicate, what is this supposed to do? */
if (forward_dependency_cache != NULL)
bitmap_bit_p (&forward_dependency_cache[INSN_LUID (from)],
INSN_LUID (to));
Index: sched-ebb.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/sched-ebb.c,v
retrieving revision 1.37
diff -c -3 -p -r1.37 sched-ebb.c
*** sched-ebb.c 9 Jul 2004 03:29:35 -0000 1.37
--- sched-ebb.c 9 Sep 2004 14:27:03 -0000
*************** fix_basic_block_boundaries (basic_block
*** 240,247 ****
for (; insn != aftertail; insn = NEXT_INSN (insn))
{
! if (LABEL_P (insn))
! abort ();
/* Create new basic blocks just before first insn. */
if (inside_basic_block_p (insn))
{
--- 240,246 ----
for (; insn != aftertail; insn = NEXT_INSN (insn))
{
! gcc_assert (!LABEL_P (insn));
/* Create new basic blocks just before first insn. */
if (inside_basic_block_p (insn))
{
*************** schedule_ebb (rtx head, rtx tail)
*** 542,549 ****
schedule_block (-1, n_insns);
/* Sanity check: verify that all region insns were scheduled. */
! if (sched_n_insns != n_insns)
! abort ();
head = current_sched_info->head;
tail = current_sched_info->tail;
--- 541,547 ----
schedule_block (-1, n_insns);
/* Sanity check: verify that all region insns were scheduled. */
! gcc_assert (sched_n_insns == n_insns);
head = current_sched_info->head;
tail = current_sched_info->tail;
Index: sched-rgn.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/sched-rgn.c,v
retrieving revision 1.80
diff -c -3 -p -r1.80 sched-rgn.c
*** sched-rgn.c 24 Aug 2004 16:46:32 -0000 1.80
--- sched-rgn.c 9 Sep 2004 14:27:07 -0000
*************** debug_regions (void)
*** 517,525 ****
{
current_blocks = RGN_BLOCKS (rgn);
! if (bb != BLOCK_TO_BB (BB_TO_BLOCK (bb)))
! abort ();
!
fprintf (sched_dump, " %d/%d ", bb, BB_TO_BLOCK (bb));
}
--- 517,523 ----
{
current_blocks = RGN_BLOCKS (rgn);
! gcc_assert (bb == BLOCK_TO_BB (BB_TO_BLOCK (bb)));
fprintf (sched_dump, " %d/%d ", bb, BB_TO_BLOCK (bb));
}
*************** compute_trg_info (int trg)
*** 1211,1218 ****
sp->update_bbs.nr_members = update_idx;
/* Make sure we didn't overrun the end of bblst_table. */
! if (bblst_last > bblst_size)
! abort ();
}
else
{
--- 1209,1215 ----
sp->update_bbs.nr_members = update_idx;
/* Make sure we didn't overrun the end of bblst_table. */
! gcc_assert (bblst_last <= bblst_size);
}
else
{
*************** schedule_region (int rgn)
*** 2501,2508 ****
}
/* Sanity check: verify that all region insns were scheduled. */
! if (sched_rgn_n_insns != rgn_n_insns)
! abort ();
/* Restore line notes. */
if (write_symbols != NO_DEBUG)
--- 2498,2504 ----
}
/* Sanity check: verify that all region insns were scheduled. */
! gcc_assert (sched_rgn_n_insns == rgn_n_insns);
/* Restore line notes. */
if (write_symbols != NO_DEBUG)
*************** schedule_insns (FILE *dump_file)
*** 2708,2716 ****
sbitmap_zero (blocks);
SET_BIT (blocks, rgn_bb_table[RGN_BLOCKS (rgn)]);
! if (deaths_in_region[rgn]
! != count_or_remove_death_notes (blocks, 0))
! abort ();
}
free (deaths_in_region);
}
--- 2704,2711 ----
sbitmap_zero (blocks);
SET_BIT (blocks, rgn_bb_table[RGN_BLOCKS (rgn)]);
! gcc_assert (deaths_in_region[rgn]
! == count_or_remove_death_notes (blocks, 0));
}
free (deaths_in_region);
}
*************** schedule_insns (FILE *dump_file)
*** 2733,2742 ****
nr_inter, nr_spec);
}
else
! {
! if (nr_inter > 0)
! abort ();
! }
fprintf (sched_dump, "\n\n");
}
--- 2728,2734 ----
nr_inter, nr_spec);
}
else
! gcc_assert (nr_inter <= 0);
fprintf (sched_dump, "\n\n");
}
Index: sched-vis.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/sched-vis.c,v
retrieving revision 1.32
diff -c -3 -p -r1.32 sched-vis.c
*** sched-vis.c 20 Jul 2004 07:26:53 -0000 1.32
--- sched-vis.c 9 Sep 2004 14:27:09 -0000
*************** print_pattern (char *buf, rtx x, int ver
*** 566,573 ****
break;
case SEQUENCE:
/* Should never see SEQUENCE codes until after reorg. */
! abort ();
! break;
case ASM_INPUT:
sprintf (buf, "asm {%s}", XSTR (x, 0));
break;
--- 566,572 ----
break;
case SEQUENCE:
/* Should never see SEQUENCE codes until after reorg. */
! gcc_unreachable ();
case ASM_INPUT:
sprintf (buf, "asm {%s}", XSTR (x, 0));
break;
Index: sdbout.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/sdbout.c,v
retrieving revision 1.94
diff -c -3 -p -r1.94 sdbout.c
*** sdbout.c 20 Jul 2004 12:24:57 -0000 1.94
--- sdbout.c 9 Sep 2004 14:27:12 -0000
*************** sdbout_symbol (tree decl, int local)
*** 758,764 ****
case PARM_DECL:
/* Parm decls go in their own separate chains
and are output by sdbout_reg_parms and sdbout_parms. */
! abort ();
case VAR_DECL:
/* Don't mention a variable that is external.
--- 758,764 ----
case PARM_DECL:
/* Parm decls go in their own separate chains
and are output by sdbout_reg_parms and sdbout_parms. */
! gcc_unreachable ();
case VAR_DECL:
/* Don't mention a variable that is external.
*************** sdbout_toplevel_data (tree decl)
*** 942,951 ****
if (DECL_IGNORED_P (decl))
return;
! if (! (TREE_CODE (decl) == VAR_DECL
! && MEM_P (DECL_RTL (decl))
! && DECL_INITIAL (decl)))
! abort ();
PUT_SDB_DEF (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)));
PUT_SDB_VAL (XEXP (DECL_RTL (decl), 0));
--- 942,950 ----
if (DECL_IGNORED_P (decl))
return;
! gcc_assert (TREE_CODE (decl) == VAR_DECL);
! gcc_assert (MEM_P (DECL_RTL (decl)));
! gcc_assert (DECL_INITIAL (decl));
PUT_SDB_DEF (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)));
PUT_SDB_VAL (XEXP (DECL_RTL (decl), 0));
Index: simplify-rtx.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/simplify-rtx.c,v
retrieving revision 1.203
diff -c -3 -p -r1.203 simplify-rtx.c
*** simplify-rtx.c 4 Sep 2004 08:50:35 -0000 1.203
--- simplify-rtx.c 9 Sep 2004 14:27:20 -0000
*************** simplify_unary_operation (enum rtx_code
*** 360,375 ****
if (code == VEC_DUPLICATE)
{
! if (!VECTOR_MODE_P (mode))
! abort ();
! if (GET_MODE (trueop) != VOIDmode
! && !VECTOR_MODE_P (GET_MODE (trueop))
! && GET_MODE_INNER (mode) != GET_MODE (trueop))
! abort ();
! if (GET_MODE (trueop) != VOIDmode
! && VECTOR_MODE_P (GET_MODE (trueop))
! && GET_MODE_INNER (mode) != GET_MODE_INNER (GET_MODE (trueop)))
! abort ();
if (GET_CODE (trueop) == CONST_INT || GET_CODE (trueop) == CONST_DOUBLE
|| GET_CODE (trueop) == CONST_VECTOR)
{
--- 360,374 ----
if (code == VEC_DUPLICATE)
{
! gcc_assert (VECTOR_MODE_P (mode));
! if (GET_MODE (trueop) != VOIDmode)
! {
! if (!VECTOR_MODE_P (GET_MODE (trueop)))
! gcc_assert (GET_MODE_INNER (mode) == GET_MODE (trueop));
! else
! gcc_assert (GET_MODE_INNER (mode) == GET_MODE_INNER
! (GET_MODE (trueop)));
! }
if (GET_CODE (trueop) == CONST_INT || GET_CODE (trueop) == CONST_DOUBLE
|| GET_CODE (trueop) == CONST_VECTOR)
{
*************** simplify_unary_operation (enum rtx_code
*** 387,394 ****
int in_elt_size = GET_MODE_SIZE (GET_MODE_INNER (inmode));
unsigned in_n_elts = (GET_MODE_SIZE (inmode) / in_elt_size);
! if (in_n_elts >= n_elts || n_elts % in_n_elts)
! abort ();
for (i = 0; i < n_elts; i++)
RTVEC_ELT (v, i) = CONST_VECTOR_ELT (trueop, i % in_n_elts);
}
--- 386,393 ----
int in_elt_size = GET_MODE_SIZE (GET_MODE_INNER (inmode));
unsigned in_n_elts = (GET_MODE_SIZE (inmode) / in_elt_size);
! gcc_assert (in_n_elts < n_elts);
! gcc_assert ((n_elts % in_n_elts) == 0);
for (i = 0; i < n_elts; i++)
RTVEC_ELT (v, i) = CONST_VECTOR_ELT (trueop, i % in_n_elts);
}
*************** simplify_unary_operation (enum rtx_code
*** 408,416 ****
rtvec v = rtvec_alloc (n_elts);
unsigned int i;
! if (op_n_elts != n_elts)
! abort ();
!
for (i = 0; i < n_elts; i++)
{
rtx x = simplify_unary_operation (code, GET_MODE_INNER (mode),
--- 407,413 ----
rtvec v = rtvec_alloc (n_elts);
unsigned int i;
! gcc_assert (op_n_elts == n_elts);
for (i = 0; i < n_elts; i++)
{
rtx x = simplify_unary_operation (code, GET_MODE_INNER (mode),
*************** simplify_unary_operation (enum rtx_code
*** 541,555 ****
case ZERO_EXTEND:
/* When zero-extending a CONST_INT, we need to know its
original mode. */
! if (op_mode == VOIDmode)
! abort ();
if (GET_MODE_BITSIZE (op_mode) == HOST_BITS_PER_WIDE_INT)
{
/* If we were really extending the mode,
we would have to distinguish between zero-extension
and sign-extension. */
! if (width != GET_MODE_BITSIZE (op_mode))
! abort ();
val = arg0;
}
else if (GET_MODE_BITSIZE (op_mode) < HOST_BITS_PER_WIDE_INT)
--- 538,550 ----
case ZERO_EXTEND:
/* When zero-extending a CONST_INT, we need to know its
original mode. */
! gcc_assert (op_mode != VOIDmode);
if (GET_MODE_BITSIZE (op_mode) == HOST_BITS_PER_WIDE_INT)
{
/* If we were really extending the mode,
we would have to distinguish between zero-extension
and sign-extension. */
! gcc_assert (width == GET_MODE_BITSIZE (op_mode));
val = arg0;
}
else if (GET_MODE_BITSIZE (op_mode) < HOST_BITS_PER_WIDE_INT)
*************** simplify_unary_operation (enum rtx_code
*** 566,573 ****
/* If we were really extending the mode,
we would have to distinguish between zero-extension
and sign-extension. */
! if (width != GET_MODE_BITSIZE (op_mode))
! abort ();
val = arg0;
}
else if (GET_MODE_BITSIZE (op_mode) < HOST_BITS_PER_WIDE_INT)
--- 561,567 ----
/* If we were really extending the mode,
we would have to distinguish between zero-extension
and sign-extension. */
! gcc_assert (width == GET_MODE_BITSIZE (op_mode));
val = arg0;
}
else if (GET_MODE_BITSIZE (op_mode) < HOST_BITS_PER_WIDE_INT)
*************** simplify_unary_operation (enum rtx_code
*** 590,596 ****
return 0;
default:
! abort ();
}
val = trunc_int_for_mode (val, mode);
--- 584,590 ----
return 0;
default:
! gcc_unreachable ();
}
val = trunc_int_for_mode (val, mode);
*************** simplify_unary_operation (enum rtx_code
*** 690,697 ****
break;
case ZERO_EXTEND:
! if (op_mode == VOIDmode)
! abort ();
if (GET_MODE_BITSIZE (op_mode) > HOST_BITS_PER_WIDE_INT)
return 0;
--- 684,690 ----
break;
case ZERO_EXTEND:
! gcc_assert (op_mode != VOIDmode);
if (GET_MODE_BITSIZE (op_mode) > HOST_BITS_PER_WIDE_INT)
return 0;
*************** simplify_unary_operation (enum rtx_code
*** 766,772 ****
real_from_target (&d, tmp, mode);
}
default:
! abort ();
}
return CONST_DOUBLE_FROM_REAL_VALUE (d, mode);
}
--- 759,765 ----
real_from_target (&d, tmp, mode);
}
default:
! gcc_unreachable ();
}
return CONST_DOUBLE_FROM_REAL_VALUE (d, mode);
}
*************** simplify_unary_operation (enum rtx_code
*** 864,870 ****
break;
default:
! abort ();
}
return immed_double_const (xl, xh, mode);
}
--- 857,863 ----
break;
default:
! gcc_unreachable ();
}
return immed_double_const (xl, xh, mode);
}
*************** simplify_binary_operation (enum rtx_code
*** 1175,1190 ****
rtx trueop0, trueop1;
rtx tem;
- #ifdef ENABLE_CHECKING
/* Relational operations don't work here. We must know the mode
of the operands in order to do the comparison correctly.
Assuming a full word can give incorrect results.
Consider comparing 128 with -128 in QImode. */
!
! if (GET_RTX_CLASS (code) == RTX_COMPARE
! || GET_RTX_CLASS (code) == RTX_COMM_COMPARE)
! abort ();
! #endif
/* Make sure the constant is second. */
if (GET_RTX_CLASS (code) == RTX_COMM_ARITH
--- 1168,1179 ----
rtx trueop0, trueop1;
rtx tem;
/* Relational operations don't work here. We must know the mode
of the operands in order to do the comparison correctly.
Assuming a full word can give incorrect results.
Consider comparing 128 with -128 in QImode. */
! gcc_assert (GET_RTX_CLASS (code) != RTX_COMPARE);
! gcc_assert (GET_RTX_CLASS (code) != RTX_COMM_COMPARE);
/* Make sure the constant is second. */
if (GET_RTX_CLASS (code) == RTX_COMM_ARITH
*************** simplify_binary_operation (enum rtx_code
*** 1211,1219 ****
rtvec v = rtvec_alloc (n_elts);
unsigned int i;
! if (op0_n_elts != n_elts || op1_n_elts != n_elts)
! abort ();
!
for (i = 0; i < n_elts; i++)
{
rtx x = simplify_binary_operation (code, GET_MODE_INNER (mode),
--- 1200,1207 ----
rtvec v = rtvec_alloc (n_elts);
unsigned int i;
! gcc_assert (op0_n_elts == n_elts);
! gcc_assert (op1_n_elts == n_elts);
for (i = 0; i < n_elts; i++)
{
rtx x = simplify_binary_operation (code, GET_MODE_INNER (mode),
*************** simplify_binary_operation (enum rtx_code
*** 1247,1260 ****
GET_MODE (op1));
for (i = 0; i < 4; i++)
{
! if (code == AND)
tmp0[i] &= tmp1[i];
! else if (code == IOR)
tmp0[i] |= tmp1[i];
! else if (code == XOR)
tmp0[i] ^= tmp1[i];
! else
! abort ();
}
real_from_target (&r, tmp0, mode);
return CONST_DOUBLE_FROM_REAL_VALUE (r, mode);
--- 1235,1254 ----
GET_MODE (op1));
for (i = 0; i < 4; i++)
{
! switch (code)
! {
! case AND:
tmp0[i] &= tmp1[i];
! break;
! case IOR:
tmp0[i] |= tmp1[i];
! break;
! case XOR:
tmp0[i] ^= tmp1[i];
! break;
! default:
! gcc_unreachable ();
! }
}
real_from_target (&r, tmp0, mode);
return CONST_DOUBLE_FROM_REAL_VALUE (r, mode);
*************** simplify_binary_operation (enum rtx_code
*** 2142,2165 ****
case VEC_SELECT:
if (!VECTOR_MODE_P (mode))
{
! if (!VECTOR_MODE_P (GET_MODE (trueop0))
! || (mode
! != GET_MODE_INNER (GET_MODE (trueop0)))
! || GET_CODE (trueop1) != PARALLEL
! || XVECLEN (trueop1, 0) != 1
! || GET_CODE (XVECEXP (trueop1, 0, 0)) != CONST_INT)
! abort ();
if (GET_CODE (trueop0) == CONST_VECTOR)
! return CONST_VECTOR_ELT (trueop0, INTVAL (XVECEXP (trueop1, 0, 0)));
}
else
{
! if (!VECTOR_MODE_P (GET_MODE (trueop0))
! || (GET_MODE_INNER (mode)
! != GET_MODE_INNER (GET_MODE (trueop0)))
! || GET_CODE (trueop1) != PARALLEL)
! abort ();
if (GET_CODE (trueop0) == CONST_VECTOR)
{
--- 2136,2157 ----
case VEC_SELECT:
if (!VECTOR_MODE_P (mode))
{
! gcc_assert (VECTOR_MODE_P (GET_MODE (trueop0)));
! gcc_assert (mode == GET_MODE_INNER (GET_MODE (trueop0)));
! gcc_assert (GET_CODE (trueop1) == PARALLEL);
! gcc_assert (XVECLEN (trueop1, 0) == 1);
! gcc_assert (GET_CODE (XVECEXP (trueop1, 0, 0)) == CONST_INT);
if (GET_CODE (trueop0) == CONST_VECTOR)
! return CONST_VECTOR_ELT (trueop0, INTVAL (XVECEXP
! (trueop1, 0, 0)));
}
else
{
! gcc_assert (VECTOR_MODE_P (GET_MODE (trueop0)));
! gcc_assert (GET_MODE_INNER (mode)
! == GET_MODE_INNER (GET_MODE (trueop0)));
! gcc_assert (GET_CODE (trueop1) == PARALLEL);
if (GET_CODE (trueop0) == CONST_VECTOR)
{
*************** simplify_binary_operation (enum rtx_code
*** 2168,2182 ****
rtvec v = rtvec_alloc (n_elts);
unsigned int i;
! if (XVECLEN (trueop1, 0) != (int) n_elts)
! abort ();
for (i = 0; i < n_elts; i++)
{
rtx x = XVECEXP (trueop1, 0, i);
! if (GET_CODE (x) != CONST_INT)
! abort ();
! RTVEC_ELT (v, i) = CONST_VECTOR_ELT (trueop0, INTVAL (x));
}
return gen_rtx_CONST_VECTOR (mode, v);
--- 2160,2173 ----
rtvec v = rtvec_alloc (n_elts);
unsigned int i;
! gcc_assert (XVECLEN (trueop1, 0) == (int) n_elts);
for (i = 0; i < n_elts; i++)
{
rtx x = XVECEXP (trueop1, 0, i);
! gcc_assert (GET_CODE (x) == CONST_INT);
! RTVEC_ELT (v, i) = CONST_VECTOR_ELT (trueop0,
! INTVAL (x));
}
return gen_rtx_CONST_VECTOR (mode, v);
*************** simplify_binary_operation (enum rtx_code
*** 2192,2215 ****
? GET_MODE (trueop1)
: GET_MODE_INNER (mode));
! if (!VECTOR_MODE_P (mode)
! || (GET_MODE_SIZE (op0_mode) + GET_MODE_SIZE (op1_mode)
! != GET_MODE_SIZE (mode)))
! abort ();
!
! if ((VECTOR_MODE_P (op0_mode)
! && (GET_MODE_INNER (mode)
! != GET_MODE_INNER (op0_mode)))
! || (!VECTOR_MODE_P (op0_mode)
! && GET_MODE_INNER (mode) != op0_mode))
! abort ();
!
! if ((VECTOR_MODE_P (op1_mode)
! && (GET_MODE_INNER (mode)
! != GET_MODE_INNER (op1_mode)))
! || (!VECTOR_MODE_P (op1_mode)
! && GET_MODE_INNER (mode) != op1_mode))
! abort ();
if ((GET_CODE (trueop0) == CONST_VECTOR
|| GET_CODE (trueop0) == CONST_INT
--- 2183,2203 ----
? GET_MODE (trueop1)
: GET_MODE_INNER (mode));
! gcc_assert (VECTOR_MODE_P (mode));
! gcc_assert (GET_MODE_SIZE (op0_mode) + GET_MODE_SIZE (op1_mode)
! == GET_MODE_SIZE (mode));
!
! if (VECTOR_MODE_P (op0_mode))
! gcc_assert (GET_MODE_INNER (mode)
! == GET_MODE_INNER (op0_mode));
! else
! gcc_assert (GET_MODE_INNER (mode) == op0_mode);
!
! if (VECTOR_MODE_P (op1_mode))
! gcc_assert (GET_MODE_INNER (mode)
! == GET_MODE_INNER (op1_mode));
! else
! gcc_assert (GET_MODE_INNER (mode) == op1_mode);
if ((GET_CODE (trueop0) == CONST_VECTOR
|| GET_CODE (trueop0) == CONST_INT
*************** simplify_binary_operation (enum rtx_code
*** 2251,2257 ****
return 0;
default:
! abort ();
}
return 0;
--- 2239,2245 ----
return 0;
default:
! gcc_unreachable ();
}
return 0;
*************** simplify_binary_operation (enum rtx_code
*** 2413,2419 ****
return 0;
default:
! abort ();
}
val = trunc_int_for_mode (val, mode);
--- 2401,2407 ----
return 0;
default:
! gcc_unreachable ();
}
val = trunc_int_for_mode (val, mode);
*************** simplify_const_relational_operation (enu
*** 2799,2808 ****
rtx trueop0;
rtx trueop1;
! if (mode == VOIDmode
! && (GET_MODE (op0) != VOIDmode
! || GET_MODE (op1) != VOIDmode))
! abort ();
/* If op0 is a compare, extract the comparison arguments from it. */
if (GET_CODE (op0) == COMPARE && op1 == const0_rtx)
--- 2787,2795 ----
rtx trueop0;
rtx trueop1;
! gcc_assert (mode != VOIDmode
! || (GET_MODE (op0) == VOIDmode
! && GET_MODE (op1) == VOIDmode));
/* If op0 is a compare, extract the comparison arguments from it. */
if (GET_CODE (op0) == COMPARE && op1 == const0_rtx)
*************** simplify_const_relational_operation (enu
*** 3101,3107 ****
case UNORDERED:
return const0_rtx;
default:
! abort ();
}
}
--- 3088,3094 ----
case UNORDERED:
return const0_rtx;
default:
! gcc_unreachable ();
}
}
*************** simplify_ternary_operation (enum rtx_cod
*** 3240,3249 ****
break;
case VEC_MERGE:
! if (GET_MODE (op0) != mode
! || GET_MODE (op1) != mode
! || !VECTOR_MODE_P (mode))
! abort ();
op2 = avoid_constant_pool_reference (op2);
if (GET_CODE (op2) == CONST_INT)
{
--- 3227,3235 ----
break;
case VEC_MERGE:
! gcc_assert (GET_MODE (op0) == mode);
! gcc_assert (GET_MODE (op1) == mode);
! gcc_assert (VECTOR_MODE_P (mode));
op2 = avoid_constant_pool_reference (op2);
if (GET_CODE (op2) == CONST_INT)
{
*************** simplify_ternary_operation (enum rtx_cod
*** 3274,3280 ****
break;
default:
! abort ();
}
return 0;
--- 3260,3266 ----
break;
default:
! gcc_unreachable ();
}
return 0;
*************** simplify_immed_subreg (enum machine_mode
*** 3328,3338 ****
elems = &op;
elem_bitsize = max_bitsize;
}
!
! if (BITS_PER_UNIT % value_bit != 0)
! abort (); /* Too complicated; reducing value_bit may help. */
! if (elem_bitsize % BITS_PER_UNIT != 0)
! abort (); /* I don't know how to handle endianness of sub-units. */
for (elem = 0; elem < num_elem; elem++)
{
--- 3314,3323 ----
elems = &op;
elem_bitsize = max_bitsize;
}
! /* If this asserts, it is too complicated; reducing value_bit may help. */
! gcc_assert (BITS_PER_UNIT % value_bit == 0);
! /* I don't know how to handle endianness of sub-units. */
! gcc_assert (elem_bitsize % BITS_PER_UNIT == 0);
for (elem = 0; elem < num_elem; elem++)
{
*************** simplify_immed_subreg (enum machine_mode
*** 3369,3376 ****
{
/* If this triggers, someone should have generated a
CONST_INT instead. */
! if (elem_bitsize <= HOST_BITS_PER_WIDE_INT)
! abort ();
for (i = 0; i < HOST_BITS_PER_WIDE_INT; i += value_bit)
*vp++ = CONST_DOUBLE_LOW (el) >> i;
--- 3354,3360 ----
{
/* If this triggers, someone should have generated a
CONST_INT instead. */
! gcc_assert (elem_bitsize > HOST_BITS_PER_WIDE_INT);
for (i = 0; i < HOST_BITS_PER_WIDE_INT; i += value_bit)
*vp++ = CONST_DOUBLE_LOW (el) >> i;
*************** simplify_immed_subreg (enum machine_mode
*** 3385,3399 ****
for (; i < max_bitsize; i += value_bit)
*vp++ = 0;
}
! else if (GET_MODE_CLASS (GET_MODE (el)) == MODE_FLOAT)
{
long tmp[max_bitsize / 32];
int bitsize = GET_MODE_BITSIZE (GET_MODE (el));
!
! if (bitsize > elem_bitsize)
! abort ();
! if (bitsize % value_bit != 0)
! abort ();
real_to_target (tmp, CONST_DOUBLE_REAL_VALUE (el),
GET_MODE (el));
--- 3369,3382 ----
for (; i < max_bitsize; i += value_bit)
*vp++ = 0;
}
! else
{
long tmp[max_bitsize / 32];
int bitsize = GET_MODE_BITSIZE (GET_MODE (el));
!
! gcc_assert (GET_MODE_CLASS (GET_MODE (el)) == MODE_FLOAT);
! gcc_assert (bitsize <= elem_bitsize);
! gcc_assert (bitsize % value_bit == 0);
real_to_target (tmp, CONST_DOUBLE_REAL_VALUE (el),
GET_MODE (el));
*************** simplify_immed_subreg (enum machine_mode
*** 3417,3428 ****
for (; i < elem_bitsize; i += value_bit)
*vp++ = 0;
}
- else
- abort ();
break;
default:
! abort ();
}
}
--- 3400,3409 ----
for (; i < elem_bitsize; i += value_bit)
*vp++ = 0;
}
break;
default:
! gcc_unreachable ();
}
}
*************** simplify_immed_subreg (enum machine_mode
*** 3442,3449 ****
/* BYTE should still be inside OP. (Note that BYTE is unsigned,
so if it's become negative it will instead be very large.) */
! if (byte >= GET_MODE_SIZE (innermode))
! abort ();
/* Convert from bytes to chunks of size value_bit. */
value_start = byte * (BITS_PER_UNIT / value_bit);
--- 3423,3429 ----
/* BYTE should still be inside OP. (Note that BYTE is unsigned,
so if it's become negative it will instead be very large.) */
! gcc_assert (byte < GET_MODE_SIZE (innermode));
/* Convert from bytes to chunks of size value_bit. */
value_start = byte * (BITS_PER_UNIT / value_bit);
*************** simplify_immed_subreg (enum machine_mode
*** 3467,3476 ****
outer_class = GET_MODE_CLASS (outer_submode);
elem_bitsize = GET_MODE_BITSIZE (outer_submode);
! if (elem_bitsize % value_bit != 0)
! abort ();
! if (elem_bitsize + value_start * value_bit > max_bitsize)
! abort ();
for (elem = 0; elem < num_elem; elem++)
{
--- 3447,3454 ----
outer_class = GET_MODE_CLASS (outer_submode);
elem_bitsize = GET_MODE_BITSIZE (outer_submode);
! gcc_assert (elem_bitsize % value_bit == 0);
! gcc_assert (elem_bitsize + value_start * value_bit <= max_bitsize);
for (elem = 0; elem < num_elem; elem++)
{
*************** simplify_immed_subreg (enum machine_mode
*** 3540,3546 ****
break;
default:
! abort ();
}
}
if (VECTOR_MODE_P (outermode))
--- 3518,3524 ----
break;
default:
! gcc_unreachable ();
}
}
if (VECTOR_MODE_P (outermode))
*************** simplify_subreg (enum machine_mode outer
*** 3556,3572 ****
enum machine_mode innermode, unsigned int byte)
{
/* Little bit of sanity checking. */
! if (innermode == VOIDmode || outermode == VOIDmode
! || innermode == BLKmode || outermode == BLKmode)
! abort ();
!
! if (GET_MODE (op) != innermode
! && GET_MODE (op) != VOIDmode)
! abort ();
!
! if (byte % GET_MODE_SIZE (outermode)
! || byte >= GET_MODE_SIZE (innermode))
! abort ();
if (outermode == innermode && !byte)
return op;
--- 3534,3549 ----
enum machine_mode innermode, unsigned int byte)
{
/* Little bit of sanity checking. */
! gcc_assert (innermode != VOIDmode);
! gcc_assert (outermode != VOIDmode);
! gcc_assert (innermode != BLKmode);
! gcc_assert (outermode != BLKmode);
!
! gcc_assert (GET_MODE (op) == innermode
! || GET_MODE (op) == VOIDmode);
!
! gcc_assert ((byte % GET_MODE_SIZE (outermode)) == 0);
! gcc_assert (byte < GET_MODE_SIZE (innermode));
if (outermode == innermode && !byte)
return op;
*************** simplify_gen_subreg (enum machine_mode o
*** 3772,3788 ****
{
rtx newx;
/* Little bit of sanity checking. */
! if (innermode == VOIDmode || outermode == VOIDmode
! || innermode == BLKmode || outermode == BLKmode)
! abort ();
!
! if (GET_MODE (op) != innermode
! && GET_MODE (op) != VOIDmode)
! abort ();
!
! if (byte % GET_MODE_SIZE (outermode)
! || byte >= GET_MODE_SIZE (innermode))
! abort ();
newx = simplify_subreg (outermode, op, innermode, byte);
if (newx)
--- 3749,3764 ----
{
rtx newx;
/* Little bit of sanity checking. */
! gcc_assert (innermode != VOIDmode);
! gcc_assert (outermode != VOIDmode);
! gcc_assert (innermode != BLKmode);
! gcc_assert (outermode != BLKmode);
!
! gcc_assert (GET_MODE (op) == innermode
! || GET_MODE (op) == VOIDmode);
!
! gcc_assert ((byte % GET_MODE_SIZE (outermode)) == 0);
! gcc_assert (byte < GET_MODE_SIZE (innermode));
newx = simplify_subreg (outermode, op, innermode, byte);
if (newx)
Index: sreal.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/sreal.c,v
retrieving revision 1.6
diff -c -3 -p -r1.6 sreal.c
*** sreal.c 6 Jul 2003 12:35:55 -0000 1.6
--- sreal.c 9 Sep 2004 14:27:21 -0000
*************** copy (sreal *r, sreal *a)
*** 94,110 ****
static inline void
shift_right (sreal *x, int s)
{
! #ifdef ENABLE_CHECKING
! if (s <= 0 || s > SREAL_BITS)
! abort ();
! if (x->exp + s > SREAL_MAX_EXP)
! {
! /* Exponent should never be so large because shift_right is used only by
! sreal_add and sreal_sub ant thus the number cannot be shifted out from
! exponent range. */
! abort ();
! }
! #endif
x->exp += s;
--- 94,105 ----
static inline void
shift_right (sreal *x, int s)
{
! gcc_assert (s > 0);
! gcc_assert (s <= SREAL_BITS);
! /* Exponent should never be so large because shift_right is used only by
! sreal_add and sreal_sub ant thus the number cannot be shifted out from
! exponent range. */
! gcc_assert (x->exp + s <= SREAL_MAX_EXP);
x->exp += s;
*************** sreal_sub (sreal *r, sreal *a, sreal *b)
*** 401,410 ****
sreal tmp;
sreal *bb;
! if (sreal_compare (a, b) < 0)
! {
! abort ();
! }
dexp = a->exp - b->exp;
r->exp = a->exp;
--- 396,402 ----
sreal tmp;
sreal *bb;
! gcc_assert (sreal_compare (a, b) >= 0);
dexp = a->exp - b->exp;
r->exp = a->exp;
*************** sreal_div (sreal *r, sreal *a, sreal *b)
*** 509,519 ****
#if SREAL_PART_BITS < 32
unsigned HOST_WIDE_INT tmp, tmp1, tmp2;
! if (b->sig_hi < SREAL_MIN_SIG)
! {
! abort ();
! }
! else if (a->sig_hi < SREAL_MIN_SIG)
{
r->sig_hi = 0;
r->sig_lo = 0;
--- 501,508 ----
#if SREAL_PART_BITS < 32
unsigned HOST_WIDE_INT tmp, tmp1, tmp2;
! gcc_assert (b->sig_hi >= SREAL_MIN_SIG);
! if (a->sig_hi < SREAL_MIN_SIG)
{
r->sig_hi = 0;
r->sig_lo = 0;
*************** sreal_div (sreal *r, sreal *a, sreal *b)
*** 546,561 ****
normalize (r);
}
#else
! if (b->sig == 0)
! {
! abort ();
! }
! else
! {
! r->sig = (a->sig << SREAL_PART_BITS) / b->sig;
! r->exp = a->exp - b->exp - SREAL_PART_BITS;
! normalize (r);
! }
#endif
return r;
}
--- 535,544 ----
normalize (r);
}
#else
! gcc_assert (b->sig != 0);
! r->sig = (a->sig << SREAL_PART_BITS) / b->sig;
! r->exp = a->exp - b->exp - SREAL_PART_BITS;
! normalize (r);
#endif
return r;
}
Index: stmt.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/stmt.c,v
retrieving revision 1.390
diff -c -3 -p -r1.390 stmt.c
*** stmt.c 25 Aug 2004 09:51:27 -0000 1.390
--- stmt.c 9 Sep 2004 14:27:27 -0000
*************** static struct case_node *add_case_node (
*** 132,139 ****
rtx
label_rtx (tree label)
{
! if (TREE_CODE (label) != LABEL_DECL)
! abort ();
if (!DECL_RTL_SET_P (label))
{
--- 132,138 ----
rtx
label_rtx (tree label)
{
! gcc_assert (TREE_CODE (label) == LABEL_DECL);
if (!DECL_RTL_SET_P (label))
{
*************** force_label_rtx (tree label)
*** 155,162 ****
tree function = decl_function_context (label);
struct function *p;
! if (!function)
! abort ();
if (function != current_function_decl)
p = find_function_data (function);
--- 154,160 ----
tree function = decl_function_context (label);
struct function *p;
! gcc_assert (function);
if (function != current_function_decl)
p = find_function_data (function);
*************** expand_goto (tree label)
*** 241,248 ****
/* Check for a nonlocal goto to a containing function. Should have
gotten translated to __builtin_nonlocal_goto. */
tree context = decl_function_context (label);
! if (context != 0 && context != current_function_decl)
! abort ();
#endif
emit_jump (label_rtx (label));
--- 239,245 ----
/* Check for a nonlocal goto to a containing function. Should have
gotten translated to __builtin_nonlocal_goto. */
tree context = decl_function_context (label);
! gcc_assert (!context || context == current_function_decl);
#endif
emit_jump (label_rtx (label));
*************** expand_asm_operands (tree string, tree o
*** 785,795 ****
bool allows_reg;
bool allows_mem;
rtx op;
! if (!parse_output_constraint (&constraints[i], i, ninputs,
noutputs, &allows_mem, &allows_reg,
! &is_inout))
! abort ();
/* If an output operand is not a decl or indirect ref and our constraint
allows a register, make a temporary to act as an intermediate.
--- 782,793 ----
bool allows_reg;
bool allows_mem;
rtx op;
+ bool ok;
! ok = parse_output_constraint (&constraints[i], i, ninputs,
noutputs, &allows_mem, &allows_reg,
! &is_inout);
! gcc_assert (ok);
/* If an output operand is not a decl or indirect ref and our constraint
allows a register, make a temporary to act as an intermediate.
*************** expand_asm_operands (tree string, tree o
*** 866,876 ****
const char *constraint;
tree val, type;
rtx op;
constraint = constraints[i + noutputs];
! if (! parse_input_constraint (&constraint, i, ninputs, noutputs, ninout,
! constraints, &allows_mem, &allows_reg))
! abort ();
generating_concat_p = 0;
--- 864,875 ----
const char *constraint;
tree val, type;
rtx op;
+ bool ok;
constraint = constraints[i + noutputs];
! ok = parse_input_constraint (&constraint, i, ninputs, noutputs, ninout,
! constraints, &allows_mem, &allows_reg);
! gcc_assert (ok);
generating_concat_p = 0;
*************** resolve_operand_name_1 (char *p, tree ou
*** 1330,1337 ****
p = strchr (p, '\0');
/* Verify the no extra buffer space assumption. */
! if (p > q)
! abort ();
/* Shift the rest of the buffer down to fill the gap. */
memmove (p, q + 1, strlen (q + 1) + 1);
--- 1329,1335 ----
p = strchr (p, '\0');
/* Verify the no extra buffer space assumption. */
! gcc_assert (p <= q);
/* Shift the rest of the buffer down to fill the gap. */
memmove (p, q + 1, strlen (q + 1) + 1);
*************** expand_return (tree retval)
*** 1733,1741 ****
if (GET_MODE_SIZE (tmpmode) >= bytes)
break;
! /* No suitable mode found. */
! if (tmpmode == VOIDmode)
! abort ();
PUT_MODE (result_rtl, tmpmode);
}
--- 1731,1738 ----
if (GET_MODE_SIZE (tmpmode) >= bytes)
break;
! /* A suitable mode should have been found. */
! gcc_assert (tmpmode != VOIDmode);
PUT_MODE (result_rtl, tmpmode);
}
*************** expand_decl (tree decl)
*** 1974,1982 ****
to the proper address. */
if (DECL_RTL_SET_P (decl))
{
! if (!MEM_P (DECL_RTL (decl))
! || !REG_P (XEXP (DECL_RTL (decl), 0)))
! abort ();
oldaddr = XEXP (DECL_RTL (decl), 0);
}
--- 1971,1978 ----
to the proper address. */
if (DECL_RTL_SET_P (decl))
{
! gcc_assert (MEM_P (DECL_RTL (decl)));
! gcc_assert (REG_P (XEXP (DECL_RTL (decl), 0)));
oldaddr = XEXP (DECL_RTL (decl), 0);
}
*************** expand_anon_union_decl (tree decl, tree
*** 2122,2127 ****
--- 2118,2124 ----
{
tree decl_elt = TREE_VALUE (t);
enum machine_mode mode = TYPE_MODE (TREE_TYPE (decl_elt));
+ rtx decl_rtl;
/* If any of the elements are addressable, so is the entire
union. */
*************** expand_anon_union_decl (tree decl, tree
*** 2139,2162 ****
DECL_MODE (decl_elt) = mode
= mode_for_size_tree (DECL_SIZE (decl_elt), MODE_INT, 1);
! /* (SUBREG (MEM ...)) at RTL generation time is invalid, so we
! instead create a new MEM rtx with the proper mode. */
! if (MEM_P (x))
{
! if (mode == GET_MODE (x))
! SET_DECL_RTL (decl_elt, x);
! else
! SET_DECL_RTL (decl_elt, adjust_address_nv (x, mode, 0));
}
! else if (REG_P (x))
! {
! if (mode == GET_MODE (x))
! SET_DECL_RTL (decl_elt, x);
! else
! SET_DECL_RTL (decl_elt, gen_lowpart_SUBREG (mode, x));
! }
! else
! abort ();
}
}
--- 2136,2153 ----
DECL_MODE (decl_elt) = mode
= mode_for_size_tree (DECL_SIZE (decl_elt), MODE_INT, 1);
! if (mode == GET_MODE (x))
! decl_rtl = x;
! else if (MEM_P (x))
! /* (SUBREG (MEM ...)) at RTL generation time is invalid, so we
! instead create a new MEM rtx with the proper mode. */
! decl_rtl = adjust_address_nv (x, mode, 0);
! else
{
! gcc_assert (REG_P (x));
! decl_rtl = gen_lowpart_SUBREG (mode, x);
}
! SET_DECL_RTL (decl_elt, decl_rtl);
}
}
*************** emit_case_bit_tests (tree index_type, tr
*** 2280,2289 ****
if (i == count)
{
! if (count >= MAX_CASE_BIT_TESTS)
! abort ();
! test[i].hi = 0;
! test[i].lo = 0;
test[i].label = label;
test[i].bits = 1;
count++;
--- 2271,2279 ----
if (i == count)
{
! gcc_assert (count < MAX_CASE_BIT_TESTS);
! test[i].hi = 0;
! test[i].lo = 0;
test[i].label = label;
test[i].bits = 1;
count++;
*************** expand_case (tree exp)
*** 2378,2385 ****
/* The switch body is lowered in gimplify.c, we should never have
switches with a non-NULL SWITCH_BODY here. */
! if (SWITCH_BODY (exp) || !SWITCH_LABELS (exp))
! abort ();
for (i = TREE_VEC_LENGTH (vec); --i >= 0; )
{
--- 2368,2375 ----
/* The switch body is lowered in gimplify.c, we should never have
switches with a non-NULL SWITCH_BODY here. */
! gcc_assert (!SWITCH_BODY (exp));
! gcc_assert (SWITCH_LABELS (exp));
for (i = TREE_VEC_LENGTH (vec); --i >= 0; )
{
*************** expand_case (tree exp)
*** 2388,2402 ****
/* Handle default labels specially. */
if (!CASE_HIGH (elt) && !CASE_LOW (elt))
{
! #ifdef ENABLE_CHECKING
! if (default_label_decl != 0)
! abort ();
! #endif
! default_label_decl = CASE_LABEL (elt);
}
else
case_list = add_case_node (case_list, CASE_LOW (elt), CASE_HIGH (elt),
! CASE_LABEL (elt));
}
do_pending_stack_adjust ();
--- 2378,2389 ----
/* Handle default labels specially. */
if (!CASE_HIGH (elt) && !CASE_LOW (elt))
{
! gcc_assert (!default_label_decl);
! default_label_decl = CASE_LABEL (elt);
}
else
case_list = add_case_node (case_list, CASE_LOW (elt), CASE_HIGH (elt),
! CASE_LABEL (elt));
}
do_pending_stack_adjust ();
*************** expand_case (tree exp)
*** 2411,2416 ****
--- 2398,2405 ----
/* An ERROR_MARK occurs for various reasons including invalid data type. */
if (index_type != error_mark_node)
{
+ int fail;
+
/* If we don't have a default-label, create one here,
after the body of the switch. */
if (default_label_decl == 0)
*************** expand_case (tree exp)
*** 2431,2440 ****
for (n = case_list; n; n = n->right)
{
/* Check low and high label values are integers. */
! if (TREE_CODE (n->low) != INTEGER_CST)
! abort ();
! if (TREE_CODE (n->high) != INTEGER_CST)
! abort ();
n->low = convert (index_type, n->low);
n->high = convert (index_type, n->high);
--- 2420,2427 ----
for (n = case_list; n; n = n->right)
{
/* Check low and high label values are integers. */
! gcc_assert (TREE_CODE (n->low) == INTEGER_CST);
! gcc_assert (TREE_CODE (n->high) == INTEGER_CST);
n->low = convert (index_type, n->low);
n->high = convert (index_type, n->high);
*************** expand_case (tree exp)
*** 2605,2610 ****
--- 2592,2598 ----
if (! try_casesi (index_type, index_expr, minval, range,
table_label, default_label))
{
+ bool ok;
index_type = integer_type_node;
/* Index jumptables from zero for suitable values of
*************** expand_case (tree exp)
*** 2617,2625 ****
range = maxval;
}
! if (! try_tablejump (index_type, index_expr, minval, range,
! table_label, default_label))
! abort ();
}
/* Get table of labels to jump to, in order of case index. */
--- 2605,2613 ----
range = maxval;
}
! ok = try_tablejump (index_type, index_expr, minval, range,
! table_label, default_label);
! gcc_assert (ok);
}
/* Get table of labels to jump to, in order of case index. */
*************** expand_case (tree exp)
*** 2675,2682 ****
before_case = NEXT_INSN (before_case);
end = get_last_insn ();
! if (squeeze_notes (&before_case, &end))
! abort ();
reorder_insns (before_case, end, start);
}
--- 2663,2670 ----
before_case = NEXT_INSN (before_case);
end = get_last_insn ();
! fail = squeeze_notes (&before_case, &end);
! gcc_assert (!fail);
reorder_insns (before_case, end, start);
}
Index: stor-layout.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/stor-layout.c,v
retrieving revision 1.211
diff -c -3 -p -r1.211 stor-layout.c
*** stor-layout.c 5 Sep 2004 16:05:00 -0000 1.211
--- stor-layout.c 9 Sep 2004 14:27:32 -0000
*************** put_pending_size (tree expr)
*** 108,116 ****
void
put_pending_sizes (tree chain)
{
! if (pending_sizes)
! abort ();
!
pending_sizes = chain;
}
--- 108,114 ----
void
put_pending_sizes (tree chain)
{
! gcc_assert (!pending_sizes);
pending_sizes = chain;
}
*************** smallest_mode_for_size (unsigned int siz
*** 220,226 ****
if (GET_MODE_PRECISION (mode) >= size)
return mode;
! abort ();
}
/* Find an integer mode of the exact same size, or BLKmode on failure. */
--- 218,224 ----
if (GET_MODE_PRECISION (mode) >= size)
return mode;
! gcc_unreachable ();
}
/* Find an integer mode of the exact same size, or BLKmode on failure. */
*************** int_mode_for_mode (enum machine_mode mod
*** 250,256 ****
case MODE_CC:
default:
! abort ();
}
return mode;
--- 248,254 ----
case MODE_CC:
default:
! gcc_unreachable ();
}
return mode;
*************** layout_decl (tree decl, unsigned int kno
*** 302,311 ****
if (code == CONST_DECL)
return;
! else if (code != VAR_DECL && code != PARM_DECL && code != RESULT_DECL
! && code != TYPE_DECL && code != FIELD_DECL)
! abort ();
!
rtl = DECL_RTL_IF_SET (decl);
if (type == error_mark_node)
--- 300,309 ----
if (code == CONST_DECL)
return;
!
! gcc_assert (code == VAR_DECL || code == PARM_DECL || code == RESULT_DECL
! || code == TYPE_DECL ||code == FIELD_DECL);
!
rtl = DECL_RTL_IF_SET (decl);
if (type == error_mark_node)
*************** finish_builtin_struct (tree type, const
*** 1477,1484 ****
void
layout_type (tree type)
{
! if (type == 0)
! abort ();
if (type == error_mark_node)
return;
--- 1475,1481 ----
void
layout_type (tree type)
{
! gcc_assert (type);
if (type == error_mark_node)
return;
*************** layout_type (tree type)
*** 1492,1498 ****
case LANG_TYPE:
/* This kind of type is the responsibility
of the language-specific code. */
! abort ();
case BOOLEAN_TYPE: /* Used for Java, Pascal, and Chill. */
if (TYPE_PRECISION (type) == 0)
--- 1489,1495 ----
case LANG_TYPE:
/* This kind of type is the responsibility
of the language-specific code. */
! gcc_unreachable ();
case BOOLEAN_TYPE: /* Used for Java, Pascal, and Chill. */
if (TYPE_PRECISION (type) == 0)
*************** layout_type (tree type)
*** 1536,1543 ****
tree nunits_tree = build_int_cst (NULL_TREE, nunits);
tree innertype = TREE_TYPE (type);
! if (nunits & (nunits - 1))
! abort ();
/* Find an appropriate mode for the vector type. */
if (TYPE_MODE (type) == VOIDmode)
--- 1533,1539 ----
tree nunits_tree = build_int_cst (NULL_TREE, nunits);
tree innertype = TREE_TYPE (type);
! gcc_assert (!(nunits & (nunits - 1)));
/* Find an appropriate mode for the vector type. */
if (TYPE_MODE (type) == VOIDmode)
*************** layout_type (tree type)
*** 1758,1790 ****
break;
case SET_TYPE: /* Used by Chill and Pascal. */
! if (TREE_CODE (TYPE_MAX_VALUE (TYPE_DOMAIN (type))) != INTEGER_CST
! || TREE_CODE (TYPE_MIN_VALUE (TYPE_DOMAIN (type))) != INTEGER_CST)
! abort ();
! else
! {
#ifndef SET_WORD_SIZE
#define SET_WORD_SIZE BITS_PER_WORD
#endif
! unsigned int alignment
! = set_alignment ? set_alignment : SET_WORD_SIZE;
! HOST_WIDE_INT size_in_bits
! = (tree_low_cst (TYPE_MAX_VALUE (TYPE_DOMAIN (type)), 0)
! - tree_low_cst (TYPE_MIN_VALUE (TYPE_DOMAIN (type)), 0) + 1);
! HOST_WIDE_INT rounded_size
! = ((size_in_bits + alignment - 1) / alignment) * alignment;
!
! if (rounded_size > (int) alignment)
! TYPE_MODE (type) = BLKmode;
! else
! TYPE_MODE (type) = mode_for_size (alignment, MODE_INT, 1);
!
! TYPE_SIZE (type) = bitsize_int (rounded_size);
! TYPE_SIZE_UNIT (type) = size_int (rounded_size / BITS_PER_UNIT);
! TYPE_ALIGN (type) = alignment;
! TYPE_USER_ALIGN (type) = 0;
! TYPE_PRECISION (type) = size_in_bits;
! }
break;
case FILE_TYPE:
--- 1754,1790 ----
break;
case SET_TYPE: /* Used by Chill and Pascal. */
! {
! unsigned int alignment;
! HOST_WIDE_INT size_in_bits;
! HOST_WIDE_INT rounded_size;
!
! gcc_assert (TREE_CODE (TYPE_MAX_VALUE (TYPE_DOMAIN (type)))
! == INTEGER_CST);
! gcc_assert (TREE_CODE (TYPE_MIN_VALUE (TYPE_DOMAIN (type)))
! == INTEGER_CST);
!
#ifndef SET_WORD_SIZE
#define SET_WORD_SIZE BITS_PER_WORD
#endif
! alignment = set_alignment ? set_alignment : SET_WORD_SIZE;
! size_in_bits
! = (tree_low_cst (TYPE_MAX_VALUE (TYPE_DOMAIN (type)), 0)
! - tree_low_cst (TYPE_MIN_VALUE (TYPE_DOMAIN (type)), 0) + 1);
! rounded_size
! = ((size_in_bits + alignment - 1) / alignment) * alignment;
!
! if (rounded_size > (int) alignment)
! TYPE_MODE (type) = BLKmode;
! else
! TYPE_MODE (type) = mode_for_size (alignment, MODE_INT, 1);
!
! TYPE_SIZE (type) = bitsize_int (rounded_size);
! TYPE_SIZE_UNIT (type) = size_int (rounded_size / BITS_PER_UNIT);
! TYPE_ALIGN (type) = alignment;
! TYPE_USER_ALIGN (type) = 0;
! TYPE_PRECISION (type) = size_in_bits;
! }
break;
case FILE_TYPE:
*************** layout_type (tree type)
*** 1796,1802 ****
break;
default:
! abort ();
}
/* Compute the final TYPE_SIZE, TYPE_ALIGN, etc. for TYPE. For
--- 1796,1802 ----
break;
default:
! gcc_unreachable ();
}
/* Compute the final TYPE_SIZE, TYPE_ALIGN, etc. for TYPE. For
*************** set_sizetype (tree type)
*** 1886,1893 ****
2 * HOST_BITS_PER_WIDE_INT);
tree t;
! if (TYPE_UNSIGNED (type) != TYPE_UNSIGNED (sizetype))
! abort ();
t = build_distinct_type_copy (type);
/* We do want to use sizetype's cache, as we will be replacing that
--- 1886,1892 ----
2 * HOST_BITS_PER_WIDE_INT);
tree t;
! gcc_assert (TYPE_UNSIGNED (type) == TYPE_UNSIGNED (sizetype));
t = build_distinct_type_copy (type);
/* We do want to use sizetype's cache, as we will be replacing that
*************** get_mode_bounds (enum machine_mode mode,
*** 2109,2116 ****
unsigned size = GET_MODE_BITSIZE (mode);
unsigned HOST_WIDE_INT min_val, max_val;
! if (size > HOST_BITS_PER_WIDE_INT)
! abort ();
if (sign)
{
--- 2108,2114 ----
unsigned size = GET_MODE_BITSIZE (mode);
unsigned HOST_WIDE_INT min_val, max_val;
! gcc_assert (size <= HOST_BITS_PER_WIDE_INT);
if (sign)
{