/* Generate code from machine description to compute values of attributes.
- Copyright (C) 1991-2014 Free Software Foundation, Inc.
+ Copyright (C) 1991-2020 Free Software Foundation, Inc.
Contributed by Richard Kenner (kenner@vlsi1.ultra.nyu.edu)
This file is part of GCC.
`struct insn_def'. This is done to allow attribute definitions to occur
anywhere in the file. */
-struct insn_def
+class insn_def
{
- struct insn_def *next; /* Next insn in chain. */
+public:
+ class insn_def *next; /* Next insn in chain. */
rtx def; /* The DEFINE_... */
int insn_code; /* Instruction number. */
int insn_index; /* Expression number in file, for errors. */
- int lineno; /* Line number. */
+ file_location loc; /* Where in the .md files it occurs. */
int num_alternatives; /* Number of alternatives. */
int vec_idx; /* Index of attribute vector in `def'. */
};
struct insn_ent
{
struct insn_ent *next; /* Next in chain. */
- struct insn_def *def; /* Instruction definition. */
+ class insn_def *def; /* Instruction definition. */
};
/* Each value of an attribute (either constant or computed) is assigned a
/* Structure for each attribute. */
-struct attr_desc
+class attr_desc
{
+public:
char *name; /* Name of attribute. */
const char *enum_name; /* Enum name for DEFINE_ENUM_NAME. */
- struct attr_desc *next; /* Next attribute. */
+ class attr_desc *next; /* Next attribute. */
struct attr_value *first_value; /* First value of this attribute. */
struct attr_value *default_val; /* Default value for this attribute. */
- int lineno : 24; /* Line number. */
+ file_location loc; /* Where in the .md files it occurs. */
unsigned is_numeric : 1; /* Values of this attribute are numeric. */
unsigned is_const : 1; /* Attribute value constant for each run. */
unsigned is_special : 1; /* Don't call `write_attr_set'. */
/* Structure for each DEFINE_DELAY. */
-struct delay_desc
+class delay_desc
{
+public:
rtx def; /* DEFINE_DELAY expression. */
- struct delay_desc *next; /* Next DEFINE_DELAY. */
+ class delay_desc *next; /* Next DEFINE_DELAY. */
+ file_location loc; /* Where in the .md files it occurs. */
int num; /* Number of DEFINE_DELAY, starting at 1. */
- int lineno; /* Line number. */
};
struct attr_value_list
{
struct attr_value *av;
struct insn_ent *ie;
- struct attr_desc *attr;
+ class attr_desc *attr;
struct attr_value_list *next;
};
/* This one is indexed by the first character of the attribute name. */
#define MAX_ATTRS_INDEX 256
-static struct attr_desc *attrs[MAX_ATTRS_INDEX];
-static struct insn_def *defs;
-static struct delay_desc *delays;
+static class attr_desc *attrs[MAX_ATTRS_INDEX];
+static class insn_def *defs;
+static class delay_desc *delays;
struct attr_value_list **insn_code_values;
/* Other variables. */
-static int insn_code_number;
static int insn_index_number;
static int got_define_asm_attributes;
static int must_extract;
/* Stores, for each insn code, a bitmap that has bits on for each possible
alternative. */
-static int *insn_alternatives;
+/* Keep this in sync with recog.h. */
+typedef uint64_t alternative_mask;
+static alternative_mask *insn_alternatives;
/* Used to simplify expressions. */
static char *attr_printf (unsigned int, const char *, ...)
ATTRIBUTE_PRINTF_2;
static rtx make_numeric_value (int);
-static struct attr_desc *find_attr (const char **, int);
-static rtx mk_attr_alt (int);
+static class attr_desc *find_attr (const char **, int);
+static rtx mk_attr_alt (alternative_mask);
static char *next_comma_elt (const char **);
static rtx insert_right_side (enum rtx_code, rtx, rtx, int, int);
static rtx copy_boolean (rtx);
static void make_internal_attr (const char *, rtx, int);
static void insert_insn_ent (struct attr_value *, struct insn_ent *);
static void walk_attr_value (rtx);
-static int max_attr_value (rtx, int*);
-static int min_attr_value (rtx, int*);
-static int or_attr_value (rtx, int*);
+static int max_attr_value (rtx);
+static int min_attr_value (rtx);
+static unsigned int attr_value_alignment (rtx);
static rtx simplify_test_exp (rtx, int, int);
static rtx simplify_test_exp_in_temp (rtx, int, int);
static rtx copy_rtx_unchanging (rtx);
static bool attr_alt_subset_p (rtx, rtx);
static bool attr_alt_subset_of_compl_p (rtx, rtx);
static void clear_struct_flag (rtx);
-static void write_attr_valueq (FILE *, struct attr_desc *, const char *);
-static struct attr_value *find_most_used (struct attr_desc *);
-static void write_attr_set (FILE *, struct attr_desc *, int, rtx,
+static void write_attr_valueq (FILE *, class attr_desc *, const char *);
+static struct attr_value *find_most_used (class attr_desc *);
+static void write_attr_set (FILE *, class attr_desc *, int, rtx,
const char *, const char *, rtx,
int, int, unsigned int);
-static void write_attr_case (FILE *, struct attr_desc *,
+static void write_attr_case (FILE *, class attr_desc *,
struct attr_value *,
int, const char *, const char *, int, rtx);
-static void write_attr_value (FILE *, struct attr_desc *, rtx);
+static void write_attr_value (FILE *, class attr_desc *, rtx);
static void write_upcase (FILE *, const char *);
static void write_indent (FILE *, int);
static rtx identity_fn (rtx);
unsigned int hashcode;
struct attr_hash *h;
struct obstack *old_obstack = rtl_obstack;
+ int permanent_p = 1;
/* For each of several cases, search the hash table for an existing entry.
Use that entry if one is found; otherwise create a new RTL and add it
{
rtx arg0 = va_arg (p, rtx);
- /* A permanent object cannot point to impermanent ones. */
if (! ATTR_PERMANENT_P (arg0))
- {
- rt_val = rtx_alloc (code);
- XEXP (rt_val, 0) = arg0;
- return rt_val;
- }
+ permanent_p = 0;
hashcode = ((HOST_WIDE_INT) code + RTL_HASH (arg0));
for (h = attr_hash_table[hashcode % RTL_HASH_SIZE]; h; h = h->next)
rtx arg0 = va_arg (p, rtx);
rtx arg1 = va_arg (p, rtx);
- /* A permanent object cannot point to impermanent ones. */
if (! ATTR_PERMANENT_P (arg0) || ! ATTR_PERMANENT_P (arg1))
- {
- rt_val = rtx_alloc (code);
- XEXP (rt_val, 0) = arg0;
- XEXP (rt_val, 1) = arg1;
- return rt_val;
- }
+ permanent_p = 0;
hashcode = ((HOST_WIDE_INT) code + RTL_HASH (arg0) + RTL_HASH (arg1));
for (h = attr_hash_table[hashcode % RTL_HASH_SIZE]; h; h = h->next)
&& GET_CODE (h->u.rtl) == code
&& XEXP (h->u.rtl, 0) == arg0
&& XEXP (h->u.rtl, 1) == arg1)
- return h->u.rtl;
+ {
+ ATTR_CURR_SIMPLIFIED_P (h->u.rtl) = 0;
+ return h->u.rtl;
+ }
if (h == 0)
{
rt_val = rtx_alloc (code);
XSTR (rt_val, 0) = arg0;
if (code == SYMBOL_REF)
- {
- X0EXP (rt_val, 1) = NULL_RTX;
- X0EXP (rt_val, 2) = NULL_RTX;
- }
+ X0EXP (rt_val, 1) = NULL_RTX;
}
}
else if (GET_RTX_LENGTH (code) == 2
char *arg0 = va_arg (p, char *);
char *arg1 = va_arg (p, char *);
+ arg0 = DEF_ATTR_STRING (arg0);
+ arg1 = DEF_ATTR_STRING (arg1);
+
hashcode = ((HOST_WIDE_INT) code + RTL_HASH (arg0) + RTL_HASH (arg1));
for (h = attr_hash_table[hashcode % RTL_HASH_SIZE]; h; h = h->next)
if (h->hashcode == hashcode
XSTR (rt_val, 1) = arg1;
}
}
+ else if (GET_RTX_LENGTH (code) == 2
+ && GET_RTX_FORMAT (code)[0] == 'w'
+ && GET_RTX_FORMAT (code)[1] == 'w')
+ {
+ HOST_WIDE_INT arg0 = va_arg (p, HOST_WIDE_INT);
+ HOST_WIDE_INT arg1 = va_arg (p, HOST_WIDE_INT);
+
+ hashcode = ((HOST_WIDE_INT) code + RTL_HASH (arg0) + RTL_HASH (arg1));
+ for (h = attr_hash_table[hashcode % RTL_HASH_SIZE]; h; h = h->next)
+ if (h->hashcode == hashcode
+ && GET_CODE (h->u.rtl) == code
+ && XWINT (h->u.rtl, 0) == arg0
+ && XWINT (h->u.rtl, 1) == arg1)
+ return h->u.rtl;
+
+ if (h == 0)
+ {
+ rtl_obstack = hash_obstack;
+ rt_val = rtx_alloc (code);
+ XWINT (rt_val, 0) = arg0;
+ XWINT (rt_val, 1) = arg1;
+ }
+ }
else if (code == CONST_INT)
{
HOST_WIDE_INT arg0 = va_arg (p, HOST_WIDE_INT);
break;
default:
+ /* Don't need to handle 'p' for attributes. */
gcc_unreachable ();
}
}
rtl_obstack = old_obstack;
attr_hash_add_rtx (hashcode, rt_val);
- ATTR_PERMANENT_P (rt_val) = 1;
+ ATTR_PERMANENT_P (rt_val) = permanent_p;
return rt_val;
}
static rtx
attr_eq (const char *name, const char *value)
{
- return attr_rtx (EQ_ATTR, DEF_ATTR_STRING (name), DEF_ATTR_STRING (value));
+ return attr_rtx (EQ_ATTR, name, value);
}
static const char *
memcpy (new_str, str, len);
new_str[len] = '\0';
attr_hash_add_string (hashcode, new_str);
- copy_md_ptr_loc (new_str, str);
+ rtx_reader_ptr->copy_md_ptr_loc (new_str, str);
return new_str; /* Return the new string. */
}
&& rtx_equal_p (x, y)));
}
-/* Copy an attribute value expression,
- descending to all depths, but not copying any
- permanent hashed subexpressions. */
-
-static rtx
-attr_copy_rtx (rtx orig)
-{
- rtx copy;
- int i, j;
- RTX_CODE code;
- const char *format_ptr;
-
- /* No need to copy a permanent object. */
- if (ATTR_PERMANENT_P (orig))
- return orig;
-
- code = GET_CODE (orig);
-
- switch (code)
- {
- case REG:
- CASE_CONST_ANY:
- case SYMBOL_REF:
- case MATCH_TEST:
- case CODE_LABEL:
- case PC:
- case CC0:
- return orig;
-
- default:
- break;
- }
-
- copy = rtx_alloc (code);
- PUT_MODE (copy, GET_MODE (orig));
- ATTR_IND_SIMPLIFIED_P (copy) = ATTR_IND_SIMPLIFIED_P (orig);
- ATTR_CURR_SIMPLIFIED_P (copy) = ATTR_CURR_SIMPLIFIED_P (orig);
- ATTR_PERMANENT_P (copy) = ATTR_PERMANENT_P (orig);
-
- format_ptr = GET_RTX_FORMAT (GET_CODE (copy));
-
- for (i = 0; i < GET_RTX_LENGTH (GET_CODE (copy)); i++)
- {
- switch (*format_ptr++)
- {
- case 'e':
- XEXP (copy, i) = XEXP (orig, i);
- if (XEXP (orig, i) != NULL)
- XEXP (copy, i) = attr_copy_rtx (XEXP (orig, i));
- break;
-
- case 'E':
- case 'V':
- XVEC (copy, i) = XVEC (orig, i);
- if (XVEC (orig, i) != NULL)
- {
- XVEC (copy, i) = rtvec_alloc (XVECLEN (orig, i));
- for (j = 0; j < XVECLEN (copy, i); j++)
- XVECEXP (copy, i, j) = attr_copy_rtx (XVECEXP (orig, i, j));
- }
- break;
-
- case 'n':
- case 'i':
- XINT (copy, i) = XINT (orig, i);
- break;
-
- case 'w':
- XWINT (copy, i) = XWINT (orig, i);
- break;
-
- case 's':
- case 'S':
- XSTR (copy, i) = XSTR (orig, i);
- break;
-
- default:
- gcc_unreachable ();
- }
- }
- return copy;
-}
-
-/* Given a test expression for an attribute, ensure it is validly formed.
- IS_CONST indicates whether the expression is constant for each compiler
- run (a constant expression may not test any particular insn).
+/* Given a test expression EXP for attribute ATTR, ensure it is validly
+ formed. LOC is the location of the .md construct that contains EXP.
Convert (eq_attr "att" "a1,a2") to (ior (eq_attr ... ) (eq_attrq ..))
and (eq_attr "att" "!a1") to (not (eq_attr "att" "a1")). Do the latter
Return the new expression, if any. */
static rtx
-check_attr_test (rtx exp, int is_const, int lineno)
+check_attr_test (file_location loc, rtx exp, attr_desc *attr)
{
- struct attr_desc *attr;
struct attr_value *av;
const char *name_ptr, *p;
rtx orexp, newexp;
case EQ_ATTR:
/* Handle negation test. */
if (XSTR (exp, 1)[0] == '!')
- return check_attr_test (attr_rtx (NOT,
+ return check_attr_test (loc,
+ attr_rtx (NOT,
attr_eq (XSTR (exp, 0),
&XSTR (exp, 1)[1])),
- is_const, lineno);
+ attr);
else if (n_comma_elts (XSTR (exp, 1)) == 1)
{
- attr = find_attr (&XSTR (exp, 0), 0);
- if (attr == NULL)
+ attr_desc *attr2 = find_attr (&XSTR (exp, 0), 0);
+ if (attr2 == NULL)
{
if (! strcmp (XSTR (exp, 0), "alternative"))
- return mk_attr_alt (1 << atoi (XSTR (exp, 1)));
+ return mk_attr_alt (((alternative_mask) 1)
+ << atoi (XSTR (exp, 1)));
else
- fatal ("unknown attribute `%s' in EQ_ATTR", XSTR (exp, 0));
+ fatal_at (loc, "unknown attribute `%s' in definition of"
+ " attribute `%s'", XSTR (exp, 0), attr->name);
}
- if (is_const && ! attr->is_const)
- fatal ("constant expression uses insn attribute `%s' in EQ_ATTR",
- XSTR (exp, 0));
+ if (attr->is_const && ! attr2->is_const)
+ fatal_at (loc, "constant attribute `%s' cannot test non-constant"
+ " attribute `%s'", attr->name, attr2->name);
/* Copy this just to make it permanent,
so expressions using it can be permanent too. */
/* It shouldn't be possible to simplify the value given to a
constant attribute, so don't expand this until it's time to
write the test expression. */
- if (attr->is_const)
+ if (attr2->is_const)
ATTR_IND_SIMPLIFIED_P (exp) = 1;
- if (attr->is_numeric)
+ if (attr2->is_numeric)
{
for (p = XSTR (exp, 1); *p; p++)
if (! ISDIGIT (*p))
- fatal ("attribute `%s' takes only numeric values",
- XSTR (exp, 0));
+ fatal_at (loc, "attribute `%s' takes only numeric values",
+ attr2->name);
}
else
{
- for (av = attr->first_value; av; av = av->next)
+ for (av = attr2->first_value; av; av = av->next)
if (GET_CODE (av->value) == CONST_STRING
&& ! strcmp (XSTR (exp, 1), XSTR (av->value, 0)))
break;
if (av == NULL)
- fatal ("unknown value `%s' for `%s' attribute",
- XSTR (exp, 1), XSTR (exp, 0));
+ fatal_at (loc, "unknown value `%s' for attribute `%s'",
+ XSTR (exp, 1), attr2->name);
}
}
else
name_ptr = XSTR (exp, 1);
while ((p = next_comma_elt (&name_ptr)) != NULL)
- set |= 1 << atoi (p);
+ set |= ((alternative_mask) 1) << atoi (p);
return mk_attr_alt (set);
}
orexp = insert_right_side (IOR, orexp, newexp, -2, -2);
}
- return check_attr_test (orexp, is_const, lineno);
+ return check_attr_test (loc, orexp, attr);
}
}
break;
case IOR:
case AND:
- XEXP (exp, 0) = check_attr_test (XEXP (exp, 0), is_const, lineno);
- XEXP (exp, 1) = check_attr_test (XEXP (exp, 1), is_const, lineno);
+ XEXP (exp, 0) = check_attr_test (loc, XEXP (exp, 0), attr);
+ XEXP (exp, 1) = check_attr_test (loc, XEXP (exp, 1), attr);
break;
case NOT:
- XEXP (exp, 0) = check_attr_test (XEXP (exp, 0), is_const, lineno);
+ XEXP (exp, 0) = check_attr_test (loc, XEXP (exp, 0), attr);
break;
case MATCH_TEST:
break;
case MATCH_OPERAND:
- if (is_const)
- fatal ("RTL operator \"%s\" not valid in constant attribute test",
- GET_RTX_NAME (GET_CODE (exp)));
+ if (attr->is_const)
+ fatal_at (loc, "invalid operator `%s' in definition of constant"
+ " attribute `%s'", GET_RTX_NAME (GET_CODE (exp)),
+ attr->name);
/* These cases can't be simplified. */
ATTR_IND_SIMPLIFIED_P (exp) = 1;
break;
break;
case SYMBOL_REF:
- if (is_const)
+ if (attr->is_const)
{
/* These cases are valid for constant attributes, but can't be
simplified. */
ATTR_IND_SIMPLIFIED_P (exp) = 1;
break;
}
+ /* FALLTHRU */
default:
- fatal ("RTL operator \"%s\" not valid in attribute test",
- GET_RTX_NAME (GET_CODE (exp)));
+ fatal_at (loc, "invalid operator `%s' in definition of attribute"
+ " `%s'", GET_RTX_NAME (GET_CODE (exp)), attr->name);
}
return exp;
}
-/* Given an expression, ensure that it is validly formed and that all named
- attribute values are valid for the given attribute. Issue a fatal error
- if not. If no attribute is specified, assume a numeric attribute.
+/* Given an expression EXP, ensure that it is validly formed and that
+ all named attribute values are valid for ATTR. Issue an error if not.
+ LOC is the location of the .md construct that contains EXP.
Return a perhaps modified replacement expression for the value. */
static rtx
-check_attr_value (rtx exp, struct attr_desc *attr)
+check_attr_value (file_location loc, rtx exp, class attr_desc *attr)
{
struct attr_value *av;
const char *p;
switch (GET_CODE (exp))
{
case CONST_INT:
- if (attr && ! attr->is_numeric)
+ if (!attr->is_numeric)
{
- error_with_line (attr->lineno,
- "CONST_INT not valid for non-numeric attribute %s",
- attr->name);
+ error_at (loc,
+ "CONST_INT not valid for non-numeric attribute `%s'",
+ attr->name);
break;
}
if (INTVAL (exp) < 0)
{
- error_with_line (attr->lineno,
- "negative numeric value specified for attribute %s",
- attr->name);
+ error_at (loc,
+ "negative numeric value specified for attribute `%s'",
+ attr->name);
break;
}
break;
if (! strcmp (XSTR (exp, 0), "*"))
break;
- if (attr == 0 || attr->is_numeric)
+ if (attr->is_numeric)
{
p = XSTR (exp, 0);
for (; *p; p++)
if (! ISDIGIT (*p))
{
- error_with_line (attr ? attr->lineno : 0,
- "non-numeric value for numeric attribute %s",
- attr ? attr->name : "internal");
+ error_at (loc,
+ "non-numeric value specified for numeric"
+ " attribute `%s'", attr->name);
break;
}
break;
break;
if (av == NULL)
- error_with_line (attr->lineno,
- "unknown value `%s' for `%s' attribute",
- XSTR (exp, 0), attr ? attr->name : "internal");
+ error_at (loc, "unknown value `%s' for attribute `%s'",
+ XSTR (exp, 0), attr->name);
break;
case IF_THEN_ELSE:
- XEXP (exp, 0) = check_attr_test (XEXP (exp, 0),
- attr ? attr->is_const : 0,
- attr ? attr->lineno : 0);
- XEXP (exp, 1) = check_attr_value (XEXP (exp, 1), attr);
- XEXP (exp, 2) = check_attr_value (XEXP (exp, 2), attr);
+ XEXP (exp, 0) = check_attr_test (loc, XEXP (exp, 0), attr);
+ XEXP (exp, 1) = check_attr_value (loc, XEXP (exp, 1), attr);
+ XEXP (exp, 2) = check_attr_value (loc, XEXP (exp, 2), attr);
break;
case PLUS:
case MULT:
case DIV:
case MOD:
- if (attr && !attr->is_numeric)
+ if (!attr->is_numeric)
{
- error_with_line (attr->lineno,
- "invalid operation `%s' for non-numeric"
- " attribute value", GET_RTX_NAME (GET_CODE (exp)));
+ error_at (loc, "invalid operation `%s' for non-numeric"
+ " attribute `%s'", GET_RTX_NAME (GET_CODE (exp)),
+ attr->name);
break;
}
/* Fall through. */
case IOR:
case AND:
- XEXP (exp, 0) = check_attr_value (XEXP (exp, 0), attr);
- XEXP (exp, 1) = check_attr_value (XEXP (exp, 1), attr);
+ XEXP (exp, 0) = check_attr_value (loc, XEXP (exp, 0), attr);
+ XEXP (exp, 1) = check_attr_value (loc, XEXP (exp, 1), attr);
break;
case FFS:
case POPCOUNT:
case PARITY:
case BSWAP:
- XEXP (exp, 0) = check_attr_value (XEXP (exp, 0), attr);
+ XEXP (exp, 0) = check_attr_value (loc, XEXP (exp, 0), attr);
break;
case COND:
if (XVECLEN (exp, 0) % 2 != 0)
{
- error_with_line (attr->lineno,
- "first operand of COND must have even length");
+ error_at (loc, "first operand of COND must have even length");
break;
}
for (i = 0; i < XVECLEN (exp, 0); i += 2)
{
- XVECEXP (exp, 0, i) = check_attr_test (XVECEXP (exp, 0, i),
- attr ? attr->is_const : 0,
- attr ? attr->lineno : 0);
+ XVECEXP (exp, 0, i) = check_attr_test (attr->loc,
+ XVECEXP (exp, 0, i),
+ attr);
XVECEXP (exp, 0, i + 1)
- = check_attr_value (XVECEXP (exp, 0, i + 1), attr);
+ = check_attr_value (loc, XVECEXP (exp, 0, i + 1), attr);
}
- XEXP (exp, 1) = check_attr_value (XEXP (exp, 1), attr);
+ XEXP (exp, 1) = check_attr_value (loc, XEXP (exp, 1), attr);
break;
case ATTR:
{
- struct attr_desc *attr2 = find_attr (&XSTR (exp, 0), 0);
+ class attr_desc *attr2 = find_attr (&XSTR (exp, 0), 0);
if (attr2 == NULL)
- error_with_line (attr ? attr->lineno : 0,
- "unknown attribute `%s' in ATTR",
- XSTR (exp, 0));
- else if (attr && attr->is_const && ! attr2->is_const)
- error_with_line (attr->lineno,
- "non-constant attribute `%s' referenced from `%s'",
- XSTR (exp, 0), attr->name);
- else if (attr
- && attr->is_numeric != attr2->is_numeric)
- error_with_line (attr->lineno,
- "numeric attribute mismatch calling `%s' from `%s'",
- XSTR (exp, 0), attr->name);
+ error_at (loc, "unknown attribute `%s' in ATTR",
+ XSTR (exp, 0));
+ else if (attr->is_const && ! attr2->is_const)
+ error_at (attr->loc,
+ "constant attribute `%s' cannot refer to non-constant"
+ " attribute `%s'", attr->name, attr2->name);
+ else if (attr->is_numeric != attr2->is_numeric)
+ error_at (loc,
+ "numeric attribute mismatch calling `%s' from `%s'",
+ attr2->name, attr->name);
}
break;
return attr_rtx (SYMBOL_REF, XSTR (exp, 0));
default:
- error_with_line (attr ? attr->lineno : 0,
- "invalid operation `%s' for attribute value",
- GET_RTX_NAME (GET_CODE (exp)));
+ error_at (loc, "invalid operator `%s' in definition of attribute `%s'",
+ GET_RTX_NAME (GET_CODE (exp)), attr->name);
break;
}
It becomes a COND with each test being (eq_attr "alternative" "n") */
static rtx
-convert_set_attr_alternative (rtx exp, struct insn_def *id)
+convert_set_attr_alternative (rtx exp, class insn_def *id)
{
int num_alt = id->num_alternatives;
rtx condexp;
if (XVECLEN (exp, 1) != num_alt)
{
- error_with_line (id->lineno,
- "bad number of entries in SET_ATTR_ALTERNATIVE");
+ error_at (id->loc, "bad number of entries in SET_ATTR_ALTERNATIVE,"
+ " was %d expected %d", XVECLEN (exp, 1), num_alt);
return NULL_RTX;
}
list of values is given, convert to SET_ATTR_ALTERNATIVE first. */
static rtx
-convert_set_attr (rtx exp, struct insn_def *id)
+convert_set_attr (rtx exp, class insn_def *id)
{
rtx newexp;
const char *name_ptr;
static void
check_defs (void)
{
- struct insn_def *id;
- struct attr_desc *attr;
+ class insn_def *id;
+ class attr_desc *attr;
int i;
rtx value;
case SET:
if (GET_CODE (XEXP (value, 0)) != ATTR)
{
- error_with_line (id->lineno, "bad attribute set");
+ error_at (id->loc, "bad attribute set");
value = NULL_RTX;
}
break;
break;
default:
- error_with_line (id->lineno, "invalid attribute code %s",
- GET_RTX_NAME (GET_CODE (value)));
+ error_at (id->loc, "invalid attribute code %s",
+ GET_RTX_NAME (GET_CODE (value)));
value = NULL_RTX;
}
if (value == NULL_RTX)
if ((attr = find_attr (&XSTR (XEXP (value, 0), 0), 0)) == NULL)
{
- error_with_line (id->lineno, "unknown attribute %s",
- XSTR (XEXP (value, 0), 0));
+ error_at (id->loc, "unknown attribute %s",
+ XSTR (XEXP (value, 0), 0));
continue;
}
XVECEXP (id->def, id->vec_idx, i) = value;
- XEXP (value, 1) = check_attr_value (XEXP (value, 1), attr);
+ XEXP (value, 1) = check_attr_value (id->loc, XEXP (value, 1), attr);
}
}
}
/* Given a valid expression for an attribute value, remove any IF_THEN_ELSE
expressions by converting them into a COND. This removes cases from this
program. Also, replace an attribute value of "*" with the default attribute
- value. */
+ value. LOC is the location to use for error reporting. */
static rtx
-make_canonical (struct attr_desc *attr, rtx exp)
+make_canonical (file_location loc, class attr_desc *attr, rtx exp)
{
int i;
rtx newexp;
case CONST_STRING:
if (! strcmp (XSTR (exp, 0), "*"))
{
- if (attr == 0 || attr->default_val == 0)
- fatal ("(attr_value \"*\") used in invalid context");
+ if (attr->default_val == 0)
+ fatal_at (loc, "(attr_value \"*\") used in invalid context");
exp = attr->default_val->value;
}
else
This makes the COND something that won't be considered an arbitrary
expression by walk_attr_value. */
ATTR_IND_SIMPLIFIED_P (exp) = 1;
- exp = check_attr_value (exp, attr);
+ exp = check_attr_value (loc, exp, attr);
break;
case IF_THEN_ELSE:
exp = newexp;
/* Fall through to COND case since this is now a COND. */
+ gcc_fallthrough ();
case COND:
{
/* First, check for degenerate COND. */
if (XVECLEN (exp, 0) == 0)
- return make_canonical (attr, XEXP (exp, 1));
- defval = XEXP (exp, 1) = make_canonical (attr, XEXP (exp, 1));
+ return make_canonical (loc, attr, XEXP (exp, 1));
+ defval = XEXP (exp, 1) = make_canonical (loc, attr, XEXP (exp, 1));
for (i = 0; i < XVECLEN (exp, 0); i += 2)
{
XVECEXP (exp, 0, i) = copy_boolean (XVECEXP (exp, 0, i));
XVECEXP (exp, 0, i + 1)
- = make_canonical (attr, XVECEXP (exp, 0, i + 1));
- if (! rtx_equal_p (XVECEXP (exp, 0, i + 1), defval))
+ = make_canonical (loc, attr, XVECEXP (exp, 0, i + 1));
+ if (! attr_equal_p (XVECEXP (exp, 0, i + 1), defval))
allsame = 0;
}
if (allsame)
if (GET_CODE (exp) == AND || GET_CODE (exp) == IOR)
return attr_rtx (GET_CODE (exp), copy_boolean (XEXP (exp, 0)),
copy_boolean (XEXP (exp, 1)));
+ else if (GET_CODE (exp) == NOT)
+ return attr_rtx (NOT, copy_boolean (XEXP (exp, 0)));
if (GET_CODE (exp) == MATCH_OPERAND)
{
XSTR (exp, 1) = DEF_ATTR_STRING (XSTR (exp, 1));
`insn_code' is the code of an insn whose attribute has the specified
value (-2 if not processing an insn). We ensure that all insns for
a given value have the same number of alternatives if the value checks
- alternatives. */
+ alternatives. LOC is the location to use for error reporting. */
static struct attr_value *
-get_attr_value (rtx value, struct attr_desc *attr, int insn_code)
+get_attr_value (file_location loc, rtx value, class attr_desc *attr,
+ int insn_code)
{
struct attr_value *av;
- int num_alt = 0;
+ alternative_mask num_alt = 0;
- value = make_canonical (attr, value);
+ value = make_canonical (loc, attr, value);
if (compares_alternatives_p (value))
{
if (insn_code < 0 || insn_alternatives == NULL)
- fatal ("(eq_attr \"alternatives\" ...) used in non-insn context");
+ fatal_at (loc, "(eq_attr \"alternatives\" ...) used in non-insn"
+ " context");
else
num_alt = insn_alternatives[insn_code];
}
for (av = attr->first_value; av; av = av->next)
- if (rtx_equal_p (value, av->value)
+ if (attr_equal_p (value, av->value)
&& (num_alt == 0 || av->first_insn == NULL
|| insn_alternatives[av->first_insn->def->insn_code]))
return av;
static void
expand_delays (void)
{
- struct delay_desc *delay;
+ class delay_desc *delay;
rtx condexp;
rtx newexp;
int i;
the attribute. */
static void
-fill_attr (struct attr_desc *attr)
+fill_attr (class attr_desc *attr)
{
struct attr_value *av;
struct insn_ent *ie;
- struct insn_def *id;
+ class insn_def *id;
int i;
rtx value;
if (value == NULL)
av = attr->default_val;
else
- av = get_attr_value (value, attr, id->insn_code);
+ av = get_attr_value (id->loc, value, attr, id->insn_code);
ie = oballoc (struct insn_ent);
ie->def = id;
static rtx (*const address_fn[]) (rtx)
= {max_fn, min_fn, one_fn, identity_fn};
size_t i;
- struct attr_desc *length_attr, *new_attr;
+ class attr_desc *length_attr, *new_attr;
struct attr_value *av, *new_av;
struct insn_ent *ie, *new_ie;
return;
if (! length_attr->is_numeric)
- fatal ("length attribute must be numeric");
+ fatal_at (length_attr->loc, "length attribute must be numeric");
length_attr->is_const = 0;
length_attr->is_special = 1;
for (av = length_attr->first_value; av; av = av->next)
for (ie = av->first_insn; ie; ie = ie->next)
{
- new_av = get_attr_value (substitute_address (av->value,
+ new_av = get_attr_value (ie->def->loc,
+ substitute_address (av->value,
no_address_fn[i],
address_fn[i]),
new_attr, ie->def->insn_code);
static rtx
max_fn (rtx exp)
{
- int unknown;
- return make_numeric_value (max_attr_value (exp, &unknown));
+ return make_numeric_value (max_attr_value (exp));
}
static rtx
min_fn (rtx exp)
{
- int unknown;
- return make_numeric_value (min_attr_value (exp, &unknown));
+ return make_numeric_value (min_attr_value (exp));
}
static void
write_length_unit_log (FILE *outf)
{
- struct attr_desc *length_attr = find_attr (&length_str, 0);
+ class attr_desc *length_attr = find_attr (&length_str, 0);
struct attr_value *av;
struct insn_ent *ie;
unsigned int length_unit_log, length_or;
- int unknown = 0;
if (length_attr)
{
- length_or = or_attr_value (length_attr->default_val->value, &unknown);
+ length_or = attr_value_alignment (length_attr->default_val->value);
for (av = length_attr->first_value; av; av = av->next)
for (ie = av->first_insn; ie; ie = ie->next)
- length_or |= or_attr_value (av->value, &unknown);
- }
+ length_or |= attr_value_alignment (av->value);
- if (length_attr == NULL || unknown)
- length_unit_log = 0;
- else
- {
length_or = ~length_or;
for (length_unit_log = 0; length_or & 1; length_or >>= 1)
length_unit_log++;
}
+ else
+ length_unit_log = 0;
+
fprintf (outf, "EXPORTED_CONST int length_unit_log = %u;\n", length_unit_log);
}
This routine is passed an expression and either AND or IOR. It returns a
bitmask indicating which alternatives are mentioned within EXP. */
-static int
+static alternative_mask
compute_alternative_mask (rtx exp, enum rtx_code code)
{
const char *string;
else if (GET_CODE (exp) == EQ_ATTR_ALT)
{
- if (code == AND && XINT (exp, 1))
- return XINT (exp, 0);
+ if (code == AND && XWINT (exp, 1))
+ return XWINT (exp, 0);
- if (code == IOR && !XINT (exp, 1))
- return XINT (exp, 0);
+ if (code == IOR && !XWINT (exp, 1))
+ return XWINT (exp, 0);
return 0;
}
return 0;
if (string[1] == 0)
- return 1 << (string[0] - '0');
- return 1 << atoi (string);
+ return ((alternative_mask) 1) << (string[0] - '0');
+ return ((alternative_mask) 1) << atoi (string);
}
/* Given I, a single-bit mask, return RTX to compare the `alternative'
attribute with the value represented by that bit. */
static rtx
-make_alternative_compare (int mask)
+make_alternative_compare (alternative_mask mask)
{
return mk_attr_alt (mask);
}
corresponding to INSN_CODE and INSN_INDEX. */
static rtx
-evaluate_eq_attr (rtx exp, struct attr_desc *attr, rtx value,
+evaluate_eq_attr (rtx exp, class attr_desc *attr, rtx value,
int insn_code, int insn_index)
{
rtx orexp, andexp;
rtl_obstack = temp_obstack;
x = simplify_test_exp (exp, insn_code, insn_index);
rtl_obstack = old;
- if (x == exp || rtl_obstack == temp_obstack)
- return x;
- return attr_copy_rtx (x);
+ return x;
}
/* Returns true if S1 is a subset of S2. */
static bool
attr_alt_subset_p (rtx s1, rtx s2)
{
- switch ((XINT (s1, 1) << 1) | XINT (s2, 1))
+ switch ((XWINT (s1, 1) << 1) | XWINT (s2, 1))
{
case (0 << 1) | 0:
- return !(XINT (s1, 0) &~ XINT (s2, 0));
+ return !(XWINT (s1, 0) &~ XWINT (s2, 0));
case (0 << 1) | 1:
- return !(XINT (s1, 0) & XINT (s2, 0));
+ return !(XWINT (s1, 0) & XWINT (s2, 0));
case (1 << 1) | 0:
return false;
case (1 << 1) | 1:
- return !(XINT (s2, 0) &~ XINT (s1, 0));
+ return !(XWINT (s2, 0) &~ XWINT (s1, 0));
default:
gcc_unreachable ();
static bool
attr_alt_subset_of_compl_p (rtx s1, rtx s2)
{
- switch ((XINT (s1, 1) << 1) | XINT (s2, 1))
+ switch ((XWINT (s1, 1) << 1) | XWINT (s2, 1))
{
case (0 << 1) | 0:
- return !(XINT (s1, 0) & XINT (s2, 0));
+ return !(XWINT (s1, 0) & XWINT (s2, 0));
case (0 << 1) | 1:
- return !(XINT (s1, 0) & ~XINT (s2, 0));
+ return !(XWINT (s1, 0) & ~XWINT (s2, 0));
case (1 << 1) | 0:
- return !(XINT (s2, 0) &~ XINT (s1, 0));
+ return !(XWINT (s2, 0) &~ XWINT (s1, 0));
case (1 << 1) | 1:
return false;
static rtx
attr_alt_intersection (rtx s1, rtx s2)
{
- rtx result = rtx_alloc (EQ_ATTR_ALT);
+ alternative_mask result;
- switch ((XINT (s1, 1) << 1) | XINT (s2, 1))
+ switch ((XWINT (s1, 1) << 1) | XWINT (s2, 1))
{
case (0 << 1) | 0:
- XINT (result, 0) = XINT (s1, 0) & XINT (s2, 0);
+ result = XWINT (s1, 0) & XWINT (s2, 0);
break;
case (0 << 1) | 1:
- XINT (result, 0) = XINT (s1, 0) & ~XINT (s2, 0);
+ result = XWINT (s1, 0) & ~XWINT (s2, 0);
break;
case (1 << 1) | 0:
- XINT (result, 0) = XINT (s2, 0) & ~XINT (s1, 0);
+ result = XWINT (s2, 0) & ~XWINT (s1, 0);
break;
case (1 << 1) | 1:
- XINT (result, 0) = XINT (s1, 0) | XINT (s2, 0);
+ result = XWINT (s1, 0) | XWINT (s2, 0);
break;
default:
gcc_unreachable ();
}
- XINT (result, 1) = XINT (s1, 1) & XINT (s2, 1);
- return result;
+ return attr_rtx (EQ_ATTR_ALT, result, XWINT (s1, 1) & XWINT (s2, 1));
}
/* Return EQ_ATTR_ALT expression representing union of S1 and S2. */
static rtx
attr_alt_union (rtx s1, rtx s2)
{
- rtx result = rtx_alloc (EQ_ATTR_ALT);
+ alternative_mask result;
- switch ((XINT (s1, 1) << 1) | XINT (s2, 1))
+ switch ((XWINT (s1, 1) << 1) | XWINT (s2, 1))
{
case (0 << 1) | 0:
- XINT (result, 0) = XINT (s1, 0) | XINT (s2, 0);
+ result = XWINT (s1, 0) | XWINT (s2, 0);
break;
case (0 << 1) | 1:
- XINT (result, 0) = XINT (s2, 0) & ~XINT (s1, 0);
+ result = XWINT (s2, 0) & ~XWINT (s1, 0);
break;
case (1 << 1) | 0:
- XINT (result, 0) = XINT (s1, 0) & ~XINT (s2, 0);
+ result = XWINT (s1, 0) & ~XWINT (s2, 0);
break;
case (1 << 1) | 1:
- XINT (result, 0) = XINT (s1, 0) & XINT (s2, 0);
+ result = XWINT (s1, 0) & XWINT (s2, 0);
break;
default:
gcc_unreachable ();
}
- XINT (result, 1) = XINT (s1, 1) | XINT (s2, 1);
- return result;
+ return attr_rtx (EQ_ATTR_ALT, result, XWINT (s1, 1) | XWINT (s2, 1));
}
/* Return EQ_ATTR_ALT expression representing complement of S. */
static rtx
attr_alt_complement (rtx s)
{
- rtx result = rtx_alloc (EQ_ATTR_ALT);
-
- XINT (result, 0) = XINT (s, 0);
- XINT (result, 1) = 1 - XINT (s, 1);
-
- return result;
+ return attr_rtx (EQ_ATTR_ALT, XWINT (s, 0),
+ ((HOST_WIDE_INT) 1) - XWINT (s, 1));
}
/* Return EQ_ATTR_ALT expression representing set containing elements set
in E. */
static rtx
-mk_attr_alt (int e)
+mk_attr_alt (alternative_mask e)
{
- rtx result = rtx_alloc (EQ_ATTR_ALT);
-
- XINT (result, 0) = e;
- XINT (result, 1) = 0;
-
- return result;
+ return attr_rtx (EQ_ATTR_ALT, (HOST_WIDE_INT) e, (HOST_WIDE_INT) 0);
}
/* Given an expression, see if it can be simplified for a particular insn
simplify_test_exp (rtx exp, int insn_code, int insn_index)
{
rtx left, right;
- struct attr_desc *attr;
+ class attr_desc *attr;
struct attr_value *av;
struct insn_ent *ie;
struct attr_value_list *iv;
- int i;
+ alternative_mask i;
rtx newexp = exp;
bool left_alt, right_alt;
&& compute_alternative_mask (right, IOR))
{
if (GET_CODE (left) == IOR)
- {
- rtx tem = left;
- left = right;
- right = tem;
- }
+ std::swap (left, right);
newexp = attr_rtx (IOR,
attr_rtx (AND, left, XEXP (right, 0)),
&& XSTR (XEXP (left, 0), 0) == alternative_name);
else
left_alt = (GET_CODE (left) == EQ_ATTR_ALT
- && XINT (left, 1));
+ && XWINT (left, 1));
if (GET_CODE (right) == NOT)
right_alt = (GET_CODE (XEXP (right, 0)) == EQ_ATTR
&& XSTR (XEXP (right, 0), 0) == alternative_name);
else
right_alt = (GET_CODE (right) == EQ_ATTR_ALT
- && XINT (right, 1));
+ && XWINT (right, 1));
if (insn_code >= 0
&& (GET_CODE (left) == AND
else if (insn_code >= 0
&& (GET_CODE (left) == IOR
|| (GET_CODE (left) == EQ_ATTR_ALT
- && !XINT (left, 1))
+ && !XWINT (left, 1))
|| (GET_CODE (left) == EQ_ATTR
&& XSTR (left, 0) == alternative_name)
|| GET_CODE (right) == IOR
|| (GET_CODE (right) == EQ_ATTR_ALT
- && !XINT (right, 1))
+ && !XWINT (right, 1))
|| (GET_CODE (right) == EQ_ATTR
&& XSTR (right, 0) == alternative_name)))
{
break;
case EQ_ATTR_ALT:
- if (!XINT (exp, 0))
- return XINT (exp, 1) ? true_rtx : false_rtx;
+ if (!XWINT (exp, 0))
+ return XWINT (exp, 1) ? true_rtx : false_rtx;
break;
case EQ_ATTR:
if (XSTR (exp, 0) == alternative_name)
{
- newexp = mk_attr_alt (1 << atoi (XSTR (exp, 1)));
+ newexp = mk_attr_alt (((alternative_mask) 1)
+ << atoi (XSTR (exp, 1)));
break;
}
otherwise return 0. */
static int
-tests_attr_p (rtx p, struct attr_desc *attr)
+tests_attr_p (rtx p, class attr_desc *attr)
{
const char *fmt;
int i, ie, j, je;
attr_desc pointers), and return the size of that array. */
static int
-get_attr_order (struct attr_desc ***ret)
+get_attr_order (class attr_desc ***ret)
{
int i, j;
int num = 0;
- struct attr_desc *attr;
- struct attr_desc **all, **sorted;
+ class attr_desc *attr;
+ class attr_desc **all, **sorted;
char *handled;
for (i = 0; i < MAX_ATTRS_INDEX; i++)
for (attr = attrs[i]; attr; attr = attr->next)
num++;
- all = XNEWVEC (struct attr_desc *, num);
- sorted = XNEWVEC (struct attr_desc *, num);
+ all = XNEWVEC (class attr_desc *, num);
+ sorted = XNEWVEC (class attr_desc *, num);
handled = XCNEWVEC (char, num);
num = 0;
for (i = 0; i < MAX_ATTRS_INDEX; i++)
if (DEBUG)
for (j = 0; j < num; j++)
{
- struct attr_desc *attr2;
+ class attr_desc *attr2;
struct attr_value *av;
attr = sorted[j];
/* Optimize the attribute lists by seeing if we can determine conditional
values from the known values of other attributes. This will save subroutine
- calls during the compilation. */
+ calls during the compilation. NUM_INSN_CODES is the number of unique
+ instruction codes. */
static void
-optimize_attrs (void)
+optimize_attrs (int num_insn_codes)
{
- struct attr_desc *attr;
+ class attr_desc *attr;
struct attr_value *av;
struct insn_ent *ie;
rtx newexp;
int i;
struct attr_value_list *ivbuf;
struct attr_value_list *iv;
- struct attr_desc **topsort;
+ class attr_desc **topsort;
int topnum;
/* For each insn code, make a list of all the insn_ent's for it,
return;
/* Make 2 extra elements, for "code" values -2 and -1. */
- insn_code_values = XCNEWVEC (struct attr_value_list *, insn_code_number + 2);
+ insn_code_values = XCNEWVEC (struct attr_value_list *, num_insn_codes + 2);
/* Offset the table address so we can index by -2 or -1. */
insn_code_values += 2;
gcc_assert (iv == ivbuf + num_insn_ents);
/* Process one insn code at a time. */
- for (i = -2; i < insn_code_number; i++)
+ for (i = -2; i < num_insn_codes; i++)
{
/* Clear the ATTR_CURR_SIMPLIFIED_P flag everywhere relevant.
We use it to mean "already simplified for this insn". */
&& attr_rtx_cost (newexp) < 26
)
{
- newexp = attr_copy_rtx (newexp);
remove_insn_ent (av, ie);
- av = get_attr_value (newexp, attr, ie->def->insn_code);
+ av = get_attr_value (ie->def->loc, newexp, attr,
+ ie->def->insn_code);
iv->av = av;
insert_insn_ent (av, ie);
}
/* Add attribute value NAME to the beginning of ATTR's list. */
static void
-add_attr_value (struct attr_desc *attr, const char *name)
+add_attr_value (class attr_desc *attr, const char *name)
{
struct attr_value *av;
/* Create table entries for DEFINE_ATTR or DEFINE_ENUM_ATTR. */
static void
-gen_attr (rtx exp, int lineno)
+gen_attr (md_rtx_info *info)
{
struct enum_type *et;
struct enum_value *ev;
- struct attr_desc *attr;
+ class attr_desc *attr;
const char *name_ptr;
char *p;
+ rtx def = info->def;
/* Make a new attribute structure. Check for duplicate by looking at
attr->default_val, since it is initialized by this routine. */
- attr = find_attr (&XSTR (exp, 0), 1);
+ attr = find_attr (&XSTR (def, 0), 1);
if (attr->default_val)
{
- error_with_line (lineno, "duplicate definition for attribute %s",
- attr->name);
- message_with_line (attr->lineno, "previous definition");
+ error_at (info->loc, "duplicate definition for attribute %s",
+ attr->name);
+ message_at (attr->loc, "previous definition");
return;
}
- attr->lineno = lineno;
+ attr->loc = info->loc;
- if (GET_CODE (exp) == DEFINE_ENUM_ATTR)
+ if (GET_CODE (def) == DEFINE_ENUM_ATTR)
{
- attr->enum_name = XSTR (exp, 1);
- et = lookup_enum_type (XSTR (exp, 1));
+ attr->enum_name = XSTR (def, 1);
+ et = rtx_reader_ptr->lookup_enum_type (XSTR (def, 1));
if (!et || !et->md_p)
- error_with_line (lineno, "No define_enum called `%s' defined",
- attr->name);
+ error_at (info->loc, "No define_enum called `%s' defined",
+ attr->name);
if (et)
for (ev = et->values; ev; ev = ev->next)
add_attr_value (attr, ev->name);
}
- else if (*XSTR (exp, 1) == '\0')
+ else if (*XSTR (def, 1) == '\0')
attr->is_numeric = 1;
else
{
- name_ptr = XSTR (exp, 1);
+ name_ptr = XSTR (def, 1);
while ((p = next_comma_elt (&name_ptr)) != NULL)
add_attr_value (attr, p);
}
- if (GET_CODE (XEXP (exp, 2)) == CONST)
+ if (GET_CODE (XEXP (def, 2)) == CONST)
{
attr->is_const = 1;
if (attr->is_numeric)
- error_with_line (lineno,
- "constant attributes may not take numeric values");
+ error_at (info->loc,
+ "constant attributes may not take numeric values");
/* Get rid of the CONST node. It is allowed only at top-level. */
- XEXP (exp, 2) = XEXP (XEXP (exp, 2), 0);
+ XEXP (def, 2) = XEXP (XEXP (def, 2), 0);
}
if (! strcmp_check (attr->name, length_str) && ! attr->is_numeric)
- error_with_line (lineno, "`length' attribute must take numeric values");
+ error_at (info->loc, "`length' attribute must take numeric values");
/* Set up the default value. */
- XEXP (exp, 2) = check_attr_value (XEXP (exp, 2), attr);
- attr->default_val = get_attr_value (XEXP (exp, 2), attr, -2);
+ XEXP (def, 2) = check_attr_value (info->loc, XEXP (def, 2), attr);
+ attr->default_val = get_attr_value (info->loc, XEXP (def, 2), attr, -2);
}
/* Given a pattern for DEFINE_PEEPHOLE or DEFINE_INSN, return the number of
/* Process DEFINE_PEEPHOLE, DEFINE_INSN, and DEFINE_ASM_ATTRIBUTES. */
static void
-gen_insn (rtx exp, int lineno)
+gen_insn (md_rtx_info *info)
{
- struct insn_def *id;
+ class insn_def *id;
+ rtx def = info->def;
- id = oballoc (struct insn_def);
+ id = oballoc (class insn_def);
id->next = defs;
defs = id;
- id->def = exp;
- id->lineno = lineno;
+ id->def = def;
+ id->loc = info->loc;
- switch (GET_CODE (exp))
+ switch (GET_CODE (def))
{
case DEFINE_INSN:
- id->insn_code = insn_code_number;
+ id->insn_code = info->index;
id->insn_index = insn_index_number;
- id->num_alternatives = count_alternatives (exp);
+ id->num_alternatives = count_alternatives (def);
if (id->num_alternatives == 0)
id->num_alternatives = 1;
id->vec_idx = 4;
break;
case DEFINE_PEEPHOLE:
- id->insn_code = insn_code_number;
+ id->insn_code = info->index;
id->insn_index = insn_index_number;
- id->num_alternatives = count_alternatives (exp);
+ id->num_alternatives = count_alternatives (def);
if (id->num_alternatives == 0)
id->num_alternatives = 1;
id->vec_idx = 3;
true or annul false is specified, and make a `struct delay_desc'. */
static void
-gen_delay (rtx def, int lineno)
+gen_delay (md_rtx_info *info)
{
- struct delay_desc *delay;
+ class delay_desc *delay;
int i;
+ rtx def = info->def;
if (XVECLEN (def, 1) % 3 != 0)
{
- error_with_line (lineno,
- "number of elements in DEFINE_DELAY must"
- " be multiple of three");
+ error_at (info->loc, "number of elements in DEFINE_DELAY must"
+ " be multiple of three");
return;
}
have_annul_false = 1;
}
- delay = oballoc (struct delay_desc);
+ delay = oballoc (class delay_desc);
delay->def = def;
delay->num = ++num_delays;
delay->next = delays;
- delay->lineno = lineno;
+ delay->loc = info->loc;
delays = delay;
}
{
int i;
const char *name;
- struct attr_desc *attr;
+ class attr_desc *attr;
if (exp == NULL)
return;
/* Given a piece of RTX, print a C expression to test its truth value to OUTF.
We use AND and IOR both for logical and bit-wise operations, so
- interpret them as logical unless they are inside a comparison expression. */
+ interpret them as logical unless they are inside a comparison expression.
+
+ An outermost pair of parentheses is emitted around this C expression unless
+ EMIT_PARENS is false. */
/* Interpret AND/IOR as bit-wise operations instead of logical. */
#define FLG_BITWISE 1
#define FLG_OUTSIDE_AND 8
static unsigned int
-write_test_expr (FILE *outf, rtx exp, unsigned int attrs_cached, int flags)
+write_test_expr (FILE *outf, rtx exp, unsigned int attrs_cached, int flags,
+ bool emit_parens = true)
{
int comparison_operator = 0;
RTX_CODE code;
- struct attr_desc *attr;
+ class attr_desc *attr;
- /* In order not to worry about operator precedence, surround our part of
- the expression with parentheses. */
+ if (emit_parens)
+ fprintf (outf, "(");
- fprintf (outf, "(");
code = GET_CODE (exp);
switch (code)
{
case GE: case GT:
case LE: case LT:
comparison_operator = FLG_BITWISE;
+ /* FALLTHRU */
case PLUS: case MINUS: case MULT: case DIV: case MOD:
case AND: case IOR: case XOR:
|| GET_CODE (XEXP (exp, 1)) == EQ_ATTR
|| (GET_CODE (XEXP (exp, 1)) == NOT
&& GET_CODE (XEXP (XEXP (exp, 1), 0)) == EQ_ATTR)))
- attrs_cached
- = write_test_expr (outf, XEXP (exp, 1), attrs_cached, flags);
+ {
+ bool need_parens = true;
+
+ /* No need to emit parentheses around the right-hand operand if we are
+ continuing a chain of && or || (or & or |). */
+ if (GET_CODE (XEXP (exp, 1)) == code)
+ need_parens = false;
+
+ attrs_cached
+ = write_test_expr (outf, XEXP (exp, 1), attrs_cached, flags,
+ need_parens);
+ }
else
write_test_expr (outf, XEXP (exp, 1), attrs_cached,
flags | comparison_operator);
}
/* Otherwise, fall through to normal unary operator. */
+ gcc_fallthrough ();
/* Unary operators. */
case ABS: case NEG:
case EQ_ATTR_ALT:
{
- int set = XINT (exp, 0), bit = 0;
+ alternative_mask set = XWINT (exp, 0);
+ int bit = 0;
if (flags & FLG_BITWISE)
fatal ("EQ_ATTR_ALT not valid inside comparison");
if (!(set & (set - 1)))
{
+ if (!(set & 0xffffffff))
+ {
+ bit += 32;
+ set >>= 32;
+ }
if (!(set & 0xffff))
{
bit += 16;
bit++;
fprintf (outf, "which_alternative %s= %d",
- XINT (exp, 1) ? "!" : "=", bit);
+ XWINT (exp, 1) ? "!" : "=", bit);
}
else
{
- fprintf (outf, "%s((1 << which_alternative) & %#x)",
- XINT (exp, 1) ? "!" : "", set);
+ fprintf (outf, "%s((1ULL << which_alternative) & %#" PRIx64
+ "ULL)",
+ XWINT (exp, 1) ? "!" : "", set);
}
}
break;
break;
case MATCH_TEST:
- fprint_c_condition (outf, XSTR (exp, 0));
+ rtx_reader_ptr->fprint_c_condition (outf, XSTR (exp, 0));
if (flags & FLG_BITWISE)
fprintf (outf, " != 0");
break;
/* A random C expression. */
case SYMBOL_REF:
- fprint_c_condition (outf, XSTR (exp, 0));
+ rtx_reader_ptr->fprint_c_condition (outf, XSTR (exp, 0));
break;
/* The address of the branch target. */
GET_RTX_NAME (code));
}
- fprintf (outf, ")");
+ if (emit_parens)
+ fprintf (outf, ")");
+
return attrs_cached;
}
-/* Given an attribute value, return the maximum CONST_STRING argument
- encountered. Set *UNKNOWNP and return INT_MAX if the value is unknown. */
+/* Given an attribute value expression, return the maximum value that
+ might be evaluated. Return INT_MAX if the value can't be
+ calculated by this function. */
static int
-max_attr_value (rtx exp, int *unknownp)
+max_attr_value (rtx exp)
{
int current_max;
int i, n;
current_max = atoi (XSTR (exp, 0));
break;
+ case CONST_INT:
+ current_max = INTVAL (exp);
+ break;
+
+ case PLUS:
+ current_max = max_attr_value (XEXP (exp, 0));
+ if (current_max != INT_MAX)
+ {
+ n = current_max;
+ current_max = max_attr_value (XEXP (exp, 1));
+ if (current_max != INT_MAX)
+ current_max += n;
+ }
+ break;
+
+ case MINUS:
+ current_max = max_attr_value (XEXP (exp, 0));
+ if (current_max != INT_MAX)
+ {
+ n = current_max;
+ current_max = min_attr_value (XEXP (exp, 1));
+ if (current_max != INT_MAX)
+ current_max = n - current_max;
+ }
+ break;
+
+ case MULT:
+ current_max = max_attr_value (XEXP (exp, 0));
+ if (current_max != INT_MAX)
+ {
+ n = current_max;
+ current_max = max_attr_value (XEXP (exp, 1));
+ if (current_max != INT_MAX)
+ current_max *= n;
+ }
+ break;
+
case COND:
- current_max = max_attr_value (XEXP (exp, 1), unknownp);
+ current_max = max_attr_value (XEXP (exp, 1));
for (i = 0; i < XVECLEN (exp, 0); i += 2)
{
- n = max_attr_value (XVECEXP (exp, 0, i + 1), unknownp);
+ n = max_attr_value (XVECEXP (exp, 0, i + 1));
if (n > current_max)
current_max = n;
}
break;
case IF_THEN_ELSE:
- current_max = max_attr_value (XEXP (exp, 1), unknownp);
- n = max_attr_value (XEXP (exp, 2), unknownp);
+ current_max = max_attr_value (XEXP (exp, 1));
+ n = max_attr_value (XEXP (exp, 2));
if (n > current_max)
current_max = n;
break;
default:
- *unknownp = 1;
current_max = INT_MAX;
break;
}
return current_max;
}
-/* Given an attribute value, return the minimum CONST_STRING argument
- encountered. Set *UNKNOWNP and return 0 if the value is unknown. */
+/* Given an attribute value expression, return the minimum value that
+ might be evaluated. Return INT_MAX if the value can't be
+ calculated by this function. Note that when this function can
+ calculate one value inside IF_THEN_ELSE or some but not all values
+ inside COND, then it returns the minimum among those values it can
+ calculate. */
static int
-min_attr_value (rtx exp, int *unknownp)
+min_attr_value (rtx exp)
{
int current_min;
int i, n;
current_min = atoi (XSTR (exp, 0));
break;
+ case CONST_INT:
+ current_min = INTVAL (exp);
+ break;
+
+ case PLUS:
+ current_min = min_attr_value (XEXP (exp, 0));
+ if (current_min != INT_MAX)
+ {
+ n = current_min;
+ current_min = min_attr_value (XEXP (exp, 1));
+ if (current_min != INT_MAX)
+ current_min += n;
+ }
+ break;
+
+ case MINUS:
+ current_min = min_attr_value (XEXP (exp, 0));
+ if (current_min != INT_MAX)
+ {
+ n = current_min;
+ current_min = max_attr_value (XEXP (exp, 1));
+ if (current_min != INT_MAX)
+ current_min = n - current_min;
+ }
+ break;
+
+ case MULT:
+ current_min = min_attr_value (XEXP (exp, 0));
+ if (current_min != INT_MAX)
+ {
+ n = current_min;
+ current_min = min_attr_value (XEXP (exp, 1));
+ if (current_min != INT_MAX)
+ current_min *= n;
+ }
+ break;
+
case COND:
- current_min = min_attr_value (XEXP (exp, 1), unknownp);
+ current_min = min_attr_value (XEXP (exp, 1));
for (i = 0; i < XVECLEN (exp, 0); i += 2)
{
- n = min_attr_value (XVECEXP (exp, 0, i + 1), unknownp);
+ n = min_attr_value (XVECEXP (exp, 0, i + 1));
if (n < current_min)
current_min = n;
}
break;
case IF_THEN_ELSE:
- current_min = min_attr_value (XEXP (exp, 1), unknownp);
- n = min_attr_value (XEXP (exp, 2), unknownp);
+ current_min = min_attr_value (XEXP (exp, 1));
+ n = min_attr_value (XEXP (exp, 2));
if (n < current_min)
current_min = n;
break;
default:
- *unknownp = 1;
current_min = INT_MAX;
break;
}
return current_min;
}
-/* Given an attribute value, return the result of ORing together all
- CONST_STRING arguments encountered. Set *UNKNOWNP and return -1
- if the numeric value is not known. */
+/* Given an attribute value expression, return the alignment of values.
+ Return 0 if EXP is known to be zero, and 1 if the value can't be
+ calculated by this function. */
-static int
-or_attr_value (rtx exp, int *unknownp)
+static unsigned int
+attr_value_alignment (rtx exp)
{
- int current_or;
+ unsigned int current_or;
int i;
switch (GET_CODE (exp))
current_or = atoi (XSTR (exp, 0));
break;
+ case CONST_INT:
+ current_or = INTVAL (exp);
+ break;
+
+ case PLUS:
+ case MINUS:
+ current_or = attr_value_alignment (XEXP (exp, 0));
+ current_or |= attr_value_alignment (XEXP (exp, 1));
+ break;
+
+ case MULT:
+ current_or = attr_value_alignment (XEXP (exp, 0));
+ current_or *= attr_value_alignment (XEXP (exp, 1));
+ break;
+
case COND:
- current_or = or_attr_value (XEXP (exp, 1), unknownp);
+ current_or = attr_value_alignment (XEXP (exp, 1));
for (i = 0; i < XVECLEN (exp, 0); i += 2)
- current_or |= or_attr_value (XVECEXP (exp, 0, i + 1), unknownp);
+ current_or |= attr_value_alignment (XVECEXP (exp, 0, i + 1));
break;
case IF_THEN_ELSE:
- current_or = or_attr_value (XEXP (exp, 1), unknownp);
- current_or |= or_attr_value (XEXP (exp, 2), unknownp);
+ current_or = attr_value_alignment (XEXP (exp, 1));
+ current_or |= attr_value_alignment (XEXP (exp, 2));
break;
default:
- *unknownp = 1;
- current_or = -1;
+ current_or = 1;
break;
}
- return current_or;
+ return current_or & -current_or;
}
/* Scan an attribute value, possibly a conditional, and record what actions
/* Write out a function to obtain the attribute for a given INSN. */
static void
-write_attr_get (FILE *outf, struct attr_desc *attr)
+write_attr_get (FILE *outf, class attr_desc *attr)
{
struct attr_value *av, *common_av;
int i, j;
/* If the attribute name starts with a star, the remainder is the name of
the subroutine to use, instead of `get_attr_...'. */
if (attr->name[0] == '*')
- fprintf (outf, "%s (rtx insn ATTRIBUTE_UNUSED)\n", &attr->name[1]);
+ fprintf (outf, "%s (rtx_insn *insn ATTRIBUTE_UNUSED)\n", &attr->name[1]);
else if (attr->is_const == 0)
- fprintf (outf, "get_attr_%s (rtx insn ATTRIBUTE_UNUSED)\n", attr->name);
+ fprintf (outf, "get_attr_%s (rtx_insn *insn ATTRIBUTE_UNUSED)\n", attr->name);
else
{
fprintf (outf, "get_attr_%s (void)\n", attr->name);
if ((attrs_seen_more_than_once & (1U << i)) != 0)
{
const char *name = cached_attrs[i];
- struct attr_desc *cached_attr;
+ class attr_desc *cached_attr;
if (i != j)
cached_attrs[j] = name;
cached_attr = find_attr (&name, 0);
and ";"). */
static void
-write_attr_set (FILE *outf, struct attr_desc *attr, int indent, rtx value,
+write_attr_set (FILE *outf, class attr_desc *attr, int indent, rtx value,
const char *prefix, const char *suffix, rtx known_true,
int insn_code, int insn_index, unsigned int attrs_cached)
{
{
write_indent (outf, indent);
if (GET_CODE (ie->def->def) == DEFINE_PEEPHOLE)
- fprintf (outf, "case %d: /* define_peephole, line %d */\n",
- ie->def->insn_code, ie->def->lineno);
+ fprintf (outf, "case %d: /* define_peephole, %s:%d */\n",
+ ie->def->insn_code, ie->def->loc.filename,
+ ie->def->loc.lineno);
else
fprintf (outf, "case %d: /* %s */\n",
ie->def->insn_code, XSTR (ie->def->def, 0));
/* Write out the computation for one attribute value. */
static void
-write_attr_case (FILE *outf, struct attr_desc *attr, struct attr_value *av,
+write_attr_case (FILE *outf, class attr_desc *attr, struct attr_value *av,
int write_case_lines, const char *prefix, const char *suffix,
int indent, rtx known_true)
{
fprintf (outf, " && asm_noperands (PATTERN (insn)) < 0)\n");
write_indent (outf, indent + 2);
fprintf (outf, " fatal_insn_not_found (insn);\n");
+ write_indent (outf, indent + 2);
+ fprintf (outf, "/* FALLTHRU */\n");
}
if (write_case_lines)
/* Utilities to write in various forms. */
static void
-write_attr_valueq (FILE *outf, struct attr_desc *attr, const char *s)
+write_attr_valueq (FILE *outf, class attr_desc *attr, const char *s)
{
if (attr->is_numeric)
{
}
static void
-write_attr_value (FILE *outf, struct attr_desc *attr, rtx value)
+write_attr_value (FILE *outf, class attr_desc *attr, rtx value)
{
int op;
break;
case SYMBOL_REF:
- fprint_c_condition (outf, XSTR (value, 0));
+ rtx_reader_ptr->fprint_c_condition (outf, XSTR (value, 0));
break;
case ATTR:
{
- struct attr_desc *attr2 = find_attr (&XSTR (value, 0), 0);
+ class attr_desc *attr2 = find_attr (&XSTR (value, 0), 0);
if (attr->enum_name)
fprintf (outf, "(enum %s)", attr->enum_name);
else if (!attr->is_numeric)
goto do_operator;
do_operator:
+ fprintf (outf, "(");
write_attr_value (outf, attr, XEXP (value, 0));
- fputc (' ', outf);
- fputc (op, outf);
- fputc (' ', outf);
+ fprintf (outf, " %c ", op);
+ write_attr_value (outf, attr, XEXP (value, 1));
+ fprintf (outf, ")");
+ break;
+
+ case IF_THEN_ELSE:
+ fprintf (outf, "(");
+ write_test_expr (outf, XEXP (value, 0), 0, 0, false);
+ fprintf (outf, " ? ");
write_attr_value (outf, attr, XEXP (value, 1));
+ fprintf (outf, " : ");
+ write_attr_value (outf, attr, XEXP (value, 2));
+ fprintf (outf, ")");
break;
default:
fprintf (outf, " ");
}
+/* If the target does not have annul-true or annul-false delay slots, this
+ function will create a dummy eligible_for function on OUTF which always
+ returns false. KIND will be annul_true or annul_false. */
+
+static void
+write_dummy_eligible_delay (FILE *outf, const char *kind)
+{
+ /* Write function prelude. */
+
+ fprintf (outf, "int\n");
+ fprintf (outf, "eligible_for_%s (rtx_insn *delay_insn ATTRIBUTE_UNUSED,\n"
+ " int slot ATTRIBUTE_UNUSED,\n"
+ " rtx_insn *candidate_insn ATTRIBUTE_UNUSED,\n"
+ " int flags ATTRIBUTE_UNUSED)\n",
+ kind);
+ fprintf (outf, "{\n");
+ fprintf (outf, " return 0;\n");
+ fprintf (outf, "}\n\n");
+}
+
/* Write a subroutine that is given an insn that requires a delay slot, a
delay slot ordinal, and a candidate insn. It returns nonzero if the
candidate can be placed in the specified delay slot of the insn.
static void
write_eligible_delay (FILE *outf, const char *kind)
{
- struct delay_desc *delay;
+ class delay_desc *delay;
int max_slots;
char str[50];
const char *pstr;
- struct attr_desc *attr;
+ class attr_desc *attr;
struct attr_value *av, *common_av;
int i;
/* Write function prelude. */
fprintf (outf, "int\n");
- fprintf (outf, "eligible_for_%s (rtx delay_insn ATTRIBUTE_UNUSED, int slot, \n"
- " rtx candidate_insn, int flags ATTRIBUTE_UNUSED)\n",
+ fprintf (outf, "eligible_for_%s (rtx_insn *delay_insn ATTRIBUTE_UNUSED, int slot, \n"
+ " rtx_insn *candidate_insn, int flags ATTRIBUTE_UNUSED)\n",
kind);
fprintf (outf, "{\n");
- fprintf (outf, " rtx insn;\n");
+ fprintf (outf, " rtx_insn *insn ATTRIBUTE_UNUSED;\n");
+ fprintf (outf, "\n");
+ fprintf (outf, " if (num_delay_slots (delay_insn) == 0)\n");
+ fprintf (outf, " return 0;");
fprintf (outf, "\n");
fprintf (outf, " gcc_assert (slot < %d);\n", max_slots);
fprintf (outf, "\n");
return attr_string (start, *pstr - start);
}
-/* Return a `struct attr_desc' pointer for a given named attribute. If CREATE
+/* Return a `class attr_desc' pointer for a given named attribute. If CREATE
is nonzero, build a new attribute, if one does not exist. *NAME_P is
replaced by a pointer to a canonical copy of the string. */
-static struct attr_desc *
+static class attr_desc *
find_attr (const char **name_p, int create)
{
- struct attr_desc *attr;
+ class attr_desc *attr;
int index;
const char *name = *name_p;
if (! create)
return NULL;
- attr = oballoc (struct attr_desc);
+ attr = oballoc (class attr_desc);
attr->name = DEF_ATTR_STRING (name);
attr->enum_name = 0;
attr->first_value = attr->default_val = NULL;
static void
make_internal_attr (const char *name, rtx value, int special)
{
- struct attr_desc *attr;
+ class attr_desc *attr;
attr = find_attr (&name, 1);
gcc_assert (!attr->default_val);
attr->is_numeric = 1;
attr->is_const = 0;
attr->is_special = (special & ATTR_SPECIAL) != 0;
- attr->default_val = get_attr_value (value, attr, -2);
+ attr->default_val = get_attr_value (file_location ("<internal>", 0, 0),
+ value, attr, -2);
}
/* Find the most used value of an attribute. */
static struct attr_value *
-find_most_used (struct attr_desc *attr)
+find_most_used (class attr_desc *attr)
{
struct attr_value *av;
struct attr_value *most_used;
static void
write_const_num_delay_slots (FILE *outf)
{
- struct attr_desc *attr = find_attr (&num_delay_slots_str, 0);
+ class attr_desc *attr = find_attr (&num_delay_slots_str, 0);
struct attr_value *av;
if (attr)
{
- fprintf (outf, "int\nconst_num_delay_slots (rtx insn)\n");
+ fprintf (outf, "int\nconst_num_delay_slots (rtx_insn *insn)\n");
fprintf (outf, "{\n");
fprintf (outf, " switch (recog_memoized (insn))\n");
fprintf (outf, " {\n");
/* Store information from a DEFINE_INSN_RESERVATION for future
attribute generation. */
static void
-gen_insn_reserv (rtx def)
+gen_insn_reserv (md_rtx_info *info)
{
struct insn_reserv *decl = oballoc (struct insn_reserv);
+ rtx def = info->def;
+
+ class attr_desc attr = { };
+
+ attr.name = DEF_ATTR_STRING (XSTR (def, 0));
+ attr.loc = info->loc;
decl->name = DEF_ATTR_STRING (XSTR (def, 0));
decl->default_latency = XINT (def, 1);
- decl->condexp = check_attr_test (XEXP (def, 2), 0, 0);
+ decl->condexp = check_attr_test (info->loc, XEXP (def, 2), &attr);
decl->insn_num = n_insn_reservs;
decl->bypassed = false;
decl->next = 0;
static struct bypass_list *all_bypasses;
static size_t n_bypasses;
+static size_t n_bypassed;
static void
gen_bypass_1 (const char *s, size_t len)
}
static void
-gen_bypass (rtx def)
+gen_bypass (md_rtx_info *info)
{
const char *p, *base;
+ rtx def = info->def;
for (p = base = XSTR (def, 1); *p; p++)
if (*p == ',')
{
struct bypass_list *b;
struct insn_reserv *r;
+ n_bypassed = 0;
+
/* The reservation list is likely to be much longer than the bypass
list. */
for (r = all_insn_reservs; r; r = r->next)
for (b = all_bypasses; b; b = b->next)
if (fnmatch (b->pattern, r->name, 0) == 0)
- r->bypassed = true;
+ {
+ n_bypassed++;
+ r->bypassed = true;
+ break;
+ }
}
/* Check that attribute NAME is used in define_insn_reservation condition
/* Try to find a const attribute (usually cpu or tune) that is used
in all define_insn_reservation conditions. */
-static struct attr_desc *
+static class attr_desc *
find_tune_attr (rtx exp)
{
- struct attr_desc *attr;
+ class attr_desc *attr;
switch (GET_CODE (exp))
{
int i;
struct insn_reserv *decl;
rtx code_exp, lats_exp, byps_exp;
- struct attr_desc *tune_attr;
+ class attr_desc *tune_attr;
if (n_insn_reservs == 0)
return;
continue;
gcc_assert (GET_CODE (val->value) == CONST_STRING);
fprintf (dfa_file,
- "extern int internal_dfa_insn_code_%s (rtx);\n",
+ "extern int internal_dfa_insn_code_%s (rtx_insn *);\n",
XSTR (val->value, 0));
}
fprintf (dfa_file, "\n");
continue;
gcc_assert (GET_CODE (val->value) == CONST_STRING);
fprintf (latency_file,
- "extern int insn_default_latency_%s (rtx);\n",
+ "extern int insn_default_latency_%s (rtx_insn *);\n",
XSTR (val->value, 0));
}
fprintf (latency_file, "\n");
continue;
gcc_assert (GET_CODE (val->value) == CONST_STRING);
fprintf (attr_file,
- "extern int internal_dfa_insn_code_%s (rtx);\n"
- "extern int insn_default_latency_%s (rtx);\n",
+ "extern int internal_dfa_insn_code_%s (rtx_insn *);\n"
+ "extern int insn_default_latency_%s (rtx_insn *);\n",
XSTR (val->value, 0), XSTR (val->value, 0));
}
fprintf (attr_file, "\n");
- fprintf (attr_file, "int (*internal_dfa_insn_code) (rtx);\n");
- fprintf (attr_file, "int (*insn_default_latency) (rtx);\n");
+ fprintf (attr_file, "int (*internal_dfa_insn_code) (rtx_insn *);\n");
+ fprintf (attr_file, "int (*insn_default_latency) (rtx_insn *);\n");
fprintf (attr_file, "\n");
fprintf (attr_file, "void\n");
fprintf (attr_file, "init_sched_attrs (void)\n");
{
int j;
char *name;
- rtx test = attr_rtx (EQ_ATTR, tune_attr->name, XSTR (val->value, 0));
+ rtx test = attr_eq (tune_attr->name, XSTR (val->value, 0));
if (val == tune_attr->default_val)
continue;
process_bypasses ();
byps_exp = rtx_alloc (COND);
- XVEC (byps_exp, 0) = rtvec_alloc (n_bypasses * 2);
+ XVEC (byps_exp, 0) = rtvec_alloc (n_bypassed * 2);
XEXP (byps_exp, 1) = make_numeric_value (0);
for (decl = all_insn_reservs, i = 0;
decl;
fprintf (outf, "/* Generated automatically by the program `genattrtab'\n"
" from the machine description file `md'. */\n\n");
+ fprintf (outf, "#define IN_TARGET_CODE 1\n");
fprintf (outf, "#include \"config.h\"\n");
fprintf (outf, "#include \"system.h\"\n");
fprintf (outf, "#include \"coretypes.h\"\n");
- fprintf (outf, "#include \"tm.h\"\n");
+ fprintf (outf, "#include \"backend.h\"\n");
+ fprintf (outf, "#include \"predict.h\"\n");
fprintf (outf, "#include \"tree.h\"\n");
+ fprintf (outf, "#include \"rtl.h\"\n");
+ fprintf (outf, "#include \"alias.h\"\n");
+ fprintf (outf, "#include \"options.h\"\n");
fprintf (outf, "#include \"varasm.h\"\n");
fprintf (outf, "#include \"stor-layout.h\"\n");
fprintf (outf, "#include \"calls.h\"\n");
- fprintf (outf, "#include \"rtl.h\"\n");
fprintf (outf, "#include \"insn-attr.h\"\n");
+ fprintf (outf, "#include \"memmodel.h\"\n");
fprintf (outf, "#include \"tm_p.h\"\n");
fprintf (outf, "#include \"insn-config.h\"\n");
fprintf (outf, "#include \"recog.h\"\n");
fprintf (outf, "#include \"output.h\"\n");
fprintf (outf, "#include \"toplev.h\"\n");
fprintf (outf, "#include \"flags.h\"\n");
- fprintf (outf, "#include \"function.h\"\n");
+ fprintf (outf, "#include \"emit-rtl.h\"\n");
fprintf (outf, "\n");
fprintf (outf, "#define operands recog_data.operand\n\n");
}
}
int
-main (int argc, char **argv)
+main (int argc, const char **argv)
{
- rtx desc;
- struct attr_desc *attr;
- struct insn_def *id;
- rtx tem;
+ class attr_desc *attr;
+ class insn_def *id;
int i;
progname = "genattrtab";
/* Read the machine description. */
- while (1)
+ md_rtx_info info;
+ while (read_md_rtx (&info))
{
- int lineno;
-
- desc = read_md_rtx (&lineno, &insn_code_number);
- if (desc == NULL)
- break;
-
- switch (GET_CODE (desc))
+ switch (GET_CODE (info.def))
{
case DEFINE_INSN:
case DEFINE_PEEPHOLE:
case DEFINE_ASM_ATTRIBUTES:
- gen_insn (desc, lineno);
+ gen_insn (&info);
break;
case DEFINE_ATTR:
case DEFINE_ENUM_ATTR:
- gen_attr (desc, lineno);
+ gen_attr (&info);
break;
case DEFINE_DELAY:
- gen_delay (desc, lineno);
+ gen_delay (&info);
break;
case DEFINE_INSN_RESERVATION:
- gen_insn_reserv (desc);
+ gen_insn_reserv (&info);
break;
case DEFINE_BYPASS:
- gen_bypass (desc);
+ gen_bypass (&info);
break;
default:
break;
}
- if (GET_CODE (desc) != DEFINE_ASM_ATTRIBUTES)
+ if (GET_CODE (info.def) != DEFINE_ASM_ATTRIBUTES)
insn_index_number++;
}
if (have_error)
return FATAL_EXIT_CODE;
- insn_code_number++;
-
/* If we didn't have a DEFINE_ASM_ATTRIBUTES, make a null one. */
if (! got_define_asm_attributes)
{
- tem = rtx_alloc (DEFINE_ASM_ATTRIBUTES);
- XVEC (tem, 0) = rtvec_alloc (0);
- gen_insn (tem, 0);
+ md_rtx_info info;
+ info.def = rtx_alloc (DEFINE_ASM_ATTRIBUTES);
+ XVEC (info.def, 0) = rtvec_alloc (0);
+ info.loc = file_location ("<internal>", 0, 0);
+ info.index = -1;
+ gen_insn (&info);
}
/* Expand DEFINE_DELAY information into new attribute. */
- if (num_delays)
- expand_delays ();
+ expand_delays ();
/* Make `insn_alternatives'. */
- insn_alternatives = oballocvec (int, insn_code_number);
+ int num_insn_codes = get_num_insn_codes ();
+ insn_alternatives = oballocvec (alternative_mask, num_insn_codes);
for (id = defs; id; id = id->next)
if (id->insn_code >= 0)
- insn_alternatives[id->insn_code] = (1 << id->num_alternatives) - 1;
+ insn_alternatives[id->insn_code]
+ = (((alternative_mask) 1) << id->num_alternatives) - 1;
/* Make `insn_n_alternatives'. */
- insn_n_alternatives = oballocvec (int, insn_code_number);
+ insn_n_alternatives = oballocvec (int, num_insn_codes);
for (id = defs; id; id = id->next)
if (id->insn_code >= 0)
insn_n_alternatives[id->insn_code] = id->num_alternatives;
for (i = 0; i < MAX_ATTRS_INDEX; i++)
for (attr = attrs[i]; attr; attr = attr->next)
attr->default_val->value
- = check_attr_value (attr->default_val->value, attr);
+ = check_attr_value (attr->loc, attr->default_val->value, attr);
if (have_error)
return FATAL_EXIT_CODE;
make_length_attrs ();
/* Perform any possible optimizations to speed up compilation. */
- optimize_attrs ();
+ optimize_attrs (num_insn_codes);
/* Now write out all the `gen_attr_...' routines. Do these before the
special routines so that they get defined before they are used. */
/* Write out delay eligibility information, if DEFINE_DELAY present.
(The function to compute the number of delay slots will be written
below.) */
- if (num_delays)
- {
- write_eligible_delay (attr_file, "delay");
- if (have_annul_true)
- write_eligible_delay (attr_file, "annul_true");
- if (have_annul_false)
- write_eligible_delay (attr_file, "annul_false");
- }
+ write_eligible_delay (attr_file, "delay");
+ if (have_annul_true)
+ write_eligible_delay (attr_file, "annul_true");
+ else
+ write_dummy_eligible_delay (attr_file, "annul_true");
+ if (have_annul_false)
+ write_eligible_delay (attr_file, "annul_false");
+ else
+ write_dummy_eligible_delay (attr_file, "annul_false");
/* Write out constant delay slot info. */
write_const_num_delay_slots (attr_file);
projects / thirdparty / gcc.git / blobdiff