#include "expr.h"
#include "libfuncs.h"
#include "hard-reg-set.h"
-#include "loop.h"
#include "recog.h"
#include "machmode.h"
#include "toplev.h"
rtx
label_rtx (tree label)
{
- if (TREE_CODE (label) != LABEL_DECL)
- abort ();
+ gcc_assert (TREE_CODE (label) == LABEL_DECL);
if (!DECL_RTL_SET_P (label))
{
tree function = decl_function_context (label);
struct function *p;
- if (!function)
- abort ();
+ gcc_assert (function);
if (function != current_function_decl)
p = find_function_data (function);
/* 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 ();
+ gcc_assert (!context || context == current_function_decl);
#endif
emit_jump (label_rtx (label));
if (TREE_CODE (string) == ADDR_EXPR)
string = TREE_OPERAND (string, 0);
- body = gen_rtx_ASM_INPUT (VOIDmode, TREE_STRING_POINTER (string));
+ body = gen_rtx_ASM_INPUT (VOIDmode,
+ ggc_strdup (TREE_STRING_POINTER (string)));
MEM_VOLATILE_P (body) = vol;
message. */
if (!p)
{
- error ("output operand constraint lacks `='");
+ error ("output operand constraint lacks %<=%>");
return false;
}
size_t c_len = strlen (constraint);
if (p != constraint)
- warning ("output constraint `%c' for operand %d is not at the beginning",
+ warning ("output constraint %qc for operand %d "
+ "is not at the beginning",
*p, operand_num);
/* Make a copy of the constraint. */
{
case '+':
case '=':
- error ("operand constraint contains incorrectly positioned '+' or '='");
+ error ("operand constraint contains incorrectly positioned "
+ "%<+%> or %<=%>");
return false;
case '%':
if (operand_num + 1 == ninputs + noutputs)
{
- error ("`%%' constraint used with last operand");
+ error ("%<%%%> constraint used with last operand");
return false;
}
break;
case '+': case '=': case '&':
if (constraint == orig_constraint)
{
- error ("input operand constraint contains `%c'", constraint[j]);
+ error ("input operand constraint contains %qc", constraint[j]);
return false;
}
break;
if (constraint == orig_constraint
&& input_num + 1 == ninputs - ninout)
{
- error ("`%%' constraint used with last operand");
+ error ("%<%%%> constraint used with last operand");
return false;
}
break;
default:
if (! ISALPHA (constraint[j]))
{
- error ("invalid punctuation `%c' in constraint", constraint[j]);
+ error ("invalid punctuation %qc in constraint", constraint[j]);
return false;
}
if (REG_CLASS_FROM_CONSTRAINT (constraint[j], constraint + j)
regno++)
if (TEST_HARD_REG_BIT (clobbered_regs, regno))
{
- error ("asm-specifier for variable `%s' conflicts with asm clobber list",
+ error ("asm-specifier for variable %qs conflicts with "
+ "asm clobber list",
IDENTIFIER_POINTER (DECL_NAME (decl)));
/* Reset registerness to stop multiple errors emitted for a
if (i >= 0 || i == -4)
++nclobbers;
else if (i == -2)
- error ("unknown register name `%s' in `asm'", regname);
+ error ("unknown register name %qs in %<asm%>", regname);
/* Mark clobbered registers. */
if (i >= 0)
/* Clobbering the PIC register is an error */
if (i == (int) PIC_OFFSET_TABLE_REGNUM)
{
- error ("PIC register `%s' clobbered in `asm'", regname);
+ error ("PIC register %qs clobbered in %<asm%>", regname);
return;
}
ninputs += ninout;
if (ninputs + noutputs > MAX_RECOG_OPERANDS)
{
- error ("more than %d operands in `asm'", MAX_RECOG_OPERANDS);
+ error ("more than %d operands in %<asm%>", MAX_RECOG_OPERANDS);
return;
}
bool allows_reg;
bool allows_mem;
rtx op;
+ bool ok;
- if (!parse_output_constraint (&constraints[i], i, ninputs,
+ ok = parse_output_constraint (&constraints[i], i, ninputs,
noutputs, &allows_mem, &allows_reg,
- &is_inout))
- abort ();
+ &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.
body = gen_rtx_ASM_OPERANDS ((noutputs == 0 ? VOIDmode
: GET_MODE (output_rtx[0])),
- TREE_STRING_POINTER (string),
+ ggc_strdup (TREE_STRING_POINTER (string)),
empty_string, 0, argvec, constraintvec,
locus);
const char *constraint;
tree val, type;
rtx op;
+ bool ok;
constraint = constraints[i + noutputs];
- if (! parse_input_constraint (&constraint, i, ninputs, noutputs, ninout,
- constraints, &allows_mem, &allows_reg))
- abort ();
+ ok = parse_input_constraint (&constraint, i, ninputs, noutputs, ninout,
+ constraints, &allows_mem, &allows_reg);
+ gcc_assert (ok);
generating_concat_p = 0;
if (allows_reg)
op = force_reg (TYPE_MODE (type), op);
else if (!allows_mem)
- warning ("asm operand %d probably doesn't match constraints",
+ warning ("asm operand %d probably doesn%'t match constraints",
i + noutputs);
else if (MEM_P (op))
{
ASM_OPERANDS_INPUT (body, i) = op;
ASM_OPERANDS_INPUT_CONSTRAINT_EXP (body, i)
- = gen_rtx_ASM_INPUT (TYPE_MODE (type), constraints[i + noutputs]);
+ = gen_rtx_ASM_INPUT (TYPE_MODE (type),
+ ggc_strdup (constraints[i + noutputs]));
if (decl_conflicts_with_clobbers_p (val, clobbered_regs))
clobber_conflict_found = 1;
if (noutputs == 1 && nclobbers == 0)
{
- ASM_OPERANDS_OUTPUT_CONSTRAINT (body) = constraints[0];
+ ASM_OPERANDS_OUTPUT_CONSTRAINT (body) = ggc_strdup (constraints[0]);
emit_insn (gen_rtx_SET (VOIDmode, output_rtx[0], body));
}
output_rtx[i],
gen_rtx_ASM_OPERANDS
(GET_MODE (output_rtx[i]),
- TREE_STRING_POINTER (string),
- constraints[i], i, argvec, constraintvec,
- locus));
+ ggc_strdup (TREE_STRING_POINTER (string)),
+ ggc_strdup (constraints[i]),
+ i, argvec, constraintvec, locus));
MEM_VOLATILE_P (SET_SRC (XVECEXP (body, 0, i))) = vol;
}
if (nalternatives + 1 > MAX_RECOG_ALTERNATIVES)
{
- error ("too many alternatives in `asm'");
+ error ("too many alternatives in %<asm%>");
return false;
}
if (n_occurrences (',', constraint) != nalternatives)
{
- error ("operand constraints for `asm' differ in number of alternatives");
+ error ("operand constraints for %<asm%> differ "
+ "in number of alternatives");
return false;
}
return true;
failure:
- error ("duplicate asm operand name '%s'",
+ error ("duplicate asm operand name %qs",
TREE_STRING_POINTER (TREE_PURPOSE (TREE_PURPOSE (i))));
return false;
}
}
*q = '\0';
- error ("undefined named operand '%s'", p + 1);
+ error ("undefined named operand %qs", p + 1);
op = 0;
found:
p = strchr (p, '\0');
/* Verify the no extra buffer space assumption. */
- if (p > q)
- abort ();
+ gcc_assert (p <= q);
/* Shift the rest of the buffer down to fill the gap. */
memmove (p, q + 1, strlen (q + 1) + 1);
default:
/* Referencing a volatile value is a side effect, so don't warn. */
- if ((DECL_P (exp)
- || TREE_CODE_CLASS (TREE_CODE (exp)) == 'r')
+ if ((DECL_P (exp) || REFERENCE_CLASS_P (exp))
&& TREE_THIS_VOLATILE (exp))
return 0;
/* If this is an expression which has no operands, there is no value
to be unused. There are no such language-independent codes,
but front ends may define such. */
- if (TREE_CODE_CLASS (TREE_CODE (exp)) == 'e'
- && TREE_CODE_LENGTH (TREE_CODE (exp)) == 0)
+ if (EXPRESSION_CLASS_P (exp) && TREE_CODE_LENGTH (TREE_CODE (exp)) == 0)
return 0;
maybe_warn:
if (shift > 0)
val = expand_shift (LSHIFT_EXPR, GET_MODE (target),
gen_lowpart (GET_MODE (target), val),
- build_int_cst (NULL_TREE, shift, 0), target, 1);
+ build_int_cst (NULL_TREE, shift), target, 1);
}
return val;
}
if (GET_MODE_SIZE (tmpmode) >= bytes)
break;
- /* No suitable mode found. */
- if (tmpmode == VOIDmode)
- abort ();
+ /* A suitable mode should have been found. */
+ gcc_assert (tmpmode != VOIDmode);
PUT_MODE (result_rtl, tmpmode);
}
mark_reg_pointer (DECL_RTL (decl),
TYPE_ALIGN (TREE_TYPE (TREE_TYPE (decl))));
}
-
- maybe_set_unchanging (DECL_RTL (decl), decl);
}
else if (TREE_CODE (DECL_SIZE_UNIT (decl)) == INTEGER_CST
to the proper address. */
if (DECL_RTL_SET_P (decl))
{
- if (!MEM_P (DECL_RTL (decl))
- || !REG_P (XEXP (DECL_RTL (decl), 0)))
- abort ();
+ gcc_assert (MEM_P (DECL_RTL (decl)));
+ gcc_assert (REG_P (XEXP (DECL_RTL (decl), 0)));
oldaddr = XEXP (DECL_RTL (decl), 0);
}
{
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. */
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))
+ 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
{
- if (mode == GET_MODE (x))
- SET_DECL_RTL (decl_elt, x);
- else
- SET_DECL_RTL (decl_elt, gen_lowpart_SUBREG (mode, x));
+ gcc_assert (REG_P (x));
+ decl_rtl = gen_lowpart_SUBREG (mode, x);
}
- else
- abort ();
+ SET_DECL_RTL (decl_elt, decl_rtl);
}
}
\f
if (i == count)
{
- if (count >= MAX_CASE_BIT_TESTS)
- abort ();
- test[i].hi = 0;
- test[i].lo = 0;
+ gcc_assert (count < MAX_CASE_BIT_TESTS);
+ test[i].hi = 0;
+ test[i].lo = 0;
test[i].label = label;
test[i].bits = 1;
count++;
/* 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 ();
+ gcc_assert (!SWITCH_BODY (exp));
+ gcc_assert (SWITCH_LABELS (exp));
for (i = TREE_VEC_LENGTH (vec); --i >= 0; )
{
/* 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);
+ 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));
+ CASE_LABEL (elt));
}
do_pending_stack_adjust ();
/* 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)
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 ();
+ 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);
if (TREE_CODE (index_expr) != INTEGER_CST)
{
index_expr
- = build_int_cst (NULL_TREE, INTVAL (index),
- unsignedp || INTVAL (index) >= 0 ? 0 : -1);
+ = build_int_cst_wide (NULL_TREE, INTVAL (index),
+ unsignedp || INTVAL (index) >= 0
+ ? 0 : -1);
index_expr = convert (index_type, index_expr);
}
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
range = maxval;
}
- if (! try_tablejump (index_type, index_expr, minval, range,
- table_label, default_label))
- abort ();
+ 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. */
before_case = NEXT_INSN (before_case);
end = get_last_insn ();
- if (squeeze_notes (&before_case, &end))
- abort ();
+ fail = squeeze_notes (&before_case, &end);
+ gcc_assert (!fail);
reorder_insns (before_case, end, start);
}
{
tree min_ascii = integer_minus_one_node;
tree max_ascii = convert (TREE_TYPE (node->high),
- build_int_cst (NULL_TREE, 127, 0));
+ build_int_cst (NULL_TREE, 127));
case_node_ptr n;
int i;