+2005-04-21 Nathan Sidwell <nathan@codesourcery.com>
+
+ * alias.c (true_dependence): Remove 'abort' from comments. Use
+ gcc_assert and gcc_unreachable as appropriate.
+ (canon_true_dependence): Likewise.
+ * bb-reorder.c (connect_traces): Likewise.
+ * c-common.c (c_add_case_label): Likewise.
+ * c-decl.c (finish_function): Likewise.
+ * caller-save.c (insert_restore, insert_save): Likewise.
+ * cfg.c (update_bb_profile_for_threading): Likewise.
+ * cfganal.c (flow_active_insn_p): Likewise.
+ * cfgexpand.c (add_reg_br_prob_note): Likewise.
+ * cfgrtl.c (rtl_redirect_edge_and_branch_force, rtl_split_edge,
+ cfg_layout_merge_blocks): Likewise.
+ * ifcvt.c (cond_exec_process_insns, merge_if_block,
+ find_if_block): Likewise.
+ * integrate.c (allocate_initial_values): Likewise.
+ * jump.c (reverse_condition, reverse_condition_maybe_unordered,
+ swap_condition, unsigned_condition, signed_condition,
+ mark_jump_label, invert_jump_1, rtx_renumbered_equal_p,
+ reg_or_subregno): Likewise.
+ * lambda-code.c (lambda_compute_auxillary_space,
+ lambda_transform_legal_p): Likewise.
+ * lambda-mat.c (lambda_matrix_inverse_hard): Likewise.
+ * langhooks.c (lhd_set_decl_assembler_name, lhd_type_promotes_to,
+ lhd_incomplete_type_error, lhd_expand_expr,
+ lhd_types_compatible_p, lhd_tree_size): Likewise.
+ * lcm.c (create_pre_exit, optimize_mode_switching): Likewise.
+ * local-alloc.c (update_equiv_regs): Likewise.
+ * loop-unroll.c (peel_loop_completely
+ unroll_loop_constant_iterations, unroll_loop_runtime_iterations,
+ peel_loop_simple, unroll_loop_stupid,
+ analyze_iv_to_split_insn): Likewise.
+ * loop.c (gen_prefetch, find_and_verify_loops,
+ basic_induction_var): Likewise.
+ * modulo-sched.c (normalize_sched_times, check_nodes_order): Likewise.
+ * value-prof.c (tree_find_values_to_profile): Likewise.
+ * varasm.c (named_section, default_assemble_integer,
+ decode_addr_const): Likewise.
+
2005-04-21 Alan Modra <amodra@bigpond.net.au>
Fariborz Jahanian <fjahanian@apple.com>
- * config/rs6000/rs6000.c (rs6000_arg_partial_bytes): Fix size of
- portion of argument passed in fpr.
- *expr.c (emit_push_insn): Fix computation of 'offset' used to
- decide on partial argument save on stack.
+ * config/rs6000/rs6000.c (rs6000_arg_partial_bytes): Fix size of
+ portion of argument passed in fpr.
+ * expr.c (emit_push_insn): Fix computation of 'offset' used to
+ decide on partial argument save on stack.
2005-04-21 Kazu Hirata <kazu@cs.umass.edu>
(ipa_passes): Declare.
* Makefile.in (cgraphunit.o): Add dependency on cgraphunit.h
+2005-04-21 Nathan Sidwell <nathan@codesourcery.com>
+
2005-04-21 Nathan Sidwell <nathan@codesourcery.com>
* config/i386/i386.c (type_natural_mode): Use gcc_unreachable and
/* Read-only memory is by definition never modified, and therefore can't
conflict with anything. We don't expect to find read-only set on MEM,
- but stupid user tricks can produce them, so don't abort. */
+ but stupid user tricks can produce them, so don't die. */
if (MEM_READONLY_P (x))
return 0;
/* Read-only memory is by definition never modified, and therefore can't
conflict with anything. We don't expect to find read-only set on MEM,
- but stupid user tricks can produce them, so don't abort. */
+ but stupid user tricks can produce them, so don't die. */
if (MEM_READONLY_P (x))
return 0;
if (i >= n_traces)
{
- if (two_passes && current_pass == 1)
- {
- i = 0;
- t = i;
- current_pass = 2;
- if (current_partition == BB_HOT_PARTITION)
- current_partition = BB_COLD_PARTITION;
- else
- current_partition = BB_HOT_PARTITION;
- }
+ gcc_assert (two_passes && current_pass == 1);
+ i = 0;
+ t = i;
+ current_pass = 2;
+ if (current_partition == BB_HOT_PARTITION)
+ current_partition = BB_COLD_PARTITION;
else
- abort ();
+ current_partition = BB_HOT_PARTITION;
}
if (connected[t])
error_out:
/* Add a label so that the back-end doesn't think that the beginning of
the switch is unreachable. Note that we do not add a case label, as
- that just leads to duplicates and thence to aborts later on. */
+ that just leads to duplicates and thence to failure later on. */
if (!cases->root)
{
tree t = create_artificial_label ();
if (warn_return_type
&& TREE_CODE (TREE_TYPE (TREE_TYPE (fndecl))) != VOID_TYPE
&& !current_function_returns_value && !current_function_returns_null
- /* Don't complain if we abort. */
+ /* Don't complain if we are no-return. */
&& !current_function_returns_abnormally
/* Don't warn for main(). */
&& !MAIN_NAME_P (DECL_NAME (fndecl))
struct insn_chain *new;
rtx mem;
- /* A common failure mode if register status is not correct in the RTL
- is for this routine to be called with a REGNO we didn't expect to
- save. That will cause us to write an insn with a (nil) SET_DEST
- or SET_SRC. Instead of doing so and causing a crash later, check
- for this common case and abort here instead. This will remove one
- step in debugging such problems. */
+ /* A common failure mode if register status is not correct in the
+ RTL is for this routine to be called with a REGNO we didn't
+ expect to save. That will cause us to write an insn with a (nil)
+ SET_DEST or SET_SRC. Instead of doing so and causing a crash
+ later, check for this common case here instead. This will remove
+ one step in debugging such problems. */
gcc_assert (regno_save_mem[regno][1]);
/* Get the pattern to emit and update our status.
struct insn_chain *new;
rtx mem;
- /* A common failure mode if register status is not correct in the RTL
- is for this routine to be called with a REGNO we didn't expect to
- save. That will cause us to write an insn with a (nil) SET_DEST
- or SET_SRC. Instead of doing so and causing a crash later, check
- for this common case and abort here instead. This will remove one
+ /* A common failure mode if register status is not correct in the
+ RTL is for this routine to be called with a REGNO we didn't
+ expect to save. That will cause us to write an insn with a (nil)
+ SET_DEST or SET_SRC. Instead of doing so and causing a crash
+ later, check for this common case here. This will remove one
step in debugging such problems. */
gcc_assert (regno_save_mem[regno][1]);
c->probability *= scale / 65536;
}
- if (bb != taken_edge->src)
- abort ();
+ gcc_assert (bb == taken_edge->src);
taken_edge->count -= count;
if (taken_edge->count < 0)
taken_edge->count = 0;
programs that fail to return a value. Its effect is to
keep the return value from being live across the entire
function. If we allow it to be skipped, we introduce the
- possibility for register livetime aborts. */
+ possibility for register lifetime confusion. */
if (GET_CODE (PATTERN (insn)) == CLOBBER
&& REG_P (XEXP (PATTERN (insn), 0))
&& REG_FUNCTION_VALUE_P (XEXP (PATTERN (insn), 0)))
|| GET_CODE (NEXT_INSN (NEXT_INSN (NEXT_INSN (last)))) != CODE_LABEL
|| NEXT_INSN (NEXT_INSN (NEXT_INSN (NEXT_INSN (last)))))
goto failed;
- if (find_reg_note (last, REG_BR_PROB, 0))
- abort ();
+ gcc_assert (!find_reg_note (last, REG_BR_PROB, 0));
REG_NOTES (last)
= gen_rtx_EXPR_LIST (REG_BR_PROB,
GEN_INT (REG_BR_PROB_BASE - probability),
return;
}
if (!last || GET_CODE (last) != JUMP_INSN || !any_condjump_p (last))
- goto failed;
- if (find_reg_note (last, REG_BR_PROB, 0))
- abort ();
+ goto failed;
+ gcc_assert (!find_reg_note (last, REG_BR_PROB, 0));
REG_NOTES (last)
= gen_rtx_EXPR_LIST (REG_BR_PROB,
GEN_INT (probability), REG_NOTES (last));
/* Redirect edge even at the expense of creating new jump insn or
basic block. Return new basic block if created, NULL otherwise.
- Abort if conversion is impossible. */
+ Conversion must be possible. */
static basic_block
rtl_redirect_edge_and_branch_force (edge e, basic_block target)
}
/* Split a (typically critical) edge. Return the new block.
- Abort on abnormal edges.
+ The edge must not be abnormal.
??? The code generally expects to be called on critical edges.
The case of a block ending in an unconditional jump to a
? simplejump_p (BB_END (a)) : onlyjump_p (BB_END (a)))));
}
-/* Merge block A and B, abort when it is not possible. */
+/* Merge block A and B. The blocks must be mergeable. */
+
static void
cfg_layout_merge_blocks (basic_block a, basic_block b)
{
if (NOTE_P (insn))
goto insn_done;
- if (!NONJUMP_INSN_P (insn) && !CALL_P (insn))
- abort ();
+ gcc_assert(NONJUMP_INSN_P (insn) || CALL_P (insn));
/* Remove USE insns that get in the way. */
if (reload_completed && GET_CODE (PATTERN (insn)) == USE)
/* The outgoing edge for the current COMBO block should already
be correct. Verify this. */
if (EDGE_COUNT (combo_bb->succs) == 0)
- {
- if (find_reg_note (last, REG_NORETURN, NULL))
- ;
- else if (NONJUMP_INSN_P (last)
- && GET_CODE (PATTERN (last)) == TRAP_IF
- && TRAP_CONDITION (PATTERN (last)) == const_true_rtx)
- ;
- else
- abort ();
- }
+ gcc_assert (find_reg_note (last, REG_NORETURN, NULL)
+ || (NONJUMP_INSN_P (last)
+ && GET_CODE (PATTERN (last)) == TRAP_IF
+ && (TRAP_CONDITION (PATTERN (last))
+ == const_true_rtx)));
+ else
/* There should still be something at the end of the THEN or ELSE
blocks taking us to our final destination. */
- else if (JUMP_P (last))
- ;
- else if (EDGE_SUCC (combo_bb, 0)->dest == EXIT_BLOCK_PTR
- && CALL_P (last)
- && SIBLING_CALL_P (last))
- ;
- else if ((EDGE_SUCC (combo_bb, 0)->flags & EDGE_EH)
- && can_throw_internal (last))
- ;
- else
- abort ();
+ gcc_assert (JUMP_P (last)
+ || (EDGE_SUCC (combo_bb, 0)->dest == EXIT_BLOCK_PTR
+ && CALL_P (last)
+ && SIBLING_CALL_P (last))
+ || ((EDGE_SUCC (combo_bb, 0)->flags & EDGE_EH)
+ && can_throw_internal (last)));
}
/* The JOIN block may have had quite a number of other predecessors too.
have only one remaining edge from our if-then-else diamond. If there
is more than one remaining edge, it must come from elsewhere. There
may be zero incoming edges if the THEN block didn't actually join
- back up (as with a call to abort). */
+ back up (as with a call to a non-return function). */
else if (EDGE_COUNT (join_bb->preds) < 2
&& join_bb != EXIT_BLOCK_PTR)
{
we checked the FALLTHRU flag, those are already adjacent to the last IF
block. */
/* ??? As an enhancement, move the ELSE block. Have to deal with
- BLOCK notes, if by no other means than aborting the merge if they
+ BLOCK notes, if by no other means than backing out the merge if they
exist. Sticky enough I don't want to think about it now. */
next = then_bb;
if (else_bb && (next = next->next_bb) != else_bb)
int regno = REGNO (ivs->entries[i].pseudo);
rtx x = ALLOCATE_INITIAL_VALUE (ivs->entries[i].hard_reg);
- if (x == NULL_RTX || REG_N_SETS (REGNO (ivs->entries[i].pseudo)) > 1)
- ; /* Do nothing. */
- else if (MEM_P (x))
- reg_equiv_memory_loc[regno] = x;
- else if (REG_P (x))
+ if (x && REG_N_SETS (REGNO (ivs->entries[i].pseudo)) <= 1)
{
- reg_renumber[regno] = REGNO (x);
- /* Poke the regno right into regno_reg_rtx
- so that even fixed regs are accepted. */
- REGNO (ivs->entries[i].pseudo) = REGNO (x);
+ if (MEM_P (x))
+ reg_equiv_memory_loc[regno] = x;
+ else
+ {
+ gcc_assert (REG_P (x));
+ reg_renumber[regno] = REGNO (x);
+ /* Poke the regno right into regno_reg_rtx so that even
+ fixed regs are accepted. */
+ REGNO (ivs->entries[i].pseudo) = REGNO (x);
+ }
}
- else abort ();
}
#endif
}
return UNKNOWN;
default:
- abort ();
+ gcc_unreachable ();
}
}
return LTGT;
default:
- abort ();
+ gcc_unreachable ();
}
}
return UNLE;
default:
- abort ();
+ gcc_unreachable ();
}
}
return LEU;
default:
- abort ();
+ gcc_unreachable ();
}
}
return LE;
default:
- abort ();
+ gcc_unreachable ();
}
}
\f
&& NOTE_LINE_NUMBER (label) == NOTE_INSN_DELETED_LABEL)
break;
- if (!LABEL_P (label))
- abort ();
+ gcc_assert (LABEL_P (label));
/* Ignore references to labels of containing functions. */
if (LABEL_REF_NONLOCAL_P (x))
{
rtx x = pc_set (jump);
int ochanges;
+ int ok;
ochanges = num_validated_changes ();
- if (!x || !invert_exp_1 (SET_SRC (x), jump))
- abort ();
+ gcc_assert (x);
+ ok = invert_exp_1 (SET_SRC (x), jump);
+ gcc_assert (ok);
+
if (num_validated_changes () == ochanges)
return 0;
break;
default:
- abort ();
+ gcc_unreachable ();
}
}
return 1;
unsigned int
reg_or_subregno (rtx reg)
{
- if (REG_P (reg))
- return REGNO (reg);
if (GET_CODE (reg) == SUBREG)
- return REGNO (SUBREG_REG (reg));
- abort ();
+ reg = SUBREG_REG (reg);
+ gcc_assert (REG_P (reg));
+ return REGNO (reg);
}
/* Unfortunately, we can't know the number of constraints we'll have
ahead of time, but this should be enough even in ridiculous loop nest
- cases. We abort if we go over this limit. */
+ cases. We must not go over this limit. */
A = lambda_matrix_new (128, depth);
B = lambda_matrix_new (128, invariants);
a = lambda_vector_new (128);
lambda_vector distres;
struct data_dependence_relation *ddr;
-#if defined ENABLE_CHECKING
- if (LTM_COLSIZE (trans) != nb_loops
- || LTM_ROWSIZE (trans) != nb_loops)
- abort ();
-#endif
+ gcc_assert (LTM_COLSIZE (trans) == nb_loops
+ && LTM_ROWSIZE (trans) == nb_loops);
/* When there is an unknown relation in the dependence_relations, we
know that it is no worth looking at this loop nest: give up. */
row = temp[j];
diagonal = row[j];
- /* If the matrix is singular, abort. */
- if (diagonal == 0)
- abort ();
+ /* The matrix must not be singular. */
+ gcc_assert (diagonal);
determinant = determinant * diagonal;
DECL_ASSEMBLER_NAME for lots of DECLs. Only FUNCTION_DECLs and
VAR_DECLs for variables with static storage duration need a real
DECL_ASSEMBLER_NAME. */
- if (TREE_CODE (decl) == FUNCTION_DECL
- || (TREE_CODE (decl) == VAR_DECL
- && (TREE_STATIC (decl)
- || DECL_EXTERNAL (decl)
- || TREE_PUBLIC (decl))))
+ gcc_assert (TREE_CODE (decl) == FUNCTION_DECL
+ || (TREE_CODE (decl) == VAR_DECL
+ && (TREE_STATIC (decl)
+ || DECL_EXTERNAL (decl)
+ || TREE_PUBLIC (decl))));
+
+ /* By default, assume the name to use in assembly code is the same
+ as that used in the source language. (That's correct for C, and
+ GCC used to set DECL_ASSEMBLER_NAME to the same value as
+ DECL_NAME in build_decl, so this choice provides backwards
+ compatibility with existing front-ends.
+
+ Can't use just the variable's own name for a variable whose scope
+ is less than the whole compilation. Concatenate a distinguishing
+ number - we use the DECL_UID. */
+ if (TREE_PUBLIC (decl) || DECL_CONTEXT (decl) == NULL_TREE)
+ SET_DECL_ASSEMBLER_NAME (decl, DECL_NAME (decl));
+ else
{
- /* By default, assume the name to use in assembly code is the
- same as that used in the source language. (That's correct
- for C, and GCC used to set DECL_ASSEMBLER_NAME to the same
- value as DECL_NAME in build_decl, so this choice provides
- backwards compatibility with existing front-ends.
-
- Can't use just the variable's own name for a variable whose
- scope is less than the whole compilation. Concatenate a
- distinguishing number - we use the DECL_UID. */
- if (TREE_PUBLIC (decl) || DECL_CONTEXT (decl) == NULL_TREE)
- SET_DECL_ASSEMBLER_NAME (decl, DECL_NAME (decl));
- else
- {
- const char *name = IDENTIFIER_POINTER (DECL_NAME (decl));
- char *label;
-
- ASM_FORMAT_PRIVATE_NAME (label, name, DECL_UID (decl));
- SET_DECL_ASSEMBLER_NAME (decl, get_identifier (label));
- }
+ const char *name = IDENTIFIER_POINTER (DECL_NAME (decl));
+ char *label;
+
+ ASM_FORMAT_PRIVATE_NAME (label, name, DECL_UID (decl));
+ SET_DECL_ASSEMBLER_NAME (decl, get_identifier (label));
}
- else
- /* Nobody should ever be asking for the DECL_ASSEMBLER_NAME of
- these DECLs -- unless they're in language-dependent code, in
- which case set_decl_assembler_name hook should handle things. */
- abort ();
}
/* By default we always allow bit-field based optimizations. */
tree
lhd_type_promotes_to (tree ARG_UNUSED (type))
{
- abort ();
+ gcc_unreachable ();
}
/* Registration of machine- or os-specific builtin types. */
void
lhd_incomplete_type_error (tree ARG_UNUSED (value), tree type)
{
- if (TREE_CODE (type) == ERROR_MARK)
- return;
-
- abort ();
+ gcc_assert (TREE_CODE (type) == ERROR_MARK);
+ return;
}
/* Provide a default routine for alias sets that always returns -1. This
int ARG_UNUSED (em),
rtx * ARG_UNUSED (a))
{
- abort ();
+ gcc_unreachable ();
}
/* The default language-specific function for expanding a decl. After
handle language-specific tree codes, as well as language-specific
information associated to common tree codes. If a tree node is
completely handled within this function, it should set *SUBTREES to
- 0, so that generic handling isn't attempted. For language-specific
- tree codes, generic handling would abort(), so make sure it is set
- properly. Both SUBTREES and *SUBTREES is guaranteed to be nonzero
- when the function is called. */
+ 0, so that generic handling isn't attempted. The generic handling
+ cannot deal with language-specific tree codes, so make sure it is
+ set properly. Both SUBTREES and *SUBTREES is guaranteed to be
+ nonzero when the function is called. */
tree
lhd_tree_inlining_walk_subtrees (tree *tp ATTRIBUTE_UNUSED,
size_t
lhd_tree_size (enum tree_code c ATTRIBUTE_UNUSED)
{
- abort ();
- return 0;
+ gcc_unreachable ();
}
/* Return true if decl, which is a function decl, may be called by a
last_insn = return_copy;
}
while (nregs);
+
/* If we didn't see a full return value copy, verify that there
is a plausible reason for this. If some, but not all of the
return register is likely spilled, we can expect that there
is a copy for the likely spilled part. */
- if (nregs
- && ! forced_late_switch
- && ! short_block
- && CLASS_LIKELY_SPILLED_P (REGNO_REG_CLASS (ret_start))
- && nregs == hard_regno_nregs[ret_start][GET_MODE (ret_reg)]
- /* For multi-hard-register floating point values,
- sometimes the likely-spilled part is ordinarily copied
- first, then the other part is set with an arithmetic
- operation. This doesn't actually cause reload failures,
- so let it pass. */
- && (GET_MODE_CLASS (GET_MODE (ret_reg)) == MODE_INT
- || nregs == 1))
- abort ();
+ gcc_assert (!nregs
+ || forced_late_switch
+ || short_block
+ || !(CLASS_LIKELY_SPILLED_P
+ (REGNO_REG_CLASS (ret_start)))
+ || (nregs
+ != hard_regno_nregs[ret_start][GET_MODE (ret_reg)])
+ /* For multi-hard-register floating point
+ values, sometimes the likely-spilled part
+ is ordinarily copied first, then the other
+ part is set with an arithmetic operation.
+ This doesn't actually cause reload
+ failures, so let it pass. */
+ || (GET_MODE_CLASS (GET_MODE (ret_reg)) != MODE_INT
+ && nregs != 1));
+
if (INSN_P (last_insn))
{
before_return_copy
emited = true;
if (JUMP_P (BB_END (src_bb)))
emit_insn_before (mode_set, BB_END (src_bb));
- /* It doesn't make sense to switch to normal mode
- after a CALL_INSN, so we're going to abort if we
- find one. The cases in which a CALL_INSN may
- have an abnormal edge are sibcalls and EH edges.
- In the case of sibcalls, the dest basic-block is
- the EXIT_BLOCK, that runs in normal mode; it is
- assumed that a sibcall insn requires normal mode
- itself, so no mode switch would be required after
- the call (it wouldn't make sense, anyway). In
- the case of EH edges, EH entry points also start
- in normal mode, so a similar reasoning applies. */
- else if (NONJUMP_INSN_P (BB_END (src_bb)))
- emit_insn_after (mode_set, BB_END (src_bb));
else
- abort ();
+ {
+ /* It doesn't make sense to switch to normal
+ mode after a CALL_INSN. The cases in which a
+ CALL_INSN may have an abnormal edge are
+ sibcalls and EH edges. In the case of
+ sibcalls, the dest basic-block is the
+ EXIT_BLOCK, that runs in normal mode; it is
+ assumed that a sibcall insn requires normal
+ mode itself, so no mode switch would be
+ required after the call (it wouldn't make
+ sense, anyway). In the case of EH edges, EH
+ entry points also start in normal mode, so a
+ similar reasoning applies. */
+ gcc_assert (NONJUMP_INSN_P (BB_END (src_bb)));
+ emit_insn_after (mode_set, BB_END (src_bb));
+ }
bb_info[j][src_bb->index].computing = mode;
RESET_BIT (transp[src_bb->index], j);
}
REG_NOTES (new_insn) = REG_NOTES (equiv_insn);
REG_NOTES (equiv_insn) = 0;
- /* Make sure this insn is recognized before reload begins,
- otherwise eliminate_regs_in_insn will abort. */
+ /* Make sure this insn is recognized before
+ reload begins, otherwise
+ eliminate_regs_in_insn will die. */
INSN_CODE (new_insn) = INSN_CODE (equiv_insn);
delete_insn (equiv_insn);
if (npeel)
{
+ bool ok;
+
wont_exit = sbitmap_alloc (npeel + 1);
sbitmap_ones (wont_exit);
RESET_BIT (wont_exit, 0);
opt_info = analyze_insns_in_loop (loop);
opt_info_start_duplication (opt_info);
- if (!duplicate_loop_to_header_edge (loop, loop_preheader_edge (loop),
- loops, npeel,
- wont_exit, desc->out_edge, remove_edges, &n_remove_edges,
- DLTHE_FLAG_UPDATE_FREQ))
- abort ();
+ ok = duplicate_loop_to_header_edge (loop, loop_preheader_edge (loop),
+ loops, npeel,
+ wont_exit, desc->out_edge,
+ remove_edges, &n_remove_edges,
+ DLTHE_FLAG_UPDATE_FREQ);
+ gcc_assert (ok);
free (wont_exit);
struct niter_desc *desc = get_simple_loop_desc (loop);
bool exit_at_end = loop_exit_at_end_p (loop);
struct opt_info *opt_info = NULL;
+ bool ok;
niter = desc->niter;
if (exit_mod)
{
opt_info_start_duplication (opt_info);
- if (!duplicate_loop_to_header_edge (loop, loop_preheader_edge (loop),
+ ok = duplicate_loop_to_header_edge (loop, loop_preheader_edge (loop),
loops, exit_mod,
wont_exit, desc->out_edge,
remove_edges, &n_remove_edges,
- DLTHE_FLAG_UPDATE_FREQ))
- abort ();
+ DLTHE_FLAG_UPDATE_FREQ);
+ gcc_assert (ok);
if (opt_info && exit_mod > 1)
apply_opt_in_copies (opt_info, exit_mod, false, false);
RESET_BIT (wont_exit, 1);
opt_info_start_duplication (opt_info);
- if (!duplicate_loop_to_header_edge (loop, loop_preheader_edge (loop),
- loops, exit_mod + 1,
- wont_exit, desc->out_edge, remove_edges, &n_remove_edges,
- DLTHE_FLAG_UPDATE_FREQ))
- abort ();
+ ok = duplicate_loop_to_header_edge (loop, loop_preheader_edge (loop),
+ loops, exit_mod + 1,
+ wont_exit, desc->out_edge,
+ remove_edges, &n_remove_edges,
+ DLTHE_FLAG_UPDATE_FREQ);
+ gcc_assert (ok);
if (opt_info && exit_mod > 0)
apply_opt_in_copies (opt_info, exit_mod + 1, false, false);
/* Now unroll the loop. */
opt_info_start_duplication (opt_info);
- if (!duplicate_loop_to_header_edge (loop, loop_latch_edge (loop),
- loops, max_unroll,
- wont_exit, desc->out_edge, remove_edges, &n_remove_edges,
- DLTHE_FLAG_UPDATE_FREQ))
- abort ();
+ ok = duplicate_loop_to_header_edge (loop, loop_latch_edge (loop),
+ loops, max_unroll,
+ wont_exit, desc->out_edge,
+ remove_edges, &n_remove_edges,
+ DLTHE_FLAG_UPDATE_FREQ);
+ gcc_assert (ok);
if (opt_info)
{
struct niter_desc *desc = get_simple_loop_desc (loop);
bool exit_at_end = loop_exit_at_end_p (loop);
struct opt_info *opt_info = NULL;
+ bool ok;
if (flag_split_ivs_in_unroller
|| flag_variable_expansion_in_unroller)
&& !desc->noloop_assumptions)
SET_BIT (wont_exit, 1);
ezc_swtch = loop_preheader_edge (loop)->src;
- if (!duplicate_loop_to_header_edge (loop, loop_preheader_edge (loop),
- loops, 1,
- wont_exit, desc->out_edge, remove_edges, &n_remove_edges,
- DLTHE_FLAG_UPDATE_FREQ))
- abort ();
+ ok = duplicate_loop_to_header_edge (loop, loop_preheader_edge (loop),
+ loops, 1,
+ wont_exit, desc->out_edge,
+ remove_edges, &n_remove_edges,
+ DLTHE_FLAG_UPDATE_FREQ);
+ gcc_assert (ok);
/* Record the place where switch will be built for preconditioning. */
swtch = loop_split_edge_with (loop_preheader_edge (loop),
sbitmap_zero (wont_exit);
if (i != n_peel - 1 || !last_may_exit)
SET_BIT (wont_exit, 1);
- if (!duplicate_loop_to_header_edge (loop, loop_preheader_edge (loop),
- loops, 1,
- wont_exit, desc->out_edge, remove_edges, &n_remove_edges,
- DLTHE_FLAG_UPDATE_FREQ))
- abort ();
+ ok = duplicate_loop_to_header_edge (loop, loop_preheader_edge (loop),
+ loops, 1,
+ wont_exit, desc->out_edge,
+ remove_edges, &n_remove_edges,
+ DLTHE_FLAG_UPDATE_FREQ);
+ gcc_assert (ok);
/* Create item for switch. */
j = n_peel - i - (extra_zero_check ? 0 : 1);
preheader = loop_split_edge_with (loop_preheader_edge (loop), NULL_RTX);
branch_code = compare_and_jump_seq (copy_rtx (niter), GEN_INT (j), EQ,
- block_label (preheader), p, NULL_RTX);
+ block_label (preheader), p,
+ NULL_RTX);
swtch = loop_split_edge_with (single_pred_edge (swtch), branch_code);
set_immediate_dominator (CDI_DOMINATORS, preheader, swtch);
swtch = ezc_swtch;
preheader = loop_split_edge_with (loop_preheader_edge (loop), NULL_RTX);
branch_code = compare_and_jump_seq (copy_rtx (niter), const0_rtx, EQ,
- block_label (preheader), p, NULL_RTX);
+ block_label (preheader), p,
+ NULL_RTX);
swtch = loop_split_edge_with (single_succ_edge (swtch), branch_code);
set_immediate_dominator (CDI_DOMINATORS, preheader, swtch);
RESET_BIT (wont_exit, may_exit_copy);
opt_info_start_duplication (opt_info);
- if (!duplicate_loop_to_header_edge (loop, loop_latch_edge (loop),
- loops, max_unroll,
- wont_exit, desc->out_edge, remove_edges, &n_remove_edges,
- DLTHE_FLAG_UPDATE_FREQ))
- abort ();
+ ok = duplicate_loop_to_header_edge (loop, loop_latch_edge (loop),
+ loops, max_unroll,
+ wont_exit, desc->out_edge,
+ remove_edges, &n_remove_edges,
+ DLTHE_FLAG_UPDATE_FREQ);
+ gcc_assert (ok);
if (opt_info)
{
if (exit_at_end)
{
basic_block exit_block = desc->in_edge->src->rbi->copy;
- /* Find a new in and out edge; they are in the last copy we have made. */
+ /* Find a new in and out edge; they are in the last copy we have
+ made. */
if (EDGE_SUCC (exit_block, 0)->dest == desc->out_edge->dest)
{
the correct new number of iterations is this: */
gcc_assert (!desc->const_iter);
desc->niter_expr =
- simplify_gen_binary (UDIV, desc->mode, old_niter, GEN_INT (max_unroll + 1));
+ simplify_gen_binary (UDIV, desc->mode, old_niter,
+ GEN_INT (max_unroll + 1));
desc->niter_max /= max_unroll + 1;
if (exit_at_end)
{
unsigned npeel = loop->lpt_decision.times;
struct niter_desc *desc = get_simple_loop_desc (loop);
struct opt_info *opt_info = NULL;
+ bool ok;
if (flag_split_ivs_in_unroller && npeel > 1)
opt_info = analyze_insns_in_loop (loop);
opt_info_start_duplication (opt_info);
- if (!duplicate_loop_to_header_edge (loop, loop_preheader_edge (loop),
- loops, npeel, wont_exit, NULL, NULL, NULL,
- DLTHE_FLAG_UPDATE_FREQ))
- abort ();
+ ok = duplicate_loop_to_header_edge (loop, loop_preheader_edge (loop),
+ loops, npeel, wont_exit,
+ NULL, NULL,
+ NULL, DLTHE_FLAG_UPDATE_FREQ);
+ gcc_assert (ok);
free (wont_exit);
unsigned nunroll = loop->lpt_decision.times;
struct niter_desc *desc = get_simple_loop_desc (loop);
struct opt_info *opt_info = NULL;
+ bool ok;
if (flag_split_ivs_in_unroller
|| flag_variable_expansion_in_unroller)
sbitmap_zero (wont_exit);
opt_info_start_duplication (opt_info);
- if (!duplicate_loop_to_header_edge (loop, loop_latch_edge (loop),
- loops, nunroll, wont_exit, NULL, NULL, NULL,
- DLTHE_FLAG_UPDATE_FREQ))
- abort ();
+ ok = duplicate_loop_to_header_edge (loop, loop_latch_edge (loop),
+ loops, nunroll, wont_exit,
+ NULL, NULL, NULL,
+ DLTHE_FLAG_UPDATE_FREQ);
+ gcc_assert (ok);
if (opt_info)
{
rtx set, dest;
struct rtx_iv iv;
struct iv_to_split *ivts;
+ bool ok;
/* For now we just split the basic induction variables. Later this may be
extended for example by selecting also addresses of memory references. */
if (!biv_p (insn, dest))
return NULL;
- if (!iv_analyze (insn, dest, &iv))
- abort ();
+ ok = iv_analyze (insn, dest, &iv);
+ gcc_assert (ok);
if (iv.step == const0_rtx
|| iv.mode != iv.extend_mode)
#ifndef HAVE_prefetch
#define HAVE_prefetch 0
#define CODE_FOR_prefetch 0
-#define gen_prefetch(a,b,c) (abort(), NULL_RTX)
+#define gen_prefetch(a,b,c) (gcc_unreachable (), NULL_RTX)
#endif
/* Give up the prefetch optimizations once we exceed a given threshold.
if (invert_jump (p, new_label, 1))
{
rtx q, r;
+ bool only_notes;
/* If no suitable BARRIER was found, create a suitable
one before TARGET. Since TARGET is a fall through
/* Include the BARRIER after INSN and copy the
block after LOC. */
- if (squeeze_notes (&new_label, &last_insn_to_move))
- abort ();
+ only_notes = squeeze_notes (&new_label,
+ &last_insn_to_move);
+ gcc_assert (!only_notes);
+
reorder_insns (new_label, last_insn_to_move, loc);
/* All those insns are now in TARGET_LOOP. */
case CONST_INT:
case SYMBOL_REF:
case CONST:
- /* convert_modes aborts if we try to convert to or from CCmode, so just
+ /* convert_modes dies if we try to convert to or from CCmode, so just
exclude that case. It is very unlikely that a condition code value
- would be a useful iterator anyways. convert_modes aborts if we try to
+ would be a useful iterator anyways. convert_modes dies if we try to
convert a float mode to non-float or vice versa too. */
if (loop->level == 1
&& GET_MODE_CLASS (mode) == GET_MODE_CLASS (GET_MODE (dest_reg))
ddg_node_ptr u = &g->nodes[i];
int normalized_time = SCHED_TIME (u) - amount;
- if (normalized_time < 0)
- abort ();
+ gcc_assert (normalized_time >= 0);
SCHED_TIME (u) = normalized_time;
SCHED_ROW (u) = normalized_time % ii;
{
int u = node_order[i];
- if (u >= num_nodes || u < 0 || TEST_BIT (tmp, u))
- abort ();
+ gcc_assert (u < num_nodes && u >= 0 && !TEST_BIT (tmp, u));
SET_BIT (tmp, u);
}
break;
default:
- abort ();
+ gcc_unreachable ();
}
}
}
flags = targetm.section_type_flags (decl, name, reloc);
/* Sanity check user variables for flag changes. Non-user
- section flag changes will abort in named_section_flags.
+ section flag changes will die in named_section_flags.
However, don't complain if SECTION_OVERRIDE is set.
We trust that the setter knows that it is safe to ignore
the default flags for this decl. */
/* Assemble the integer constant X into an object of SIZE bytes. ALIGN is
the alignment of the integer in bits. Return 1 if we were able to output
- the constant, otherwise 0. If FORCE is nonzero, abort if we can't output
- the constant. */
+ the constant, otherwise 0. We must be able to output the constant,
+ if FORCE is nonzero. */
bool
assemble_integer (rtx x, unsigned int size, unsigned int align, int force)
/* Given an expression EXP with a constant value,
reduce it to the sum of an assembler symbol and an integer.
Store them both in the structure *VALUE.
- Abort if EXP does not reduce. */
+ EXP must be reduceable. */
struct addr_const GTY(())
{
projects / gcc.git / commitdiff