(struct attr_desc): Add unsigned_p field.
(struct function_unit_op): Add issue_delay, conflict_exp, and issue_exp fields. Drop busyexp field. (struct function_unit): Add needs_blockage_function, needs_range_function, issue_delay, and max_blockage fields. Drop costexp, and busy delay fields. (enum operator): Add POS_MINUS_OP, EQ_OP, MIN_OP, RANGE_OP. (operate_exp): Implement new ops. (make_internal_attr): Set unsigned_p based on the value of SPECIAL. (write_attr_get): Function is unsigned when unsigned_p is true. (write_attr_valueq): Write hex value of large constants in a comment. (simplify_by_exploding): Check for EXP having no EQ_ATTR expressions and for all values as the default. (find_and_mark_used_attributes): Add TERMS and NTERMS parameters. (max_attr_value): Allow IF_THEN_ELSE. (simplify_knowing, write_complex_function, extend_range): New functions. (gen_unit): Use local variables to name the fields. Change the meaning of busy-delay to issue-delay. (expand_units): Compute issue_exp. Write attributes for computing `<name>_unit_blockage' and `<name>_unit_blockage_range' functions. Compute max_blockage, and the needs_*_function values. (write_function_unit_info): Write blockage function and conflict cost functions using write_complex_function. Write new function_unit_desc fields. (expand_units): Use the normalized values of the unit's CONDEXP and BUSYEXP. From-SVN: r1952
This commit is contained in:
Tom Wood
parent
de19227a25
commit
bee757e1c0
546
gcc/genattrtab.c
546
gcc/genattrtab.c
@ -167,6 +167,7 @@ struct attr_desc
|
||||
struct attr_desc *next; /* Next attribute. */
|
||||
int is_numeric; /* Values of this attribute are numeric. */
|
||||
int negative_ok; /* Allow negative numeric values. */
|
||||
int unsigned_p; /* Make the output function unsigned int. */
|
||||
int is_const; /* Attribute value constant for each run. */
|
||||
int is_special; /* Don't call `write_attr_set'. */
|
||||
struct attr_value *first_value; /* First value of this attribute. */
|
||||
@ -175,6 +176,14 @@ struct attr_desc
|
||||
|
||||
#define NULL_ATTR (struct attr_desc *) NULL
|
||||
|
||||
/* A range of values. */
|
||||
|
||||
struct range
|
||||
{
|
||||
int min;
|
||||
int max;
|
||||
};
|
||||
|
||||
/* Structure for each DEFINE_DELAY. */
|
||||
|
||||
struct delay_desc
|
||||
@ -192,7 +201,9 @@ struct function_unit_op
|
||||
struct function_unit_op *next; /* Next operation for this function unit. */
|
||||
int num; /* Ordinal for this operation type in unit. */
|
||||
int ready; /* Cost until data is ready. */
|
||||
rtx busyexp; /* Expression computing conflict cost. */
|
||||
int issue_delay; /* Cost until unit can accept another insn. */
|
||||
rtx conflict_exp; /* Expression TRUE for insns incurring issue delay. */
|
||||
rtx issue_exp; /* Expression computing issue delay. */
|
||||
};
|
||||
|
||||
/* Record information about each function unit mentioned in a
|
||||
@ -207,14 +218,14 @@ struct function_unit
|
||||
int simultaneity; /* Maximum number of simultaneous insns
|
||||
on this function unit or 0 if unlimited. */
|
||||
rtx condexp; /* Expression TRUE for insn needing unit. */
|
||||
rtx costexp; /* Worst-case cost as function of insn. */
|
||||
int num_opclasses; /* Number of different operation types. */
|
||||
struct function_unit_op *ops; /* Pointer to first operation type. */
|
||||
int needs_conflict_function; /* Nonzero if a conflict function required. */
|
||||
int needs_blockage_function; /* Nonzero if a blockage function required. */
|
||||
int needs_range_function; /* Nonzero if a blockage range function required. */
|
||||
rtx default_cost; /* Conflict cost, if constant. */
|
||||
rtx max_busy_cost; /* Maximum conflict cost. */
|
||||
int min_busy_delay; /* Minimum conflict cost. */
|
||||
int max_busy_delay; /* Maximum conflict cost. */
|
||||
struct range issue_delay; /* Range of issue delay values. */
|
||||
int max_blockage; /* Maximum time an insn blocks the unit. */
|
||||
};
|
||||
|
||||
/* Listheads of above structures. */
|
||||
@ -240,7 +251,7 @@ static int num_units;
|
||||
|
||||
/* Used as operand to `operate_exp': */
|
||||
|
||||
enum operator {PLUS_OP, MINUS_OP, OR_OP, MAX_OP};
|
||||
enum operator {PLUS_OP, MINUS_OP, POS_MINUS_OP, EQ_OP, OR_OP, MAX_OP, MIN_OP, RANGE_OP};
|
||||
|
||||
/* Stores, for each insn code, the number of constraint alternatives. */
|
||||
|
||||
@ -301,6 +312,7 @@ static rtx copy_boolean ();
|
||||
static void expand_delays ();
|
||||
static rtx operate_exp ();
|
||||
static void expand_units ();
|
||||
static rtx simplify_knowing ();
|
||||
static rtx encode_units_mask ();
|
||||
static void fill_attr ();
|
||||
static rtx substitute_address ();
|
||||
@ -349,6 +361,7 @@ static void write_upcase ();
|
||||
static void write_indent ();
|
||||
static void write_eligible_delay ();
|
||||
static void write_function_unit_info ();
|
||||
static void write_complex_function ();
|
||||
static int n_comma_elts ();
|
||||
static char *next_comma_elt ();
|
||||
static struct attr_desc *find_attr ();
|
||||
@ -356,6 +369,7 @@ static void make_internal_attr ();
|
||||
static struct attr_value *find_most_used ();
|
||||
static rtx find_single_value ();
|
||||
static rtx make_numeric_value ();
|
||||
static void extend_range ();
|
||||
char *xrealloc ();
|
||||
char *xmalloc ();
|
||||
static void fatal ();
|
||||
@ -1504,10 +1518,25 @@ operate_exp (op, left, right)
|
||||
i = left_value - right_value;
|
||||
break;
|
||||
|
||||
case POS_MINUS_OP: /* The positive part of LEFT - RIGHT. */
|
||||
if (left_value > right_value)
|
||||
i = left_value - right_value;
|
||||
else
|
||||
i = 0;
|
||||
break;
|
||||
|
||||
case OR_OP:
|
||||
i = left_value | right_value;
|
||||
break;
|
||||
|
||||
case EQ_OP:
|
||||
i = left_value == right_value;
|
||||
break;
|
||||
|
||||
case RANGE_OP:
|
||||
i = (left_value << (HOST_BITS_PER_INT / 2)) | right_value;
|
||||
break;
|
||||
|
||||
case MAX_OP:
|
||||
if (left_value > right_value)
|
||||
i = left_value;
|
||||
@ -1515,6 +1544,13 @@ operate_exp (op, left, right)
|
||||
i = right_value;
|
||||
break;
|
||||
|
||||
case MIN_OP:
|
||||
if (left_value < right_value)
|
||||
i = left_value;
|
||||
else
|
||||
i = right_value;
|
||||
break;
|
||||
|
||||
default:
|
||||
abort ();
|
||||
}
|
||||
@ -1646,7 +1682,15 @@ operate_exp (op, left, right)
|
||||
and a `<name>_unit_conflict_cost' function is given an insn already
|
||||
executing on the unit and a candidate to execute and will give the
|
||||
cost from the time the executing insn started until the candidate
|
||||
can start (ignore limitations on the number of simultaneous insns). */
|
||||
can start (ignore limitations on the number of simultaneous insns).
|
||||
|
||||
For each unit, a `<name>_unit_blockage' function is given an insn
|
||||
already executing on the unit and a candidate to execute and will
|
||||
give the delay incurred due to function unit conflicts. The range of
|
||||
blockage cost values for a given executing insn is given by the
|
||||
`<name>_unit_blockage_range' function. These values are encoded in
|
||||
an int where the upper half gives the minimum value and the lower
|
||||
half gives the maximum value. */
|
||||
|
||||
static void
|
||||
expand_units ()
|
||||
@ -1659,19 +1703,47 @@ expand_units ()
|
||||
char *str;
|
||||
int i, j, u, num, nvalues;
|
||||
|
||||
/* Validate the expressions we were given for the conditions and busy cost.
|
||||
Then make attributes for use in the conflict function. */
|
||||
/* Rebuild the condition for the unit to share the RTL expressions.
|
||||
Sharing is required by simplify_by_exploding. Build the issue delay
|
||||
expressions. Validate the expressions we were given for the conditions
|
||||
and conflict vector. Then make attributes for use in the conflict
|
||||
function. */
|
||||
|
||||
for (unit = units; unit; unit = unit->next)
|
||||
for (op = unit->ops; op; op = op->next)
|
||||
{
|
||||
op->condexp = check_attr_test (op->condexp, 0);
|
||||
op->busyexp = check_attr_value (make_canonical (NULL_ATTR,
|
||||
op->busyexp),
|
||||
{
|
||||
rtx min_issue = make_numeric_value (unit->issue_delay.min);
|
||||
|
||||
unit->condexp = check_attr_test (unit->condexp, 0);
|
||||
|
||||
for (op = unit->ops; op; op = op->next)
|
||||
{
|
||||
rtx issue_delay = make_numeric_value (op->issue_delay);
|
||||
rtx issue_exp = issue_delay;
|
||||
|
||||
/* Build, validate, and simplify the issue delay expression. */
|
||||
if (op->conflict_exp != true_rtx)
|
||||
issue_exp = attr_rtx (IF_THEN_ELSE, op->conflict_exp,
|
||||
issue_exp, make_numeric_value (0));
|
||||
issue_exp = check_attr_value (make_canonical (NULL_ATTR,
|
||||
issue_exp),
|
||||
NULL_ATTR);
|
||||
str = attr_printf (strlen (unit->name) + 11, "*%s_case_%d",
|
||||
unit->name, op->num);
|
||||
make_internal_attr (str, op->busyexp, 1);
|
||||
}
|
||||
issue_exp = simplify_knowing (issue_exp, unit->condexp);
|
||||
op->issue_exp = issue_exp;
|
||||
|
||||
/* Make an attribute for use in the conflict function if needed. */
|
||||
unit->needs_conflict_function = (unit->issue_delay.min
|
||||
!= unit->issue_delay.max);
|
||||
if (unit->needs_conflict_function)
|
||||
{
|
||||
str = attr_printf (strlen (unit->name) + 11, "*%s_cost_%d",
|
||||
unit->name, op->num);
|
||||
make_internal_attr (str, issue_exp, 1);
|
||||
}
|
||||
|
||||
/* Validate the condition. */
|
||||
op->condexp = check_attr_test (op->condexp, 0);
|
||||
}
|
||||
}
|
||||
|
||||
/* Compute the mask of function units used. Initially, the unitsmask is
|
||||
zero. Set up a conditional to compute each unit's contribution. */
|
||||
@ -1682,7 +1754,7 @@ expand_units ()
|
||||
/* Merge each function unit into the unit mask attributes. */
|
||||
for (unit = units; unit; unit = unit->next)
|
||||
{
|
||||
XEXP (newexp, 0) = check_attr_test (unit->condexp, 0);
|
||||
XEXP (newexp, 0) = unit->condexp;
|
||||
XEXP (newexp, 1) = make_numeric_value (1 << unit->num);
|
||||
unitsmask = operate_exp (OR_OP, unitsmask, newexp);
|
||||
}
|
||||
@ -1788,13 +1860,128 @@ expand_units ()
|
||||
XVECEXP (readycost, 0, nvalues * 2 + 1) = make_numeric_value (value);
|
||||
}
|
||||
|
||||
/* Make an attribute for the ready_cost function. Simplifying
|
||||
further with simplify_by_exploding doesn't win. */
|
||||
if (u < num_units)
|
||||
str = attr_printf (strlen (unit->name) + 20, "*%s_unit_ready_cost",
|
||||
unit->name);
|
||||
{
|
||||
rtx max_blockage = 0, min_blockage = 0;
|
||||
|
||||
/* Simplify the readycost expression by only considering insns
|
||||
that use the unit. */
|
||||
readycost = simplify_knowing (readycost, unit->condexp);
|
||||
|
||||
/* Determine the blockage cost the executing insn (E) given
|
||||
the candidate insn (C). This is the maximum of the issue
|
||||
delay, the pipeline delay, and the simultaneity constraint.
|
||||
Each function_unit_op represents the characteristics of the
|
||||
candidate insn, so in the expressions below, C is a known
|
||||
term and E is an unknown term.
|
||||
|
||||
The issue delay function for C is op->issue_exp and is used to
|
||||
write the `<name>_unit_conflict_cost' function. Symbolicly
|
||||
this is "ISSUE-DELAY (E,C)".
|
||||
|
||||
The pipeline delay results form the FIFO constraint on the
|
||||
function unit and is "READY-COST (E) + 1 - READY-COST (C)".
|
||||
|
||||
The simultaneity constraint is based on how long it takes to
|
||||
fill the unit given the minimum issue delay. FILL-TIME is the
|
||||
constant "MIN (ISSUE-DELAY (*,*)) * (SIMULTANEITY - 1)", and
|
||||
the simultaneity constraint is "READY-COST (E) - FILL-TIME"
|
||||
if SIMULTANEITY is non-zero and zero otherwise.
|
||||
|
||||
Thus, BLOCKAGE (E,C) when SIMULTANEITY is zero is
|
||||
|
||||
MAX (ISSUE-DELAY (E,C),
|
||||
READY-COST (E) - (READY-COST (C) - 1))
|
||||
|
||||
and otherwise
|
||||
|
||||
MAX (ISSUE-DELAY (E,C),
|
||||
READY-COST (E) - (READY-COST (C) - 1),
|
||||
READY-COST (E) - FILL-TIME)
|
||||
|
||||
The `<name>_unit_blockage' function is computed by determining
|
||||
this value for each candidate insn. As these values are
|
||||
computed, we also compute the upper and lower bounds for
|
||||
BLOCKAGE (E,*). These are combined to form the function
|
||||
`<name>_unit_blockage_range'. Finally, the maximum blockage
|
||||
cost, MAX (BLOCKAGE (*,*)), is computed. */
|
||||
|
||||
for (op = unit->ops; op; op = op->next)
|
||||
{
|
||||
rtx blockage = readycost;
|
||||
int delay = op->ready - 1;
|
||||
|
||||
if (unit->simultaneity != 0)
|
||||
delay = MIN (delay, ((unit->simultaneity - 1)
|
||||
* unit->issue_delay.min));
|
||||
|
||||
if (delay > 0)
|
||||
blockage = operate_exp (POS_MINUS_OP, blockage,
|
||||
make_numeric_value (delay));
|
||||
|
||||
blockage = operate_exp (MAX_OP, blockage, op->issue_exp);
|
||||
blockage = simplify_knowing (blockage, unit->condexp);
|
||||
|
||||
/* Add this op's contribution to MAX (BLOCKAGE (E,*)) and
|
||||
MIN (BLOCKAGE (E,*)). */
|
||||
if (max_blockage == 0)
|
||||
max_blockage = min_blockage = blockage;
|
||||
else
|
||||
{
|
||||
max_blockage
|
||||
= simplify_knowing (operate_exp (MAX_OP, max_blockage,
|
||||
blockage),
|
||||
unit->condexp);
|
||||
min_blockage
|
||||
= simplify_knowing (operate_exp (MIN_OP, min_blockage,
|
||||
blockage),
|
||||
unit->condexp);
|
||||
}
|
||||
|
||||
/* Make an attribute for use in the blockage function. */
|
||||
str = attr_printf (strlen (unit->name) + 12, "*%s_block_%d",
|
||||
unit->name, op->num);
|
||||
make_internal_attr (str, blockage, 1);
|
||||
}
|
||||
|
||||
/* Record MAX (BLOCKAGE (*,*)). */
|
||||
unit->max_blockage = max_attr_value (max_blockage);
|
||||
|
||||
/* See if the upper and lower bounds of BLOCKAGE (E,*) are the
|
||||
same. If so, the blockage function carries no additional
|
||||
information and is not written. */
|
||||
newexp = operate_exp (EQ_OP, max_blockage, min_blockage);
|
||||
newexp = simplify_knowing (newexp, unit->condexp);
|
||||
unit->needs_blockage_function
|
||||
= (GET_CODE (newexp) != CONST_STRING
|
||||
|| atoi (XSTR (newexp, 0)) != 1);
|
||||
|
||||
/* If the all values of BLOCKAGE (E,C) have the same value,
|
||||
neither blockage function is written. */
|
||||
unit->needs_range_function
|
||||
= (unit->needs_blockage_function
|
||||
|| GET_CODE (max_blockage) != CONST_STRING);
|
||||
|
||||
if (unit->needs_range_function)
|
||||
{
|
||||
/* Compute the blockage range function and make an attribute
|
||||
for writing it's value. */
|
||||
newexp = operate_exp (RANGE_OP, min_blockage, max_blockage);
|
||||
newexp = simplify_knowing (newexp, unit->condexp);
|
||||
|
||||
str = attr_printf (strlen (unit->name) + 20,
|
||||
"*%s_unit_blockage_range", unit->name);
|
||||
make_internal_attr (str, newexp, 4);
|
||||
}
|
||||
|
||||
str = attr_printf (strlen (unit->name) + 20, "*%s_unit_ready_cost",
|
||||
unit->name);
|
||||
}
|
||||
else
|
||||
str = "*result_ready_cost";
|
||||
|
||||
/* Make an attribute for the ready_cost function. Simplifying
|
||||
further with simplify_by_exploding doesn't win. */
|
||||
make_internal_attr (str, readycost, 0);
|
||||
}
|
||||
|
||||
@ -1804,7 +1991,8 @@ expand_units ()
|
||||
{
|
||||
rtx caseexp;
|
||||
|
||||
if (unit->min_busy_delay == unit->max_busy_delay)
|
||||
if (! unit->needs_conflict_function
|
||||
&& ! unit->needs_blockage_function)
|
||||
continue;
|
||||
|
||||
caseexp = rtx_alloc (COND);
|
||||
@ -1833,6 +2021,21 @@ expand_units ()
|
||||
}
|
||||
}
|
||||
|
||||
/* Simplify EXP given KNOWN_TRUE. */
|
||||
|
||||
static rtx
|
||||
simplify_knowing (exp, known_true)
|
||||
rtx exp, known_true;
|
||||
{
|
||||
if (GET_CODE (exp) != CONST_STRING)
|
||||
{
|
||||
exp = attr_rtx (IF_THEN_ELSE, known_true, exp,
|
||||
make_numeric_value (max_attr_value (exp)));
|
||||
exp = simplify_by_exploding (exp);
|
||||
}
|
||||
return exp;
|
||||
}
|
||||
|
||||
/* Translate the CONST_STRING expressions in X to change the encoding of
|
||||
value. On input, the value is a bitmask with a one bit for each unit
|
||||
used; on output, the value is the unit number (zero based) if one
|
||||
@ -3170,11 +3373,11 @@ simplify_by_exploding (exp)
|
||||
rtx list = 0, link, condexp, defval;
|
||||
struct dimension *space;
|
||||
rtx *condtest, *condval;
|
||||
int i, j, total, ndim;
|
||||
int i, j, total, ndim = 0;
|
||||
int most_tests, num_marks, new_marks;
|
||||
|
||||
/* Locate all the EQ_ATTR expressions. */
|
||||
if (! find_and_mark_used_attributes (exp, &list))
|
||||
if (! find_and_mark_used_attributes (exp, &list, &ndim) || ndim == 0)
|
||||
{
|
||||
unmark_used_attributes (list, 0, 0);
|
||||
return exp;
|
||||
@ -3186,9 +3389,6 @@ simplify_by_exploding (exp)
|
||||
cover the domain of the attribute. This makes the expanded COND form
|
||||
order independent. */
|
||||
|
||||
ndim = 0;
|
||||
for (link = list; link; link = XEXP (link, 1))
|
||||
ndim++;
|
||||
space = (struct dimension *) alloca (ndim * sizeof (struct dimension));
|
||||
|
||||
total = 1;
|
||||
@ -3289,6 +3489,10 @@ simplify_by_exploding (exp)
|
||||
if (num_marks == 0)
|
||||
return exp;
|
||||
|
||||
/* If all values are the default, use that. */
|
||||
if (total == most_tests)
|
||||
return defval;
|
||||
|
||||
/* Make a COND with the most common constant value the default. (A more
|
||||
complex method where tests with the same value were combined didn't
|
||||
seem to improve things.) */
|
||||
@ -3311,8 +3515,9 @@ simplify_by_exploding (exp)
|
||||
tests have known value. */
|
||||
|
||||
static int
|
||||
find_and_mark_used_attributes (exp, terms)
|
||||
find_and_mark_used_attributes (exp, terms, nterms)
|
||||
rtx exp, *terms;
|
||||
int *nterms;
|
||||
{
|
||||
int i;
|
||||
|
||||
@ -3325,28 +3530,29 @@ find_and_mark_used_attributes (exp, terms)
|
||||
XEXP (link, 0) = exp;
|
||||
XEXP (link, 1) = *terms;
|
||||
*terms = link;
|
||||
*nterms += 1;
|
||||
MEM_VOLATILE_P (exp) = 1;
|
||||
}
|
||||
case CONST_STRING:
|
||||
return 1;
|
||||
|
||||
case IF_THEN_ELSE:
|
||||
if (! find_and_mark_used_attributes (XEXP (exp, 2), terms))
|
||||
if (! find_and_mark_used_attributes (XEXP (exp, 2), terms, nterms))
|
||||
return 0;
|
||||
case IOR:
|
||||
case AND:
|
||||
if (! find_and_mark_used_attributes (XEXP (exp, 1), terms))
|
||||
if (! find_and_mark_used_attributes (XEXP (exp, 1), terms, nterms))
|
||||
return 0;
|
||||
case NOT:
|
||||
if (! find_and_mark_used_attributes (XEXP (exp, 0), terms))
|
||||
if (! find_and_mark_used_attributes (XEXP (exp, 0), terms, nterms))
|
||||
return 0;
|
||||
return 1;
|
||||
|
||||
case COND:
|
||||
for (i = 0; i < XVECLEN (exp, 0); i++)
|
||||
if (! find_and_mark_used_attributes (XVECEXP (exp, 0, i), terms))
|
||||
if (! find_and_mark_used_attributes (XVECEXP (exp, 0, i), terms, nterms))
|
||||
return 0;
|
||||
if (! find_and_mark_used_attributes (XEXP (exp, 1), terms))
|
||||
if (! find_and_mark_used_attributes (XEXP (exp, 1), terms, nterms))
|
||||
return 0;
|
||||
return 1;
|
||||
}
|
||||
@ -3935,15 +4141,21 @@ gen_unit (def)
|
||||
{
|
||||
struct function_unit *unit;
|
||||
struct function_unit_op *op;
|
||||
char *name = XSTR (def, 0);
|
||||
int multiplicity = XINT (def, 1);
|
||||
int simultaneity = XINT (def, 2);
|
||||
rtx condexp = XEXP (def, 3);
|
||||
int ready_cost = MAX (XINT (def, 4), 1);
|
||||
int issue_delay = MAX (XINT (def, 5), 1);
|
||||
|
||||
/* See if we have already seen this function unit. If so, check that
|
||||
the multiplicity and simultaneity values are the same. If not, make
|
||||
a structure for this function unit. */
|
||||
for (unit = units; unit; unit = unit->next)
|
||||
if (! strcmp (unit->name, XSTR (def, 0)))
|
||||
if (! strcmp (unit->name, name))
|
||||
{
|
||||
if (unit->multiplicity != XINT (def, 1)
|
||||
|| unit->simultaneity != XINT (def, 2))
|
||||
if (unit->multiplicity != multiplicity
|
||||
|| unit->simultaneity != simultaneity)
|
||||
fatal ("Differing specifications given for `%s' function unit.",
|
||||
unit->name);
|
||||
break;
|
||||
@ -3952,27 +4164,28 @@ gen_unit (def)
|
||||
if (unit == 0)
|
||||
{
|
||||
unit = (struct function_unit *) xmalloc (sizeof (struct function_unit));
|
||||
unit->name = XSTR (def, 0);
|
||||
unit->multiplicity = XINT (def, 1);
|
||||
unit->simultaneity = XINT (def, 2);
|
||||
unit->name = name;
|
||||
unit->multiplicity = multiplicity;
|
||||
unit->simultaneity = simultaneity;
|
||||
unit->issue_delay.min = unit->issue_delay.max = issue_delay;
|
||||
unit->num = num_units++;
|
||||
unit->num_opclasses = 0;
|
||||
unit->condexp = false_rtx;
|
||||
unit->ops = 0;
|
||||
unit->next = units;
|
||||
unit->min_busy_delay = unit->max_busy_delay = XINT (def, 5);
|
||||
units = unit;
|
||||
}
|
||||
|
||||
/* Make a new operation class structure entry and initialize it. */
|
||||
op = (struct function_unit_op *) xmalloc (sizeof (struct function_unit_op));
|
||||
op->condexp = XEXP (def, 3);
|
||||
op->condexp = condexp;
|
||||
op->num = unit->num_opclasses++;
|
||||
op->ready = XINT (def, 4);
|
||||
op->ready = ready_cost;
|
||||
op->issue_delay = issue_delay;
|
||||
op->next = unit->ops;
|
||||
unit->ops = op;
|
||||
|
||||
/* Set our busy expression based on whether or not an optional conflict
|
||||
/* Set our issue expression based on whether or not an optional conflict
|
||||
vector was specified. */
|
||||
if (XVEC (def, 6))
|
||||
{
|
||||
@ -3983,17 +4196,13 @@ gen_unit (def)
|
||||
for (i = 0; i < XVECLEN (def, 6); i++)
|
||||
orexp = insert_right_side (IOR, orexp, XVECEXP (def, 6, i), -2);
|
||||
|
||||
op->busyexp = attr_rtx (IF_THEN_ELSE, orexp,
|
||||
make_numeric_value (XINT (def, 5)),
|
||||
make_numeric_value (0));
|
||||
unit->min_busy_delay = MIN (unit->min_busy_delay, 0);
|
||||
unit->max_busy_delay = MAX (unit->max_busy_delay, XINT (def, 5));
|
||||
op->conflict_exp = orexp;
|
||||
extend_range (&unit->issue_delay, 1, issue_delay);
|
||||
}
|
||||
else
|
||||
{
|
||||
op->busyexp = make_numeric_value (XINT (def, 5));
|
||||
unit->min_busy_delay = MIN (unit->min_busy_delay, XINT (def, 5));
|
||||
unit->max_busy_delay = MAX (unit->max_busy_delay, XINT (def, 5));
|
||||
op->conflict_exp = true_rtx;
|
||||
extend_range (&unit->issue_delay, issue_delay, issue_delay);
|
||||
}
|
||||
|
||||
/* Merge our conditional into that of the function unit so we can determine
|
||||
@ -4249,6 +4458,14 @@ max_attr_value (exp)
|
||||
current_max = n;
|
||||
}
|
||||
|
||||
else if (GET_CODE (exp) == IF_THEN_ELSE)
|
||||
{
|
||||
current_max = max_attr_value (XEXP (exp, 1));
|
||||
n = max_attr_value (XEXP (exp, 2));
|
||||
if (n > current_max)
|
||||
current_max = n;
|
||||
}
|
||||
|
||||
else
|
||||
abort ();
|
||||
|
||||
@ -4331,10 +4548,12 @@ write_attr_get (attr)
|
||||
|
||||
/* Write out start of function, then all values with explicit `case' lines,
|
||||
then a `default', then the value with the most uses. */
|
||||
if (attr->is_numeric)
|
||||
printf ("int\n");
|
||||
else
|
||||
if (!attr->is_numeric)
|
||||
printf ("enum attr_%s\n", attr->name);
|
||||
else if (attr->unsigned_p)
|
||||
printf ("unsigned int\n");
|
||||
else
|
||||
printf ("int\n");
|
||||
|
||||
/* If the attribute name starts with a star, the remainder is the name of
|
||||
the subroutine to use, instead of `get_attr_...'. */
|
||||
@ -4583,7 +4802,12 @@ write_attr_valueq (attr, s)
|
||||
char *s;
|
||||
{
|
||||
if (attr->is_numeric)
|
||||
printf ("%s", s);
|
||||
{
|
||||
printf ("%s", s);
|
||||
/* Make the blockage range values easier to read. */
|
||||
if (strlen (s) > 1)
|
||||
printf (" /* 0x%x */", atoi (s));
|
||||
}
|
||||
else
|
||||
{
|
||||
write_upcase (attr->name);
|
||||
@ -4758,107 +4982,27 @@ static void
|
||||
write_function_unit_info ()
|
||||
{
|
||||
struct function_unit *unit;
|
||||
struct attr_desc *case_attr, *attr;
|
||||
struct attr_value *av, *common_av;
|
||||
rtx value;
|
||||
char *str;
|
||||
int using_case;
|
||||
int i;
|
||||
|
||||
/* Write out conflict routines for function units. Don't bother writing
|
||||
one if there is only one busy value. */
|
||||
one if there is only one issue delay value. */
|
||||
|
||||
for (unit = units; unit; unit = unit->next)
|
||||
{
|
||||
/* Record the maximum busy cost. */
|
||||
unit->max_busy_cost = make_numeric_value (unit->max_busy_delay);
|
||||
if (unit->needs_blockage_function)
|
||||
write_complex_function (unit, "blockage", "block");
|
||||
|
||||
/* If the minimum and maximum conflict costs are the same, there
|
||||
is only one value, so we don't need a function. */
|
||||
if (unit->min_busy_delay == unit->max_busy_delay)
|
||||
if (! unit->needs_conflict_function)
|
||||
{
|
||||
unit->needs_conflict_function = 0;
|
||||
unit->default_cost = unit->max_busy_cost;
|
||||
unit->default_cost = make_numeric_value (unit->issue_delay.max);
|
||||
continue;
|
||||
}
|
||||
|
||||
/* The function first computes the case from the candidate insn. */
|
||||
unit->needs_conflict_function = 1;
|
||||
unit->default_cost = make_numeric_value (0);
|
||||
|
||||
printf ("static int\n");
|
||||
printf ("%s_unit_conflict_cost (executing_insn, candidate_insn)\n",
|
||||
unit->name);
|
||||
printf (" rtx executing_insn;\n");
|
||||
printf (" rtx candidate_insn;\n");
|
||||
printf ("{\n");
|
||||
printf (" rtx insn;\n");
|
||||
printf (" int casenum;\n\n");
|
||||
printf (" insn = candidate_insn;\n");
|
||||
printf (" switch (recog_memoized (insn))\n");
|
||||
printf (" {\n");
|
||||
|
||||
/* Write the `switch' statement to get the case value. */
|
||||
str = (char *) alloca (strlen (unit->name) + 10);
|
||||
sprintf (str, "*%s_cases", unit->name);
|
||||
case_attr = find_attr (str, 0);
|
||||
if (! case_attr) abort ();
|
||||
common_av = find_most_used (case_attr);
|
||||
|
||||
for (av = case_attr->first_value; av; av = av->next)
|
||||
if (av != common_av)
|
||||
write_attr_case (case_attr, av, 1,
|
||||
"casenum =", ";", 4, unit->condexp);
|
||||
|
||||
write_attr_case (case_attr, common_av, 0,
|
||||
"casenum =", ";", 4, unit->condexp);
|
||||
printf (" }\n\n");
|
||||
|
||||
/* Now write an outer switch statement on each case. Then write
|
||||
the tests on the executing function within each. */
|
||||
printf (" insn = executing_insn;\n");
|
||||
printf (" switch (casenum)\n");
|
||||
printf (" {\n");
|
||||
|
||||
for (i = 0; i < unit->num_opclasses; i++)
|
||||
{
|
||||
/* Ensure using this case. */
|
||||
using_case = 0;
|
||||
for (av = case_attr->first_value; av; av = av->next)
|
||||
if (av->num_insns
|
||||
&& contained_in_p (make_numeric_value (i), av->value))
|
||||
using_case = 1;
|
||||
|
||||
if (! using_case)
|
||||
continue;
|
||||
|
||||
printf (" case %d:\n", i);
|
||||
sprintf (str, "*%s_case_%d", unit->name, i);
|
||||
attr = find_attr (str, 0);
|
||||
if (! attr) abort ();
|
||||
|
||||
/* If single value, just write it. */
|
||||
value = find_single_value (attr);
|
||||
if (value)
|
||||
write_attr_set (attr, 6, value, "return", ";\n", true_rtx, -2);
|
||||
else
|
||||
{
|
||||
common_av = find_most_used (attr);
|
||||
printf (" switch (recog_memoized (insn))\n");
|
||||
printf ("\t{\n");
|
||||
|
||||
for (av = attr->first_value; av; av = av->next)
|
||||
if (av != common_av)
|
||||
write_attr_case (attr, av, 1,
|
||||
"return", ";", 8, unit->condexp);
|
||||
|
||||
write_attr_case (attr, common_av, 0,
|
||||
"return", ";", 8, unit->condexp);
|
||||
printf (" }\n\n");
|
||||
}
|
||||
}
|
||||
|
||||
printf (" }\n}\n\n");
|
||||
write_complex_function (unit, "conflict_cost", "cost");
|
||||
}
|
||||
|
||||
/* Now that all functions have been written, write the table describing
|
||||
@ -4875,13 +5019,25 @@ write_function_unit_info ()
|
||||
if (unit->num == i)
|
||||
break;
|
||||
|
||||
printf (" {\"%s\", %d, %d, %d, %s, %s, %s_unit_ready_cost, ",
|
||||
printf (" {\"%s\", %d, %d, %d, %s, %d, %s_unit_ready_cost, ",
|
||||
unit->name, 1 << unit->num, unit->multiplicity,
|
||||
unit->simultaneity, XSTR (unit->default_cost, 0),
|
||||
XSTR (unit->max_busy_cost, 0), unit->name);
|
||||
unit->issue_delay.max, unit->name);
|
||||
|
||||
if (unit->needs_conflict_function)
|
||||
printf ("%s_unit_conflict_cost", unit->name);
|
||||
printf ("%s_unit_conflict_cost, ", unit->name);
|
||||
else
|
||||
printf ("0, ");
|
||||
|
||||
printf ("%d, ", unit->max_blockage);
|
||||
|
||||
if (unit->needs_range_function)
|
||||
printf ("%s_unit_blockage_range, ", unit->name);
|
||||
else
|
||||
printf ("0, ");
|
||||
|
||||
if (unit->needs_blockage_function)
|
||||
printf ("%s_unit_blockage", unit->name);
|
||||
else
|
||||
printf ("0");
|
||||
|
||||
@ -4890,6 +5046,93 @@ write_function_unit_info ()
|
||||
|
||||
printf ("};\n\n");
|
||||
}
|
||||
|
||||
static void
|
||||
write_complex_function (unit, name, connection)
|
||||
struct function_unit *unit;
|
||||
char *name, *connection;
|
||||
{
|
||||
struct attr_desc *case_attr, *attr;
|
||||
struct attr_value *av, *common_av;
|
||||
rtx value;
|
||||
char *str;
|
||||
int using_case;
|
||||
int i;
|
||||
|
||||
printf ("static int\n");
|
||||
printf ("%s_unit_%s (executing_insn, candidate_insn)\n",
|
||||
unit->name, name);
|
||||
printf (" rtx executing_insn;\n");
|
||||
printf (" rtx candidate_insn;\n");
|
||||
printf ("{\n");
|
||||
printf (" rtx insn;\n");
|
||||
printf (" int casenum;\n\n");
|
||||
printf (" insn = candidate_insn;\n");
|
||||
printf (" switch (recog_memoized (insn))\n");
|
||||
printf (" {\n");
|
||||
|
||||
/* Write the `switch' statement to get the case value. */
|
||||
str = (char *) alloca (strlen (unit->name) + strlen (name) + strlen (connection) + 10);
|
||||
sprintf (str, "*%s_cases", unit->name);
|
||||
case_attr = find_attr (str, 0);
|
||||
if (! case_attr) abort ();
|
||||
common_av = find_most_used (case_attr);
|
||||
|
||||
for (av = case_attr->first_value; av; av = av->next)
|
||||
if (av != common_av)
|
||||
write_attr_case (case_attr, av, 1,
|
||||
"casenum =", ";", 4, unit->condexp);
|
||||
|
||||
write_attr_case (case_attr, common_av, 0,
|
||||
"casenum =", ";", 4, unit->condexp);
|
||||
printf (" }\n\n");
|
||||
|
||||
/* Now write an outer switch statement on each case. Then write
|
||||
the tests on the executing function within each. */
|
||||
printf (" insn = executing_insn;\n");
|
||||
printf (" switch (casenum)\n");
|
||||
printf (" {\n");
|
||||
|
||||
for (i = 0; i < unit->num_opclasses; i++)
|
||||
{
|
||||
/* Ensure using this case. */
|
||||
using_case = 0;
|
||||
for (av = case_attr->first_value; av; av = av->next)
|
||||
if (av->num_insns
|
||||
&& contained_in_p (make_numeric_value (i), av->value))
|
||||
using_case = 1;
|
||||
|
||||
if (! using_case)
|
||||
continue;
|
||||
|
||||
printf (" case %d:\n", i);
|
||||
sprintf (str, "*%s_%s_%d", unit->name, connection, i);
|
||||
attr = find_attr (str, 0);
|
||||
if (! attr) abort ();
|
||||
|
||||
/* If single value, just write it. */
|
||||
value = find_single_value (attr);
|
||||
if (value)
|
||||
write_attr_set (attr, 6, value, "return", ";\n", true_rtx, -2);
|
||||
else
|
||||
{
|
||||
common_av = find_most_used (attr);
|
||||
printf (" switch (recog_memoized (insn))\n");
|
||||
printf ("\t{\n");
|
||||
|
||||
for (av = attr->first_value; av; av = av->next)
|
||||
if (av != common_av)
|
||||
write_attr_case (attr, av, 1,
|
||||
"return", ";", 8, unit->condexp);
|
||||
|
||||
write_attr_case (attr, common_av, 0,
|
||||
"return", ";", 8, unit->condexp);
|
||||
printf (" }\n\n");
|
||||
}
|
||||
}
|
||||
|
||||
printf (" }\n}\n\n");
|
||||
}
|
||||
|
||||
/* This page contains miscellaneous utility routines. */
|
||||
|
||||
@ -4996,6 +5239,7 @@ make_internal_attr (name, value, special)
|
||||
attr->is_const = 0;
|
||||
attr->is_special = (special & 1) != 0;
|
||||
attr->negative_ok = (special & 2) != 0;
|
||||
attr->unsigned_p = (special & 4) != 0;
|
||||
attr->default_val = get_attr_value (value, attr, -2);
|
||||
}
|
||||
|
||||
@ -5067,6 +5311,16 @@ make_numeric_value (n)
|
||||
return exp;
|
||||
}
|
||||
|
||||
static void
|
||||
extend_range (range, min, max)
|
||||
struct range *range;
|
||||
int min;
|
||||
int max;
|
||||
{
|
||||
if (range->min > min) range->min = min;
|
||||
if (range->max < max) range->max = max;
|
||||
}
|
||||
|
||||
char *
|
||||
xrealloc (ptr, size)
|
||||
char *ptr;
|
||||
|
||||
Loading…
Reference in New Issue
Block a user