/* XXX Maybe print the vector? */
void
rtvec_check_failed_bounds (const_rtvec r, int n, const char *file, int line,
const char *func)
{
internal_error
("RTL check: access of elt %d of vector with last elt %d in %s, at %s:%d",
n, GET_NUM_ELEM (r) - 1, func, trim_filename (file), line);
}
rtvec
shallow_copy_rtvec (rtvec vec)
{
rtvec newvec;
int n;
n = GET_NUM_ELEM (vec);
newvec = rtvec_alloc (n);
memcpy (&newvec->elem[0], &vec->elem[0], sizeof (rtx) * n);
return newvec;
}
bool
rtvec_all_equal_p (const_rtvec vec)
{
const_rtx first = RTVEC_ELT (vec, 0);
/* Optimize the important special case of a vector of constants.
The main use of this function is to detect whether every element
of CONST_VECTOR is the same. */
switch (GET_CODE (first))
{
CASE_CONST_UNIQUE:
for (int i = 1, n = GET_NUM_ELEM (vec); i < n; ++i)
if (first != RTVEC_ELT (vec, i))
return false;
return true;
default:
for (int i = 1, n = GET_NUM_ELEM (vec); i < n; ++i)
if (!rtx_equal_p (first, RTVEC_ELT (vec, i)))
return false;
return true;
}
}
static void
gen_emit_seq (rtvec vec, char *used)
{
for (int i = 0, len = GET_NUM_ELEM (vec); i < len; ++i)
{
bool last_p = (i == len - 1);
rtx next = RTVEC_ELT (vec, i);
if (const char *name = get_emit_function (next))
{
printf (" %s (", name);
gen_exp (next, DEFINE_EXPAND, used);
printf (");\n");
if (!last_p && needs_barrier_p (next))
printf (" emit_barrier ();");
}
else
{
printf (" emit (");
gen_exp (next, DEFINE_EXPAND, used);
printf (", %s);\n", last_p ? "false" : "true");
}
}
}
static int
is_predicable (struct queue_elem *elem)
{
rtvec vec = XVEC (elem->data, 4);
const char *value;
int i;
if (! vec)
return predicable_default;
for (i = GET_NUM_ELEM (vec) - 1; i >= 0; --i)
{
rtx sub = RTVEC_ELT (vec, i);
switch (GET_CODE (sub))
{
case SET_ATTR:
if (strcmp (XSTR (sub, 0), "predicable") == 0)
{
value = XSTR (sub, 1);
goto found;
}
break;
case SET_ATTR_ALTERNATIVE:
if (strcmp (XSTR (sub, 0), "predicable") == 0)
{
message_with_line (elem->lineno,
"multiple alternatives for `predicable'");
errors = 1;
return 0;
}
break;
case SET:
if (GET_CODE (SET_DEST (sub)) != ATTR
|| strcmp (XSTR (SET_DEST (sub), 0), "predicable") != 0)
break;
sub = SET_SRC (sub);
if (GET_CODE (sub) == CONST_STRING)
{
value = XSTR (sub, 0);
goto found;
}
/* ??? It would be possible to handle this if we really tried.
It's not easy though, and I'm not going to bother until it
really proves necessary. */
message_with_line (elem->lineno,
"non-constant value for `predicable'");
errors = 1;
return 0;
default:
gcc_unreachable ();
}
}
return predicable_default;
found:
/* Verify that predicability does not vary on the alternative. */
/* ??? It should be possible to handle this by simply eliminating
the non-predicable alternatives from the insn. FRV would like
to do this. Delay this until we've got the basics solid. */
if (strchr (value, ',') != NULL)
{
message_with_line (elem->lineno,
"multiple alternatives for `predicable'");
errors = 1;
return 0;
}
/* Find out which value we're looking at. */
if (strcmp (value, predicable_true) == 0)
return 1;
if (strcmp (value, predicable_false) == 0)
return 0;
message_with_line (elem->lineno,
"unknown value `%s' for `predicable' attribute",
value);
errors = 1;
return 0;
}
