/* Generate code from machine description to compute values of attributes.
- Copyright (C) 1991 Free Software Foundation, Inc.
- Contributed by Richard Kenner (kenner@nyu.edu)
+ Copyright (C) 1991, 1993, 1994, 1995, 1996 Free Software Foundation, Inc.
+ Contributed by Richard Kenner (kenner@vlsi1.ultra.nyu.edu)
This file is part of GNU CC.
You should have received a copy of the GNU General Public License
along with GNU CC; see the file COPYING. If not, write to
-the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
+the Free Software Foundation, 59 Temple Place - Suite 330,
+Boston, MA 02111-1307, USA. */
/* This program handles insn attributes and the DEFINE_DELAY and
DEFINE_FUNCTION_UNIT definitions.
EQ_ATTR rtx is true if !volatil and false if volatil. */
-#include "gvarargs.h"
-#include "config.h"
+#include "hconfig.h"
+/* varargs must always be included after *config.h. */
+#ifdef __STDC__
+#include <stdarg.h>
+#else
+#include <varargs.h>
+#endif
#include "rtl.h"
-#include "obstack.h"
#include "insn-config.h" /* For REGISTER_CONSTRAINTS */
#include <stdio.h>
+#ifndef VMS
+#ifndef USG
+#include <sys/time.h>
+#include <sys/resource.h>
+#endif
+#endif
+
+/* We must include obstack.h after <sys/time.h>, to avoid lossage with
+ /usr/include/sys/stdtypes.h on Sun OS 4.x. */
+#include "obstack.h"
+
static struct obstack obstack, obstack1, obstack2;
struct obstack *rtl_obstack = &obstack;
struct obstack *hash_obstack = &obstack1;
struct insn_def
{
- int insn_code; /* Instruction number. */
- int insn_index; /* Expression numer in file, for errors. */
- struct insn_def *next; /* Next insn in chain. */
- rtx def; /* The DEFINE_... */
+ int insn_code; /* Instruction number. */
+ int insn_index; /* Expression numer in file, for errors. */
+ struct insn_def *next; /* Next insn in chain. */
+ rtx def; /* The DEFINE_... */
int num_alternatives; /* Number of alternatives. */
- int vec_idx; /* Index of attribute vector in `def'. */
+ int vec_idx; /* Index of attribute vector in `def'. */
};
/* Once everything has been read in, we store in each attribute value a list
struct attr_desc
{
- char *name; /* Name of attribute. */
- struct attr_desc *next; /* Next attribute. */
- int is_numeric; /* Values of this attribute are numeric. */
+ char *name; /* Name of attribute. */
+ 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. */
- struct attr_value *default_val; /* Default value for this attribute. */
+ int is_special; /* Don't call `write_attr_set'. */
+ struct attr_value *first_value; /* First value of this attribute. */
+ struct attr_value *default_val; /* Default value for this attribute. */
};
#define NULL_ATTR (struct attr_desc *) NULL
struct delay_desc
{
rtx def; /* DEFINE_DELAY expression. */
- struct delay_desc *next; /* Next DEFINE_DELAY. */
+ struct delay_desc *next; /* Next DEFINE_DELAY. */
int num; /* Number of DEFINE_DELAY, starting at 1. */
};
int multiplicity; /* Number of units of this type. */
int simultaneity; /* Maximum number of simultaneous insns
on this function unit or 0 if unlimited. */
- rtx condexp; /* Expression TRUE for insn needing unit. */
+ rtx condexp; /* Expression TRUE for insn needing unit. */
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. */
+ int needs_range_function; /* Nonzero if blockage range function needed.*/
rtx default_cost; /* Conflict cost, if constant. */
struct range issue_delay; /* Range of issue delay values. */
int max_blockage; /* Maximum time an insn blocks the unit. */
static struct delay_desc *delays;
static struct function_unit *units;
-/* Other variables. */
+/* An expression where all the unknown terms are EQ_ATTR tests can be
+ rearranged into a COND provided we can enumerate all possible
+ combinations of the unknown values. The set of combinations become the
+ tests of the COND; the value of the expression given that combination is
+ computed and becomes the corresponding value. To do this, we must be
+ able to enumerate all values for each attribute used in the expression
+ (currently, we give up if we find a numeric attribute).
+
+ If the set of EQ_ATTR tests used in an expression tests the value of N
+ different attributes, the list of all possible combinations can be made
+ by walking the N-dimensional attribute space defined by those
+ attributes. We record each of these as a struct dimension.
+
+ The algorithm relies on sharing EQ_ATTR nodes: if two nodes in an
+ expression are the same, the will also have the same address. We find
+ all the EQ_ATTR nodes by marking them MEM_VOLATILE_P. This bit later
+ represents the value of an EQ_ATTR node, so once all nodes are marked,
+ they are also given an initial value of FALSE.
+
+ We then separate the set of EQ_ATTR nodes into dimensions for each
+ attribute and put them on the VALUES list. Terms are added as needed by
+ `add_values_to_cover' so that all possible values of the attribute are
+ tested.
+
+ Each dimension also has a current value. This is the node that is
+ currently considered to be TRUE. If this is one of the nodes added by
+ `add_values_to_cover', all the EQ_ATTR tests in the original expression
+ will be FALSE. Otherwise, only the CURRENT_VALUE will be true.
+
+ NUM_VALUES is simply the length of the VALUES list and is there for
+ convenience.
+
+ Once the dimensions are created, the algorithm enumerates all possible
+ values and computes the current value of the given expression. */
+
+struct dimension
+{
+ struct attr_desc *attr; /* Attribute for this dimension. */
+ rtx values; /* List of attribute values used. */
+ rtx current_value; /* Position in the list for the TRUE value. */
+ int num_values; /* Length of the values list. */
+};
+
+/* Other variables. */
static int insn_code_number;
static int insn_index_number;
static int must_extract;
static int must_constrain;
static int address_used;
+static int length_used;
static int num_delays;
static int have_annul_true, have_annul_false;
static int num_units;
+static int num_insn_ents;
/* Used as operand to `operate_exp': */
/* These are referenced by rtlanal.c and hence need to be defined somewhere.
They won't actually be used. */
-rtx frame_pointer_rtx, stack_pointer_rtx, arg_pointer_rtx;
+rtx frame_pointer_rtx, hard_frame_pointer_rtx, stack_pointer_rtx;
+rtx arg_pointer_rtx;
-static rtx attr_rtx ();
+static rtx attr_rtx PVPROTO((enum rtx_code, ...));
+#ifdef HAVE_VPRINTF
+static char *attr_printf PVPROTO((int, char *, ...));
+#else
static char *attr_printf ();
-static char *attr_string ();
-static rtx check_attr_test ();
-static rtx check_attr_value ();
-static rtx convert_set_attr_alternative ();
-static rtx convert_set_attr ();
-static void check_defs ();
-static rtx convert_const_symbol_ref ();
-static rtx make_canonical ();
-static struct attr_value *get_attr_value ();
-static rtx copy_rtx_unchanging ();
-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 ();
-static void make_length_attrs ();
-static rtx identity_fn ();
-static rtx zero_fn ();
-static rtx one_fn ();
-static rtx max_fn ();
-static rtx simplify_cond ();
-static rtx simplify_by_alternatives ();
-static rtx simplify_by_exploding ();
-static int find_and_mark_used_attributes ();
-static void unmark_used_attributes ();
-static int add_values_to_cover ();
-static int increment_current_value ();
-static rtx test_for_current_value ();
-static rtx simplify_with_current_value ();
-static rtx simplify_with_current_value_aux ();
-static void remove_insn_ent ();
-static void insert_insn_ent ();
-static rtx insert_right_side ();
-static rtx make_alternative_compare ();
-static int compute_alternative_mask ();
-static rtx evaluate_eq_attr ();
-static rtx simplify_and_tree ();
-static rtx simplify_or_tree ();
-static rtx simplify_test_exp ();
-static void optimize_attrs ();
-static void gen_attr ();
-static int count_alternatives ();
-static int compares_alternatives_p ();
-static int contained_in_p ();
-static void gen_insn ();
-static void gen_delay ();
-static void gen_unit ();
-static void write_test_expr ();
-static int max_attr_value ();
-static void walk_attr_value ();
-static void write_attr_get ();
-static rtx eliminate_known_true ();
-static void write_attr_set ();
-static void write_attr_case ();
-static void write_attr_value ();
-static void write_attr_valueq ();
-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 ();
-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 ();
+#endif
+
+static char *attr_string PROTO((char *, int));
+static rtx check_attr_test PROTO((rtx, int));
+static rtx check_attr_value PROTO((rtx, struct attr_desc *));
+static rtx convert_set_attr_alternative PROTO((rtx, int, int, int));
+static rtx convert_set_attr PROTO((rtx, int, int, int));
+static void check_defs PROTO((void));
+static rtx convert_const_symbol_ref PROTO((rtx, struct attr_desc *));
+static rtx make_canonical PROTO((struct attr_desc *, rtx));
+static struct attr_value *get_attr_value PROTO((rtx, struct attr_desc *, int));
+static rtx copy_rtx_unchanging PROTO((rtx));
+static rtx copy_boolean PROTO((rtx));
+static void expand_delays PROTO((void));
+static rtx operate_exp PROTO((enum operator, rtx, rtx));
+static void expand_units PROTO((void));
+static rtx simplify_knowing PROTO((rtx, rtx));
+static rtx encode_units_mask PROTO((rtx));
+static void fill_attr PROTO((struct attr_desc *));
+/* dpx2 compiler chokes if we specify the arg types of the args. */
+static rtx substitute_address PROTO((rtx, rtx (*) (), rtx (*) ()));
+static void make_length_attrs PROTO((void));
+static rtx identity_fn PROTO((rtx));
+static rtx zero_fn PROTO((rtx));
+static rtx one_fn PROTO((rtx));
+static rtx max_fn PROTO((rtx));
+static rtx simplify_cond PROTO((rtx, int, int));
+static rtx simplify_by_alternatives PROTO((rtx, int, int));
+static rtx simplify_by_exploding PROTO((rtx));
+static int find_and_mark_used_attributes PROTO((rtx, rtx *, int *));
+static void unmark_used_attributes PROTO((rtx, struct dimension *, int));
+static int add_values_to_cover PROTO((struct dimension *));
+static int increment_current_value PROTO((struct dimension *, int));
+static rtx test_for_current_value PROTO((struct dimension *, int));
+static rtx simplify_with_current_value PROTO((rtx, struct dimension *, int));
+static rtx simplify_with_current_value_aux PROTO((rtx));
+static void clear_struct_flag PROTO((rtx));
+static int count_sub_rtxs PROTO((rtx, int));
+static void remove_insn_ent PROTO((struct attr_value *, struct insn_ent *));
+static void insert_insn_ent PROTO((struct attr_value *, struct insn_ent *));
+static rtx insert_right_side PROTO((enum rtx_code, rtx, rtx, int, int));
+static rtx make_alternative_compare PROTO((int));
+static int compute_alternative_mask PROTO((rtx, enum rtx_code));
+static rtx evaluate_eq_attr PROTO((rtx, rtx, int, int));
+static rtx simplify_and_tree PROTO((rtx, rtx *, int, int));
+static rtx simplify_or_tree PROTO((rtx, rtx *, int, int));
+static rtx simplify_test_exp PROTO((rtx, int, int));
+static void optimize_attrs PROTO((void));
+static void gen_attr PROTO((rtx));
+static int count_alternatives PROTO((rtx));
+static int compares_alternatives_p PROTO((rtx));
+static int contained_in_p PROTO((rtx, rtx));
+static void gen_insn PROTO((rtx));
+static void gen_delay PROTO((rtx));
+static void gen_unit PROTO((rtx));
+static void write_test_expr PROTO((rtx, int));
+static int max_attr_value PROTO((rtx));
+static void walk_attr_value PROTO((rtx));
+static void write_attr_get PROTO((struct attr_desc *));
+static rtx eliminate_known_true PROTO((rtx, rtx, int, int));
+static void write_attr_set PROTO((struct attr_desc *, int, rtx, char *,
+ char *, rtx, int, int));
+static void write_attr_case PROTO((struct attr_desc *, struct attr_value *,
+ int, char *, char *, int, rtx));
+static void write_attr_valueq PROTO((struct attr_desc *, char *));
+static void write_attr_value PROTO((struct attr_desc *, rtx));
+static void write_upcase PROTO((char *));
+static void write_indent PROTO((int));
+static void write_eligible_delay PROTO((char *));
+static void write_function_unit_info PROTO((void));
+static void write_complex_function PROTO((struct function_unit *, char *,
+ char *));
+static int n_comma_elts PROTO((char *));
+static char *next_comma_elt PROTO((char **));
+static struct attr_desc *find_attr PROTO((char *, int));
+static void make_internal_attr PROTO((char *, rtx, int));
+static struct attr_value *find_most_used PROTO((struct attr_desc *));
+static rtx find_single_value PROTO((struct attr_desc *));
+static rtx make_numeric_value PROTO((int));
+static void extend_range PROTO((struct range *, int, int));
+char *xrealloc PROTO((char *, unsigned));
+char *xmalloc PROTO((unsigned));
#define oballoc(size) obstack_alloc (hash_obstack, size)
/*VARARGS1*/
static rtx
-attr_rtx (va_alist)
- va_dcl
+attr_rtx VPROTO((enum rtx_code code, ...))
{
- va_list p;
+#ifndef __STDC__
enum rtx_code code;
+#endif
+ va_list p;
register int i; /* Array indices... */
register char *fmt; /* Current rtx's format... */
register rtx rt_val; /* RTX to return to caller... */
register struct attr_hash *h;
struct obstack *old_obstack = rtl_obstack;
- va_start (p);
+ VA_START (p, code);
+
+#ifndef __STDC__
code = va_arg (p, enum rtx_code);
+#endif
/* 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
/*VARARGS2*/
static char *
-attr_printf (va_alist)
- va_dcl
+attr_printf VPROTO((register int len, char *fmt, ...))
{
- va_list p;
+#ifndef __STDC__
register int len;
- register char *fmt;
+ char *fmt;
+#endif
+ va_list p;
register char *str;
- /* Print the string into a temporary location. */
- va_start (p);
+ VA_START (p, fmt);
+
+#ifndef __STDC__
len = va_arg (p, int);
- str = (char *) alloca (len);
fmt = va_arg (p, char *);
+#endif
+
+ /* Print the string into a temporary location. */
+ str = (char *) alloca (len);
vsprintf (str, fmt, p);
va_end (p);
while ((p = next_comma_elt (&name_ptr)) != NULL)
{
newexp = attr_eq (XSTR (exp, 0), p);
- orexp = insert_right_side (IOR, orexp, newexp, -2);
+ orexp = insert_right_side (IOR, orexp, newexp, -2, -2);
}
return check_attr_test (orexp, is_const);
}
break;
+ case ATTR_FLAG:
+ break;
+
case CONST_INT:
/* Either TRUE or FALSE. */
if (XWINT (exp, 0))
/* A constant SYMBOL_REF is valid as a constant attribute test and
is expanded later by make_canonical into a COND. */
return attr_rtx (SYMBOL_REF, XSTR (exp, 0));
- /* Otherwise, fall through... */
+ /* Otherwise, fall through... */
default:
- fatal ("Illegal operation `%s' for attribute value",
+ fatal ("Invalid operation `%s' for attribute value",
GET_RTX_NAME (GET_CODE (exp)));
}
\f
/* Scan all definitions, checking for validity. Also, convert any SET_ATTR
and SET_ATTR_ALTERNATIVE expressions to the corresponding SET
- expressions. */
+ expressions. */
static void
check_defs ()
int allsame = 1;
rtx defval;
- /* First, check for degenerate 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));
for (unit = units; unit; unit = unit->next)
{
- 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)
* sizeof (struct function_unit_op *));
for (unit = units, i = 0; unit; i += unit->num_opclasses, unit = unit->next)
- bcopy (unit_ops[unit->num], &op_array[i],
+ bcopy ((char *) unit_ops[unit->num], (char *) &op_array[i],
unit->num_opclasses * sizeof (struct function_unit_op *));
/* Compute the ready cost function for each unit by computing the
if (op->ready <= 1)
break;
else if (op->ready == value)
- orexp = insert_right_side (IOR, orexp, op->condexp, -2);
+ orexp = insert_right_side (IOR, orexp, op->condexp, -2, -2);
else
{
XVECEXP (readycost, 0, nvalues * 2) = orexp;
candidate insn, so in the expressions below, C is a known
term and E is an unknown term.
+ We compute the blockage cost for each E for every possible C.
+ Thus OP represents E, and READYCOST is a list of values for
+ every possible C.
+
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)".
for (op = unit->ops; op; op = op->next)
{
- rtx blockage = readycost;
- int delay = op->ready - 1;
+ rtx blockage = operate_exp (POS_MINUS_OP, readycost,
+ make_numeric_value (1));
if (unit->simultaneity != 0)
- delay = MIN (delay, ((unit->simultaneity - 1)
- * unit->issue_delay.min));
+ {
+ rtx filltime = make_numeric_value ((unit->simultaneity - 1)
+ * unit->issue_delay.min);
+ blockage = operate_exp (MIN_OP, blockage, filltime);
+ }
- if (delay > 0)
- blockage = operate_exp (POS_MINUS_OP, blockage,
- make_numeric_value (delay));
+ blockage = operate_exp (POS_MINUS_OP,
+ make_numeric_value (op->ready),
+ blockage);
blockage = operate_exp (MAX_OP, blockage, op->issue_exp);
blockage = simplify_knowing (blockage, unit->condexp);
static char *new_names[] = {"*insn_default_length",
"*insn_variable_length_p",
"*insn_current_length"};
- static rtx (*no_address_fn[]) () = {identity_fn, zero_fn, zero_fn};
- static rtx (*address_fn[]) () = {max_fn, one_fn, identity_fn};
+ static rtx (*no_address_fn[]) PROTO((rtx)) = {identity_fn, zero_fn, zero_fn};
+ static rtx (*address_fn[]) PROTO((rtx)) = {max_fn, one_fn, identity_fn};
int i;
struct attr_desc *length_attr, *new_attr;
struct attr_value *av, *new_av;
then build a new expression if they don't match EXP. */
rtx defval = XEXP (exp, 1);
rtx new_defval = XEXP (exp, 1);
-
int len = XVECLEN (exp, 0);
- rtx *tests = (rtx *) alloca (len * sizeof (rtx));
+ rtunion *tests = (rtunion *) alloca (len * sizeof (rtunion));
int allsame = 1;
char *first_spacer;
/* This lets us free all storage allocated below, if appropriate. */
first_spacer = (char *) obstack_finish (rtl_obstack);
- bcopy (&XVECEXP (exp, 0, 0), tests, len * sizeof (rtx));
+ bcopy ((char *) XVEC (exp, 0)->elem, (char *) tests, len * sizeof (rtunion));
/* See if default value needs simplification. */
if (GET_CODE (defval) == COND)
rtx newtest, newval;
/* Simplify this test. */
- newtest = SIMPLIFY_TEST_EXP (tests[i], insn_code, insn_index);
- tests[i] = newtest;
+ newtest = SIMPLIFY_TEST_EXP (tests[i].rtx, insn_code, insn_index);
+ tests[i].rtx = newtest;
- newval = tests[i + 1];
+ newval = tests[i + 1].rtx;
/* See if this value may need simplification. */
if (GET_CODE (newval) == COND)
newval = simplify_cond (newval, insn_code, insn_index);
/* If test is true, make this value the default
and discard this + any following tests. */
len = i;
- defval = tests[i + 1];
+ defval = tests[i + 1].rtx;
new_defval = newval;
}
{
/* If test is false, discard it and its value. */
for (j = i; j < len - 2; j++)
- tests[j] = tests[j + 2];
+ tests[j].rtx = tests[j + 2].rtx;
len -= 2;
}
- else if (i > 0 && attr_equal_p (newval, tests[i - 1]))
+ else if (i > 0 && attr_equal_p (newval, tests[i - 1].rtx))
{
/* If this value and the value for the prev test are the same,
merge the tests. */
- tests[i - 2]
- = insert_right_side (IOR, tests[i - 2], newtest,
+ tests[i - 2].rtx
+ = insert_right_side (IOR, tests[i - 2].rtx, newtest,
insn_code, insn_index);
/* Delete this test/value. */
for (j = i; j < len - 2; j++)
- tests[j] = tests[j + 2];
+ tests[j].rtx = tests[j + 2].rtx;
len -= 2;
}
else
- tests[i + 1] = newval;
+ tests[i + 1].rtx = newval;
}
/* If the last test in a COND has the same value
as the default value, that test isn't needed. */
- while (len > 0 && attr_equal_p (tests[len - 1], new_defval))
+ while (len > 0 && attr_equal_p (tests[len - 1].rtx, new_defval))
len -= 2;
/* See if we changed anything. */
allsame = 0;
else
for (i = 0; i < len; i++)
- if (! attr_equal_p (tests[i], XVECEXP (exp, 0, i)))
+ if (! attr_equal_p (tests[i].rtx, XVECEXP (exp, 0, i)))
{
allsame = 0;
break;
rtx newexp = rtx_alloc (COND);
XVEC (newexp, 0) = rtvec_alloc (len);
- bcopy (tests, &XVECEXP (newexp, 0, 0), len * sizeof (rtx));
+ bcopy ((char *) tests, (char *) XVEC (newexp, 0)->elem,
+ len * sizeof (rtunion));
XEXP (newexp, 1) = new_defval;
return newexp;
}
av->num_insns--;
if (ie->insn_code == -1)
av->has_asm_insn = 0;
+
+ num_insn_ents--;
}
/* Insert an insn entry in an attribute value list. */
av->num_insns++;
if (ie->insn_code == -1)
av->has_asm_insn = 1;
+
+ num_insn_ents++;
}
\f
/* This is a utility routine to take an expression that is a tree of either
static rtx
insert_right_side (code, exp, term, insn_code, insn_index)
- RTX_CODE code;
+ enum rtx_code code;
rtx exp;
rtx term;
int insn_code, insn_index;
If so, we can optimize. Similarly for IOR's of EQ_ATTR.
This routine is passed an expression and either AND or IOR. It returns a
- bitmask indicating which alternatives are present.
- ??? What does "present" mean? */
+ bitmask indicating which alternatives are mentioned within EXP. */
static int
compute_alternative_mask (exp, code)
rtx exp;
- RTX_CODE code;
+ enum rtx_code code;
{
char *string;
if (GET_CODE (exp) == code)
of "attr" for this insn code. From that value, we can compute a test
showing when the EQ_ATTR will be true. This routine performs that
computation. If a test condition involves an address, we leave the EQ_ATTR
- intact because addresses are only valid for the `length' attribute. */
+ intact because addresses are only valid for the `length' attribute.
-/* ??? Kenner, document the meanings of the arguments!!! */
+ EXP is the EQ_ATTR expression and VALUE is the value of that attribute
+ for the insn corresponding to INSN_CODE and INSN_INDEX. */
static rtx
evaluate_eq_attr (exp, value, insn_code, insn_index)
For each possible COND value, call ourselves recursively.
The extra TRUE and FALSE expressions will be eliminated by another
- call to the simplification routine. */
+ call to the simplification routine. */
orexp = false_rtx;
andexp = true_rtx;
right = insert_right_side (AND, andexp, this,
insn_code, insn_index);
right = insert_right_side (AND, right,
- evaluate_eq_attr (exp, XVECEXP (value, 0, i + 1),
- insn_code, insn_index),
+ evaluate_eq_attr (exp,
+ XVECEXP (value, 0,
+ i + 1),
+ insn_code, insn_index),
insn_code, insn_index);
orexp = insert_right_side (IOR, orexp, right,
insn_code, insn_index);
/* Handle the default case. */
right = insert_right_side (AND, andexp,
evaluate_eq_attr (exp, XEXP (value, 1),
- insn_code, insn_index),
+ insn_code, insn_index),
insn_code, insn_index);
newexp = insert_right_side (IOR, orexp, right, insn_code, insn_index);
}
rtx newexp = exp;
char *spacer = (char *) obstack_finish (rtl_obstack);
- static rtx loser = 0;
- static int count = 0;
- static stopcount = 0;
-
- if (exp == loser)
- do_nothing ();
- count++;
- if (count == stopcount)
- do_nothing ();
-
/* Don't re-simplify something we already simplified. */
if (RTX_UNCHANGING_P (exp) || MEM_IN_STRUCT_P (exp))
return exp;
{
i = compute_alternative_mask (exp, AND);
if (i & ~insn_alternatives[insn_code])
- fatal ("Illegal alternative specified for pattern number %d",
+ fatal ("Invalid alternative specified for pattern number %d",
insn_index);
- /* If all alternatives are excluded, this is false. */
+ /* If all alternatives are excluded, this is false. */
i ^= insn_alternatives[insn_code];
if (i == 0)
return false_rtx;
{
i = compute_alternative_mask (exp, IOR);
if (i & ~insn_alternatives[insn_code])
- fatal ("Illegal alternative specified for pattern number %d",
+ fatal ("Invalid alternative specified for pattern number %d",
insn_index);
- /* If all alternatives are included, this is true. */
+ /* If all alternatives are included, this is true. */
i ^= insn_alternatives[insn_code];
if (i == 0)
return true_rtx;
return newexp;
}
-
-do_nothing ()
-{}
\f
/* Optimize the attribute lists by seeing if we can determine conditional
values from the known values of other attributes. This will save subroutine
struct attr_desc * attr;
struct attr_value_list *next; };
struct attr_value_list **insn_code_values;
+ struct attr_value_list *ivbuf;
struct attr_value_list *iv;
/* For each insn code, make a list of all the insn_ent's for it,
for all values for all attributes. */
+ if (num_insn_ents == 0)
+ return;
+
/* Make 2 extra elements, for "code" values -2 and -1. */
insn_code_values
= (struct attr_value_list **) alloca ((insn_code_number + 2)
* sizeof (struct attr_value_list *));
- bzero (insn_code_values,
+ bzero ((char *) insn_code_values,
(insn_code_number + 2) * sizeof (struct attr_value_list *));
+
/* Offset the table address so we can index by -2 or -1. */
insn_code_values += 2;
+ /* Allocate the attr_value_list structures using xmalloc rather than
+ alloca, because using alloca can overflow the maximum permitted
+ stack limit on SPARC Lynx. */
+ iv = ivbuf = ((struct attr_value_list *)
+ xmalloc (num_insn_ents * sizeof (struct attr_value_list)));
+
for (i = 0; i < MAX_ATTRS_INDEX; i++)
for (attr = attrs[i]; attr; attr = attr->next)
for (av = attr->first_value; av; av = av->next)
for (ie = av->first_insn; ie; ie = ie->next)
{
- iv = ((struct attr_value_list *)
- alloca (sizeof (struct attr_value_list)));
iv->attr = attr;
iv->av = av;
iv->ie = ie;
iv->next = insn_code_values[ie->insn_code];
insn_code_values[ie->insn_code] = iv;
+ iv++;
}
+ /* Sanity check on num_insn_ents. */
+ if (iv != ivbuf + num_insn_ents)
+ abort ();
+
/* Process one insn code at a time. */
for (i = -2; i < insn_code_number; i++)
{
}
}
}
+
+ free (ivbuf);
}
#if 0
}
#endif
\f
-/* An expression where all the unknown terms are EQ_ATTR tests can be
- rearranged into a COND provided we can enumerate all possible
- combinations of the unknown values. The set of combinations become the
- tests of the COND; the value of the expression given that combination is
- computed and becomes the corresponding value. To do this, we must be
- able to enumerate all values for each attribute used in the expression
- (currently, we give up if we find a numeric attribute).
-
- If the set of EQ_ATTR tests used in an expression tests the value of N
- different attributes, the list of all possible combinations can be made
- by walking the N-dimensional attribute space defined by those
- attributes. We record each of these as a struct dimension.
-
- The algorithm relies on sharing EQ_ATTR nodes: if two nodes in an
- expression are the same, the will also have the same address. We find
- all the EQ_ATTR nodes by marking them MEM_VOLATILE_P. This bit later
- represents the value of an EQ_ATTR node, so once all nodes are marked,
- they are also given an initial value of FALSE.
-
- We then separate the set of EQ_ATTR nodes into dimensions for each
- attribute and put them on the VALUES list. Terms are added as needed by
- `add_values_to_cover' so that all possible values of the attribute are
- tested.
-
- Each dimension also has a current value. This is the node that is
- currently considered to be TRUE. If this is one of the nodes added by
- `add_values_to_cover', all the EQ_ATTR tests in the original expression
- will be FALSE. Otherwise, only the CURRENT_VALUE will be true.
-
- NUM_VALUES is simply the length of the VALUES list and is there for
- convenience.
-
- Once the dimensions are created, the algorithm enumerates all possible
- values and computes the current value of the given expression. */
-
-struct dimension
-{
- struct attr_desc *attr; /* Attribute for this dimension. */
- rtx values; /* List of attribute values used. */
- rtx current_value; /* Position in the list for the TRUE value. */
- int num_values; /* Length of the values list. */
-};
-
/* If EXP is a suitable expression, reorganize it by constructing an
equivalent expression that is a COND with the tests being all combinations
of attribute values and the values being simple constants. */
prev = &dim->values;
for (link = dim->values; link; link = *prev)
{
- orexp = insert_right_side (IOR, orexp, XEXP (link, 0), -2);
+ orexp = insert_right_side (IOR, orexp, XEXP (link, 0), -2, -2);
prev = &XEXP (link, 1);
}
link = rtx_alloc (EXPR_LIST);
rtx exp = true_rtx;
for (i = 0; i < ndim; i++)
- exp = insert_right_side (AND, exp, XEXP (space[i].current_value, 0), -2);
+ exp = insert_right_side (AND, exp, XEXP (space[i].current_value, 0),
+ -2, -2);
return exp;
}
\f
/* Clear the MEM_IN_STRUCT_P flag in EXP and its subexpressions. */
+static void
clear_struct_flag (x)
rtx x;
{
case PC:
case CC0:
case EQ_ATTR:
+ case ATTR_FLAG:
return;
}
/* Return the number of RTX objects making up the expression X.
But if we count more more than MAX objects, stop counting. */
+static int
count_sub_rtxs (x, max)
rtx x;
int max;
case PC:
case CC0:
case EQ_ATTR:
+ case ATTR_FLAG:
return 1;
}
if (! strcmp (attr->name, "length") && ! attr->is_numeric)
fatal ("`length' attribute must take numeric values");
- /* Set up the default value. */
+ /* 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);
}
int i;
for (i = 0; i < XVECLEN (def, 6); i++)
- orexp = insert_right_side (IOR, orexp, XVECEXP (def, 6, i), -2);
+ orexp = insert_right_side (IOR, orexp, XVECEXP (def, 6, i), -2, -2);
op->conflict_exp = orexp;
extend_range (&unit->issue_delay, 1, issue_delay);
/* Merge our conditional into that of the function unit so we can determine
which insns are used by the function unit. */
- unit->condexp = insert_right_side (IOR, unit->condexp, op->condexp, -2);
+ unit->condexp = insert_right_side (IOR, unit->condexp, op->condexp, -2, -2);
}
\f
/* Given a piece of RTX, print a C expression to test it's truth value.
case PLUS: case MINUS: case MULT: case DIV: case MOD:
case AND: case IOR: case XOR:
- case LSHIFT: case ASHIFT: case LSHIFTRT: case ASHIFTRT:
+ case ASHIFT: case LSHIFTRT: case ASHIFTRT:
write_test_expr (XEXP (exp, 0), in_comparison || comparison_operator);
switch (code)
{
case XOR:
printf (" ^ ");
break;
- case LSHIFT:
case ASHIFT:
printf (" << ");
break;
if (attr->is_const)
{
write_test_expr (evaluate_eq_attr (exp, attr->default_val->value,
- 0, 0),
+ -2, -2),
in_comparison);
}
else
}
break;
+ /* Comparison test of flags for define_delays. */
+ case ATTR_FLAG:
+ if (in_comparison)
+ fatal ("ATTR_FLAG not valid inside comparison");
+ printf ("(flags & ATTR_FLAG_%s) != 0", XSTR (exp, 0));
+ break;
+
/* See if an operand matches a predicate. */
case MATCH_OPERAND:
/* If only a mode is given, just ensure the mode matches the operand.
XSTR (exp, 1), XINT (exp, 0), GET_MODE_NAME (GET_MODE (exp)));
break;
- /* Constant integer. */
+ /* Constant integer. */
case CONST_INT:
#if HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_INT
printf ("%d", XWINT (exp, 0));
#endif
break;
- /* A random C expression. */
+ /* A random C expression. */
case SYMBOL_REF:
printf ("%s", XSTR (exp, 0));
break;
/* The address of the branch target. */
case MATCH_DUP:
- printf ("insn_addresses[INSN_UID (JUMP_LABEL (insn))]");
+ printf ("insn_addresses[INSN_UID (GET_CODE (operands[%d]) == LABEL_REF ? XEXP (operands[%d], 0) : operands[%d])]",
+ XINT (exp, 0), XINT (exp, 0), XINT (exp, 0));
break;
/* The address of the current insn. It would be more consistent with
`must_extract' if we need to extract the insn operands
`must_constrain' if we must compute `which_alternative'
`address_used' if an address expression was used
+ `length_used' if an (eq_attr "length" ...) was used
*/
static void
case EQ_ATTR:
if (XSTR (exp, 0) == alternative_name)
must_extract = must_constrain = 1;
+ else if (strcmp (XSTR (exp, 0), "length") == 0)
+ length_used = 1;
return;
case MATCH_DUP:
+ must_extract = 1;
+ address_used = 1;
+ return;
+
case PC:
address_used = 1;
return;
+
+ case ATTR_FLAG:
+ return;
}
for (i = 0, fmt = GET_RTX_FORMAT (code); i < GET_RTX_LENGTH (code); i++)
struct attr_value *av, *common_av;
/* Find the most used attribute value. Handle that as the `default' of the
- switch we will generate. */
+ switch we will generate. */
common_av = find_most_used (attr);
/* Write out start of function, then all values with explicit `case' lines,
/* Write out the computation for one attribute value. */
static void
-write_attr_case (attr, av, write_case_lines, prefix, suffix, indent, known_true)
+write_attr_case (attr, av, write_case_lines, prefix, suffix, indent,
+ known_true)
struct attr_desc *attr;
struct attr_value *av;
int write_case_lines;
printf ("default:\n");
}
- /* See what we have to do to handle output this value. */
+ /* See what we have to do to output this value. */
must_extract = must_constrain = address_used = 0;
walk_attr_value (av->value);
/* Write function prelude. */
printf ("int\n");
- printf ("eligible_for_%s (delay_insn, slot, candidate_insn)\n", kind);
+ printf ("eligible_for_%s (delay_insn, slot, candidate_insn, flags)\n",
+ kind);
printf (" rtx delay_insn;\n");
printf (" int slot;\n");
printf (" rtx candidate_insn;\n");
+ printf (" int flags;\n");
printf ("{\n");
printf (" rtx insn;\n");
printf ("\n");
printf ("{\n");
printf (" rtx insn;\n");
printf (" int casenum;\n\n");
- printf (" insn = candidate_insn;\n");
+ printf (" insn = executing_insn;\n");
printf (" switch (recog_memoized (insn))\n");
printf (" {\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 (" insn = candidate_insn;\n");
printf (" switch (casenum)\n");
printf (" {\n");
/* If single value, just write it. */
value = find_single_value (attr);
if (value)
- write_attr_set (attr, 6, value, "return", ";\n", true_rtx, -2);
+ write_attr_set (attr, 6, value, "return", ";\n", true_rtx, -2, -2);
else
{
common_av = find_most_used (attr);
PUT_MODE (copy, GET_MODE (orig));
RTX_UNCHANGING_P (copy) = 1;
- bcopy (&XEXP (orig, 0), &XEXP (copy, 0),
+ bcopy ((char *) &XEXP (orig, 0), (char *) &XEXP (copy, 0),
GET_RTX_LENGTH (GET_CODE (copy)) * sizeof (rtx));
return copy;
#endif
static void
fatal (s, a1, a2)
char *s;
+ char *a1, *a2;
{
fprintf (stderr, "genattrtab: ");
fprintf (stderr, s, a1, a2);
fatal ("Internal gcc abort.");
}
-/* Determine if an insn has a constant number of delay slots. */
+/* Determine if an insn has a constant number of delay slots, i.e., the
+ number of delay slots is not a function of the length of the insn. */
+
void
write_const_num_delay_slots ()
{
if (attr)
{
printf ("int\nconst_num_delay_slots (insn)\n");
- printf (" rtx *insn;\n");
+ printf (" rtx insn;\n");
printf ("{\n");
printf (" switch (recog_memoized (insn))\n");
printf (" {\n");
for (av = attr->first_value; av; av = av->next)
- if (GET_CODE (av->value) == COND && av->num_insns)
- {
- for (ie = av->first_insn; ie; ie = ie->next)
+ {
+ length_used = 0;
+ walk_attr_value (av->value);
+ if (length_used)
+ {
+ for (ie = av->first_insn; ie; ie = ie->next)
if (ie->insn_code != -1)
printf (" case %d:\n", ie->insn_code);
- printf (" return 0;\n");
- }
+ printf (" return 0;\n");
+ }
+ }
+
printf (" default:\n");
printf (" return 1;\n");
printf (" }\n}\n");
rtx tem;
int i;
+#ifdef RLIMIT_STACK
+ /* Get rid of any avoidable limit on stack size. */
+ {
+ struct rlimit rlim;
+
+ /* Set the stack limit huge so that alloca does not fail. */
+ getrlimit (RLIMIT_STACK, &rlim);
+ rlim.rlim_cur = rlim.rlim_max;
+ setrlimit (RLIMIT_STACK, &rlim);
+ }
+#endif /* RLIMIT_STACK defined */
+
obstack_init (rtl_obstack);
obstack_init (hash_obstack);
obstack_init (temp_obstack);
/* Construct extra attributes for `length'. */
make_length_attrs ();
- /* Perform any possible optimizations to speed up compilation. */
+ /* Perform any possible optimizations to speed up compilation. */
optimize_attrs ();
/* Now write out all the `gen_attr_...' routines. Do these before the
OSDN Git Service
