+2005-04-21 Nathan Sidwell <nathan@codesourcery.com>
+
+ * cfghooks.h (struct cfg_hooks): Reword comments to avoid 'abort'.
+ * lambda.h (lambda_vector_min_nz): Likewise.
+ * langhooks.h (struct lang_hooks_for_types,
+ struct lang_hooks): Likewise.
+ * output.h (assemble_integer, this_is_asm_operands): Likewise.
+ * tree.h: Likewise.
+ * vec.h: Likewise.
+ * tree-flow-inline.h (relink_imm_use): Use gcc_assert.
+
+ * optabs.c (prepare_cmp_insn, emit_cmp_and_jump_insns): Reword
+ comments to avoid 'abort'. Use gcc_assert as necessary.
+ * opts.c (common_handle_option): Likewise.
+ * pretty-print.c (pp_base_format_text): Likewise.
+ * print-rtl.c (print_rtx): Likewise.
+ * read-rtl.c (read_rtx_filename, read_rtx_1): Likewise.
+ * regmove.c (try_auto_increment): Likewise.
+ * reload.c (find_valid_class, find_reloads_toplev,
+ find_equiv_reg): Likewise.
+ * reload1.c (reload, forget_old_reloads_1, function_invariant_p,
+ merge_assigned_reloads): Likewise.
+ * tree-inline.c (inline_forbidden_p_1,
+ estimate_num_insns_1): Likewise.
+ * tree-optimize.c (execute_todo): Likewise.
+ * tree-outof-ssa.c (eliminate_phi): Likewise.
+ * tree-ssa-alias.c (add_pointed_to_expr): Likewise.
+ * tree-ssa-ccp.c (maybe_fold_stmt_indirect): Likewise.
+ * tree-ssa-operands.c (parse_ssa_operands,
+ get_indirect_ref_operands, create_ssa_artficial_load_stmt): Likewise.
+ * tree-ssa-pre.c (find_or_generate_expression): Likewise.
+ * tree-ssanames.c (release_ssa_name): Likewise.
+ * tree.c (int_bit_position, int_byte_position, tree_low_cst,
+ walk_tree): Likewise.
+
+ * tree-ssa-operands.c (verify_abort): Fold into ..
+ (verify_imm_links): ... here.
+
2005-04-21 Richard Henderson <rth@redhat.com>
* config/alpha/sync.md (sync_new_nand<I48MODE>): Fix constraints
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
gcc_assert instead of abort.
(classify_argument, examine_argument, construct_container,
edge (*redirect_edge_and_branch) (edge e, basic_block b);
/* Same as the above but allows redirecting of fallthru edges. In that case
- newly created forwarder basic block is returned. It aborts when called
- on abnormal edge. */
+ newly created forwarder basic block is returned. The edge must
+ not be abnormal. */
basic_block (*redirect_edge_and_branch_force) (edge, basic_block);
/* Remove statements corresponding to a given basic block. */
{
int j;
int min = -1;
-#ifdef ENABLE_CHECKING
- if (start > n)
- abort ();
-#endif
+
+ gcc_assert (start <= n);
for (j = start; j < n; j++)
{
if (vec1[j])
if (min < 0 || vec1[j] < vec1[min])
min = j;
}
-
- if (min < 0)
- abort ();
+ gcc_assert (min >= 0);
return min;
}
/* Given a type, apply default promotions to unnamed function
arguments and return the new type. Return the same type if no
change. Required by any language that supports variadic
- arguments. The default hook aborts. */
+ arguments. The default hook dies. */
tree (*type_promotes_to) (tree);
/* Register TYPE as a builtin type with the indicated NAME. The
/* Determines the size of any language-specific tcc_constant or
tcc_exceptional nodes. Since it is called from make_node, the
- only information available is the tree code. Expected to abort
+ only information available is the tree code. Expected to die
on unrecognized codes. */
size_t (*tree_size) (enum tree_code);
comparison or emitting a library call to perform the comparison if no insn
is available to handle it.
The values which are passed in through pointers can be modified; the caller
- should perform the comparison on the modified values. */
+ should perform the comparison on the modified values. Constant
+ comparisons must have already been folded. */
static void
prepare_cmp_insn (rtx *px, rtx *py, enum rtx_code *pcomparison, rtx size,
class = GET_MODE_CLASS (mode);
- /* They could both be VOIDmode if both args are immediate constants,
- but we should fold that at an earlier stage.
- With no special code here, this will call abort,
- reminding the programmer to implement such folding. */
-
if (mode != BLKmode && flag_force_mem)
{
/* Load duplicate non-volatile operands once. */
y = force_reg (mode, y);
#ifdef HAVE_cc0
- /* Abort if we have a non-canonical comparison. The RTL documentation
- states that canonical comparisons are required only for targets which
- have cc0. */
+ /* Make sure if we have a canonical comparison. The RTL
+ documentation states that canonical comparisons are required only
+ for targets which have cc0. */
gcc_assert (!CONSTANT_P (x) || CONSTANT_P (y));
#endif
}
#ifdef HAVE_cc0
- /* If OP0 is still a constant, then both X and Y must be constants. Force
- X into a register to avoid aborting in emit_cmp_insn due to non-canonical
- RTL. */
+ /* If OP0 is still a constant, then both X and Y must be constants.
+ Force X into a register to create canonical RTL. */
if (CONSTANT_P (op0))
op0 = force_reg (mode, op0);
#endif
default:
/* If the flag was handled in a standard way, assume the lack of
processing here is intentional. */
- if (cl_options[scode].flag_var)
- break;
-
- abort ();
+ gcc_assert (cl_options[scode].flag_var);
+ break;
}
return 1;
/* 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. If FORCE is nonzero the constant must
+ be outputable. */
extern bool assemble_integer (rtx, unsigned, unsigned, int);
/* An interface to assemble_integer for the common case in which a value is
extern rtx current_output_insn;
/* Nonzero while outputting an `asm' with operands.
- This means that inconsistencies are the user's fault, so don't abort.
+ This means that inconsistencies are the user's fault, so don't die.
The precise value is the insn being output, to pass to error_for_asm. */
extern rtx this_is_asm_operands;
break;
default:
- if (!pp_format_decoder (pp) || !(*pp_format_decoder (pp)) (pp, text))
- {
- /* Hmmm. The client failed to install a format translator
- but called us with an unrecognized format. Or, maybe, the
- translated string just contains an invalid format, or
- has formats in the wrong order. Sorry. */
- abort ();
- }
+ {
+ bool ok;
+
+ gcc_assert (pp_format_decoder (pp));
+ ok = pp_format_decoder (pp) (pp, text);
+ gcc_assert (ok);
+ }
}
if (quoted)
pp_string (pp, close_quote);
break;
default:
- fprintf (stderr,
- "switch format wrong in rtl.print_rtx(). format was: %c.\n",
- format_ptr[-1]);
- abort ();
+ gcc_unreachable ();
}
switch (GET_CODE (in_rtx))
/* The current line number for the file. */
int read_rtx_lineno = 1;
-/* The filename for aborting with file and line. */
+/* The filename for error reporting. */
const char *read_rtx_filename = "<unknown>";
static void
break;
default:
- fprintf (stderr,
- "switch format wrong in rtl.read_rtx(). format was: %c.\n",
- format_ptr[i]);
- fprintf (stderr, "\tfile position: %ld\n", ftell (infile));
- abort ();
+ gcc_unreachable ();
}
c = read_skip_spaces (infile);
/* If there is a REG_DEAD note on this insn, we must
change this not to REG_UNUSED meaning that the register
is set, but the value is dead. Failure to do so will
- result in a sched1 abort -- when it recomputes lifetime
+ result in a sched1 dieing -- when it recomputes lifetime
information, the number of REG_DEAD notes will have
changed. */
rtx note = find_reg_note (insn, REG_DEAD, reg);
/* Find the largest class which has at least one register valid in
mode INNER, and which for every such register, that register number
plus N is also valid in OUTER (if in range) and is cheap to move
- into REGNO. Abort if no such class exists. */
+ into REGNO. Such a class must exist. */
static enum reg_class
find_valid_class (enum machine_mode outer ATTRIBUTE_UNUSED,
if (code == SUBREG && REG_P (SUBREG_REG (x)))
{
- /* Check for SUBREG containing a REG that's equivalent to a constant.
- If the constant has a known value, truncate it right now.
- Similarly if we are extracting a single-word of a multi-word
- constant. If the constant is symbolic, allow it to be substituted
- normally. push_reload will strip the subreg later. If the
- constant is VOIDmode, abort because we will lose the mode of
- the register (this should never happen because one of the cases
- above should handle it). */
+ /* Check for SUBREG containing a REG that's equivalent to a
+ constant. If the constant has a known value, truncate it
+ right now. Similarly if we are extracting a single-word of a
+ multi-word constant. If the constant is symbolic, allow it
+ to be substituted normally. push_reload will strip the
+ subreg later. The constant must not be VOIDmode, because we
+ will lose the mode of the register (this should never happen
+ because one of the cases above should handle it). */
int regno = REGNO (SUBREG_REG (x));
rtx tem;
different from what they were when calculating the need for
spills. If we notice an input-reload insn here, we will
reject it below, but it might hide a usable equivalent.
- That makes bad code. It may even abort: perhaps no reg was
+ That makes bad code. It may even fail: perhaps no reg was
spilled for this insn because it was assumed we would find
that equivalent. */
|| INSN_UID (p) < reload_first_uid))
CLEAR_REGNO_REG_SET (bb->global_live_at_start,
HARD_FRAME_POINTER_REGNUM);
- /* Come here (with failure set nonzero) if we can't get enough spill regs
- and we decide not to abort about it. */
+ /* Come here (with failure set nonzero) if we can't get enough spill
+ regs. */
failed:
CLEAR_REG_SET (&spilled_pseudos);
unsigned int nr;
/* note_stores does give us subregs of hard regs,
- subreg_regno_offset will abort if it is not a hard reg. */
+ subreg_regno_offset requires a hard reg. */
while (GET_CODE (x) == SUBREG)
{
/* We ignore the subreg offset when calculating the regno,
}
/* Return nonzero if the rtx X is invariant over the current function. */
-/* ??? Actually, the places where we use this expect exactly what
- * is tested here, and not everything that is function invariant. In
- * particular, the frame pointer and arg pointer are special cased;
- * pic_offset_table_rtx is not, and this will cause aborts when we
- * go to spill these things to memory. */
+/* ??? Actually, the places where we use this expect exactly what is
+ tested here, and not everything that is function invariant. In
+ particular, the frame pointer and arg pointer are special cased;
+ pic_offset_table_rtx is not, and we must not spill these things to
+ memory. */
static int
function_invariant_p (rtx x)
|| rld[j].when_needed == RELOAD_FOR_INPADDR_ADDRESS)
? RELOAD_FOR_OTHER_ADDRESS : RELOAD_OTHER);
- /* Check to see if we accidentally converted two reloads
- that use the same reload register with different inputs
- to the same type. If so, the resulting code won't work,
- so abort. */
+ /* Check to see if we accidentally converted two
+ reloads that use the same reload register with
+ different inputs to the same type. If so, the
+ resulting code won't work. */
if (rld[j].reg_rtx)
for (k = 0; k < j; k++)
gcc_assert (rld[k].in == 0 || rld[k].reg_rtx == 0
static inline void
relink_imm_use (ssa_imm_use_t *node, ssa_imm_use_t *old)
{
-#ifdef ENABLE_CHECKING
/* The node one had better be in the same list. */
- if (*(old->use) != *(node->use))
- abort ();
-#endif
+ gcc_assert (*(old->use) == *(node->use));
node->prev = old->prev;
node->next = old->next;
if (old->prev)
/* Remove the old node from the list. */
old->prev = NULL;
}
-
}
/* Relink ssa_imm_use node LINKNODE into the chain for OLD, with use occuring
UNION_TYPE nodes, then it goes into infinite recursion on a
structure containing a pointer to its own type. If it doesn't,
then the type node for S doesn't get adjusted properly when
- F is inlined, and we abort in find_function_data.
+ F is inlined.
??? This is likely no longer true, but it's too late in the 4.0
cycle to try to find out. This should be checked for 4.1. */
break;
}
default:
- /* Abort here se we know we don't miss any nodes. */
gcc_unreachable ();
}
return NULL;
print_rtl (dump_file, get_insns ());
/* Flush the file. If verification fails, we won't be able to
- close the file before aborting. */
+ close the file before dieing. */
fflush (dump_file);
}
if ((flags & TODO_dump_cgraph)
gcc_assert (VARRAY_ACTIVE_SIZE (g->const_copies) == 0);
- /* Abnormal edges already have everything coalesced, or the coalescer
- would have aborted. */
+ /* Abnormal edges already have everything coalesced. */
if (e->flags & EDGE_ABNORMAL)
return;
}
/* Neither operand is a pointer? VAR can be pointing anywhere.
- FIXME: Shouldn't we abort here? If we get here, we found
+ FIXME: Shouldn't we asserting here? If we get here, we found
PTR = INT_CST + INT_CST, which should not be a valid pointer
expression. */
if (!(POINTER_TYPE_P (TREE_TYPE (op0))
&& TREE_CODE (TREE_OPERAND (t, 0)) == STRING_CST)
{
/* FIXME: Except that this causes problems elsewhere with dead
- code not being deleted, and we abort in the rtl expanders
+ code not being deleted, and we die in the rtl expanders
because we failed to remove some ssa_name. In the meantime,
just return zero. */
/* FIXME2: This condition should be signaled by
default:
/* Notice that if get_expr_operands tries to use &STMT as the operand
- pointer (which may only happen for USE operands), we will abort in
+ pointer (which may only happen for USE operands), we will fail in
append_use. This default will handle statements like empty
statements, or CALL_EXPRs that may appear on the RHS of a statement
or as statements themselves. */
/* Everything else *should* have been folded elsewhere, but users
are smarter than we in finding ways to write invalid code. We
- cannot just abort here. If we were absolutely certain that we
+ cannot just assert here. If we were absolutely certain that we
do handle all valid cases, then we could just do nothing here.
That seems optimistic, so attempt to do something logical... */
else if ((TREE_CODE (ptr) == PLUS_EXPR || TREE_CODE (ptr) == MINUS_EXPR)
ann->operands.vuse_ops = finalize_ssa_vuses (&(tmp.vuse_ops), NULL);
}
-
-
-/* Issue immediate use error for VAR to debug file F. */
-static void
-verify_abort (FILE *f, ssa_imm_use_t *var)
-{
- tree stmt;
- stmt = var->stmt;
- if (stmt)
- {
- if (stmt_modified_p(stmt))
- {
- fprintf (f, " STMT MODIFIED. - <%p> ", (void *)stmt);
- print_generic_stmt (f, stmt, TDF_SLIM);
- }
- }
- fprintf (f, " IMM ERROR : (use_p : tree - %p:%p)", (void *)var,
- (void *)var->use);
- print_generic_expr (f, USE_FROM_PTR (var), TDF_SLIM);
- fprintf(f, "\n");
-}
-
-
/* Scan the immediate_use list for VAR making sure its linked properly.
return RTUE iof there is a problem. */
for (ptr = list->next; ptr != list; )
{
if (prev != ptr->prev)
- {
- verify_abort (f, ptr);
- return true;
- }
-
+ goto error;
+
if (ptr->use == NULL)
- {
- verify_abort (f, ptr); /* 2 roots, or SAFE guard node. */
- return true;
- }
- else
- if (*(ptr->use) != var)
- {
- verify_abort (f, ptr);
- return true;
- }
+ goto error; /* 2 roots, or SAFE guard node. */
+ else if (*(ptr->use) != var)
+ goto error;
prev = ptr;
ptr = ptr->next;
/* Avoid infinite loops. */
if (count++ > 30000)
- {
- verify_abort (f, ptr);
- return true;
- }
+ goto error;
}
/* Verify list in the other direction. */
for (ptr = list->prev; ptr != list; )
{
if (prev != ptr->next)
- {
- verify_abort (f, ptr);
- return true;
- }
+ goto error;
prev = ptr;
ptr = ptr->prev;
if (count-- < 0)
- {
- verify_abort (f, ptr);
- return true;
- }
+ goto error;
}
if (count != 0)
- {
- verify_abort (f, ptr);
- return true;
- }
+ goto error;
return false;
+
+ error:
+ if (ptr->stmt && stmt_modified_p (ptr->stmt))
+ {
+ fprintf (f, " STMT MODIFIED. - <%p> ", (void *)ptr->stmt);
+ print_generic_stmt (f, ptr->stmt, TDF_SLIM);
+ }
+ fprintf (f, " IMM ERROR : (use_p : tree - %p:%p)", (void *)ptr,
+ (void *)ptr->use);
+ print_generic_expr (f, USE_FROM_PTR (ptr), TDF_SLIM);
+ fprintf(f, "\n");
+ return true;
}
{
tree genop = bitmap_find_leader (AVAIL_OUT (block), expr);
- /* If it's still NULL, see if it is a complex expression, and if
- so, generate it recursively, otherwise, abort, because it's
- not really . */
+ /* If it's still NULL, it must be a complex expression, so generate
+ it recursively. */
if (genop == NULL)
{
genop = VALUE_HANDLE_EXPR_SET (expr)->head->expr;
EXPR is the expression to insert (in value form)
STMTS is a statement list to append the necessary insertions into.
- This function will abort if we hit some value that shouldn't be
+ This function will die if we hit some value that shouldn't be
ANTIC but is (IE there is no leader for it, or its components).
This function may also generate expressions that are themselves
partially or fully redundant. Those that are will be either made
/* Generic routines for manipulating SSA_NAME expressions
Copyright (C) 2003, 2004, 2005 Free Software Foundation, Inc.
-
+
This file is part of GCC.
-
+
GCC is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
-
+
GCC is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
-
+
You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING. If not, write to
the Free Software Foundation, 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
-
+
#include "config.h"
#include "system.h"
#include "coretypes.h"
verify_imm_links (stderr, var);
#endif
while (imm->next != imm)
- {
- delink_imm_use (imm->next);
- }
-#ifdef ENABLE_CHECKING
- if (imm->next != imm)
- abort();
-#endif
+ delink_imm_use (imm->next);
VARRAY_TREE (ssa_names, SSA_NAME_VERSION (var)) = NULL;
memset (var, 0, tree_size (var));
DECL_FIELD_BIT_OFFSET (field));
}
-/* Likewise, but return as an integer. Abort if it cannot be represented
- in that way (since it could be a signed value, we don't have the option
- of returning -1 like int_size_in_byte can. */
+/* Likewise, but return as an integer. It must be representable in
+ that way (since it could be a signed value, we don't have the
+ option of returning -1 like int_size_in_byte can. */
HOST_WIDE_INT
int_bit_position (tree field)
DECL_FIELD_BIT_OFFSET (field));
}
-/* Likewise, but return as an integer. Abort if it cannot be represented
- in that way (since it could be a signed value, we don't have the option
- of returning -1 like int_size_in_byte can. */
+/* Likewise, but return as an integer. It must be representable in
+ that way (since it could be a signed value, we don't have the
+ option of returning -1 like int_size_in_byte can. */
HOST_WIDE_INT
int_byte_position (tree field)
/* Return the HOST_WIDE_INT least significant bits of T if it is an
INTEGER_CST and there is no overflow. POS is nonzero if the result must
- be positive. Abort if we cannot satisfy the above conditions. */
+ be positive. We must be able to satisfy the above conditions. */
HOST_WIDE_INT
tree_low_cst (tree t, int pos)
/* Apply FUNC to all the sub-trees of TP in a pre-order traversal. FUNC is
called with the DATA and the address of each sub-tree. If FUNC returns a
- non-NULL value, the traversal is aborted, and the value returned by FUNC
+ non-NULL value, the traversal is stopped, and the value returned by FUNC
is returned. If PSET is non-NULL it is used to record the nodes visited,
and to avoid visiting a node more than once. */
#define TREE_SET_CODE(NODE, VALUE) ((NODE)->common.code = (VALUE))
/* When checking is enabled, errors will be generated if a tree node
- is accessed incorrectly. The macros abort with a fatal error. */
+ is accessed incorrectly. The macros die with a fatal error. */
#if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
#define TREE_CHECK(T, CODE) __extension__ \
Each operation that increases the number of active elements is
available in 'quick' and 'safe' variants. The former presumes that
there is sufficient allocated space for the operation to succeed
- (it aborts if there is not). The latter will reallocate the
+ (it dies if there is not). The latter will reallocate the
vector, if needed. Reallocation causes an exponential increase in
vector size. If you know you will be adding N elements, it would
be more efficient to use the reserve operation before adding the
T VEC_T_last(VEC(T) *v); // Pointer
T *VEC_T_last(VEC(T) *v); // Object
- Return the final element. If V is empty, abort. */
+ Return the final element. V must not be empty. */
#define VEC_last(T,V) (VEC_OP(T,base,last)(VEC_BASE(V) VEC_CHECK_INFO))
T VEC_T_index(VEC(T) *v, unsigned ix); // Pointer
T *VEC_T_index(VEC(T) *v, unsigned ix); // Object
- Return the IX'th element. If IX is outside the domain of V,
- abort. */
+ Return the IX'th element. If IX must be in the domain of V. */
#define VEC_index(T,V,I) (VEC_OP(T,base,index)(VEC_BASE(V),I VEC_CHECK_INFO))
Push a new element onto the end, returns a pointer to the slot
filled in. For object vectors, the new value can be NULL, in which
- case NO initialization is performed. Aborts if there is
- insufficient space in the vector. */
+ case NO initialization is performed. There must
+ be sufficient space in the vector. */
#define VEC_quick_push(T,V,O) \
(VEC_OP(T,base,quick_push)(VEC_BASE(V),O VEC_CHECK_INFO))
Insert an element, VAL, at the IXth position of V. Return a pointer
to the slot created. For vectors of object, the new value can be
NULL, in which case no initialization of the inserted slot takes
- place. Aborts if there is insufficient space. */
+ place. There must be sufficient space. */
#define VEC_quick_insert(T,V,I,O) \
(VEC_OP(T,base,quick_insert)(VEC_BASE(V),I,O VEC_CHECK_INFO))
OSDN Git Service
