/* 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 attribues and the DEFINE_DELAY and
+/* This program handles insn attributes and the DEFINE_DELAY and
DEFINE_FUNCTION_UNIT definitions.
It produces a series of functions named `get_attr_...', one for each insn
for constant attributes and generate a set of functions for that given
combination. An initialization function would be written that evaluates
the attributes and installs the corresponding set of routines and
- definitions (each would be accessed through a pointer). */
-
-#include <stdio.h>
-#include "gvarargs.h"
-#include "config.h"
+ definitions (each would be accessed through a pointer).
+
+ We use the flags in an RTX as follows:
+ `unchanging' (RTX_UNCHANGING_P): This rtx is fully simplified
+ independent of the insn code.
+ `in_struct' (MEM_IN_STRUCT_P): This rtx is fully simplified
+ for the insn code currently being processed (see optimize_attrs).
+ `integrated' (RTX_INTEGRATED_P): This rtx is permanent and unique
+ (see attr_rtx).
+ `volatil' (MEM_VOLATILE_P): During simplify_by_exploding the value of an
+ EQ_ATTR rtx is true if !volatil and false if volatil. */
+
+
+#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;
static void fatal ();
void fancy_abort ();
+/* enough space to reserve for printing out ints */
+#define MAX_DIGITS (HOST_BITS_PER_INT * 3 / 10 + 3)
+
/* Define structures used to record attributes and values. */
/* As each DEFINE_INSN, DEFINE_PEEPHOLE, or DEFINE_ASM_ATTRIBUTES is
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
+
+/* A range of values. */
+
+struct range
+{
+ int min;
+ int max;
};
/* Structure for each DEFINE_DELAY. */
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. */
};
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
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 costexp; /* Worst-case cost as function of insn. */
+ 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 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. */
};
/* Listheads of above structures. */
-static struct attr_desc *attrs;
+/* 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 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': */
-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. */
+
+static int *insn_n_alternatives;
/* Stores, for each insn code, a bitmap that has bits on for each possible
alternative. */
static int *insn_alternatives;
+/* If nonzero, assume that the `alternative' attr has this value.
+ This is the hashed, unique string for the numeral
+ whose value is chosen alternative. */
+
+static char *current_alternative_string;
+
/* Used to simplify expressions. */
static rtx true_rtx, false_rtx;
/* Simplify an expression. Only call the routine if there is something to
simplify. */
#define SIMPLIFY_TEST_EXP(EXP,INSN_CODE,INSN_INDEX) \
- (RTX_UNCHANGING_P (EXP) ? (EXP) \
+ (RTX_UNCHANGING_P (EXP) || MEM_IN_STRUCT_P (EXP) ? (EXP) \
: simplify_test_exp (EXP, INSN_CODE, INSN_INDEX))
+/* Simplify (eq_attr ("alternative") ...)
+ when we are working with a particular alternative. */
+#define SIMPLIFY_ALTERNATIVE(EXP) \
+ if (current_alternative_string \
+ && GET_CODE ((EXP)) == EQ_ATTR \
+ && XSTR ((EXP), 0) == alternative_name) \
+ (EXP) = (XSTR ((EXP), 1) == current_alternative_string \
+ ? true_rtx : false_rtx);
+
/* 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 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 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 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 ();
-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)
+
\f
/* Hash table for sharing RTL and strings. */
/* Here is how primitive or already-shared RTL's hash
codes are made. */
-#define RTL_HASH(RTL) ((int) (RTL) & 0777777)
+#define RTL_HASH(RTL) ((HOST_WIDE_INT) (RTL) & 0777777)
/* Add an entry to the hash table for RTL with hash code HASHCODE. */
/*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
return rt_val;
}
- hashcode = ((int) code + RTL_HASH (arg0));
+ hashcode = ((HOST_WIDE_INT) code + RTL_HASH (arg0));
for (h = attr_hash_table[hashcode % RTL_HASH_SIZE]; h; h = h->next)
if (h->hashcode == hashcode
&& GET_CODE (h->u.rtl) == code
return rt_val;
}
- hashcode = ((int) code + RTL_HASH (arg0) + RTL_HASH (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
&& GET_CODE (h->u.rtl) == code
if (code == SYMBOL_REF)
arg0 = attr_string (arg0, strlen (arg0));
- hashcode = ((int) code + RTL_HASH (arg0));
+ hashcode = ((HOST_WIDE_INT) code + RTL_HASH (arg0));
for (h = attr_hash_table[hashcode % RTL_HASH_SIZE]; h; h = h->next)
if (h->hashcode == hashcode
&& GET_CODE (h->u.rtl) == code
char *arg0 = va_arg (p, char *);
char *arg1 = va_arg (p, char *);
- hashcode = ((int) code + RTL_HASH (arg0) + RTL_HASH (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
&& GET_CODE (h->u.rtl) == code
}
else if (code == CONST_INT)
{
- int arg0 = va_arg (p, int);
+ HOST_WIDE_INT arg0 = va_arg (p, HOST_WIDE_INT);
if (arg0 == 0)
return false_rtx;
if (arg0 == 1)
XINT (rt_val, i) = va_arg (p, int);
break;
+ case 'w': /* A wide integer? */
+ XWINT (rt_val, i) = va_arg (p, HOST_WIDE_INT);
+ break;
+
case 's': /* A string? */
XSTR (rt_val, i) = va_arg (p, char *);
break;
/*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);
return h->u.str; /* <-- return if found. */
/* Not found; create a permanent copy and add it to the hash table. */
- new_str = (char *) xmalloc (len + 1);
+ new_str = (char *) obstack_alloc (hash_obstack, len + 1);
bcopy (str, new_str, len);
new_str[len] = '\0';
attr_hash_add_string (hashcode, new_str);
}
break;
- default:
+ 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:
+ abort ();
}
}
return copy;
so expressions using it can be permanent too. */
exp = attr_eq (XSTR (exp, 0), XSTR (exp, 1));
+ /* 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)
+ RTX_UNCHANGING_P (exp) = 1;
+
if (attr->is_numeric)
{
for (p = XSTR (exp, 1); *p; 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 (XINT (exp, 0))
+ if (XWINT (exp, 0))
return true_rtx;
else
return false_rtx;
if (attr == 0 || attr->is_numeric)
{
- for (p = XSTR (exp, 0); *p; p++)
+ p = XSTR (exp, 0);
+ if (attr && attr->negative_ok && *p == '-')
+ p++;
+ for (; *p; p++)
if (*p > '9' || *p < '0')
fatal ("Non-numeric value for numeric `%s' attribute",
attr ? attr->name : "internal");
/* 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)));
}
int num_alt;
int insn_code, insn_index;
{
- rtx newexp;
rtx condexp;
int i;
\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 ()
char *p, *string;
rtx value;
- string = p = (char *) xmalloc (2
+ string = p = (char *) oballoc (2
+ strlen (attr->name)
+ strlen (XSTR (av->value, 0)));
strcpy (p, attr->name);
value = attr_rtx (SYMBOL_REF, string);
RTX_UNCHANGING_P (value) = 1;
- XVECEXP (condexp, 0, 2 * i) = attr_eq (exp, value);
+ XVECEXP (condexp, 0, 2 * i) = attr_rtx (EQ, exp, value);
XVECEXP (condexp, 0, 2 * i + 1) = av->value;
}
case SYMBOL_REF:
if (!attr->is_const || RTX_UNCHANGING_P (exp))
break;
+ /* The SYMBOL_REF is constant for a given run, so mark it as unchanging.
+ This makes the COND something that won't be considered an arbitrary
+ expression by walk_attr_value. */
+ RTX_UNCHANGING_P (exp) = 1;
exp = convert_const_symbol_ref (exp, attr);
RTX_UNCHANGING_P (exp) = 1;
exp = check_attr_value (exp, attr);
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));
|| insn_alternatives[av->first_insn->insn_code]))
return av;
- av = (struct attr_value *) xmalloc (sizeof (struct attr_value));
+ av = (struct attr_value *) oballoc (sizeof (struct attr_value));
av->value = value;
av->next = attr->first_value;
attr->first_value = av;
Finally, for each [DEFINE_DELAY, slot #] pair, we compute an attribute that
tells whether a given insn can be in that delay slot.
- Normal attrbute filling and optimization expands these to contain the
+ Normal attribute filling and optimization expands these to contain the
information needed to handle delay slots. */
static void
make_internal_attr ("*delay_type", condexp, 1);
}
- /* For each delay possibility and delay slot, compute an eligability
- attribute for non-anulled insns and for each type of annulled (annul
+ /* For each delay possibility and delay slot, compute an eligibility
+ attribute for non-annulled insns and for each type of annulled (annul
if true and annul if false). */
for (delay = delays; delay; delay = delay->next)
{
newexp = attr_rtx (IF_THEN_ELSE, condexp,
make_numeric_value (1), make_numeric_value (0));
- p = attr_printf (13, "*delay_%d_%d", delay->num, i / 3);
+ p = attr_printf (sizeof ("*delay__") + MAX_DIGITS*2, "*delay_%d_%d",
+ delay->num, i / 3);
make_internal_attr (p, newexp, 1);
if (have_annul_true)
newexp = attr_rtx (IF_THEN_ELSE, condexp,
make_numeric_value (1),
make_numeric_value (0));
- p = attr_printf (18, "*annul_true_%d_%d", delay->num, i / 3);
+ p = attr_printf (sizeof ("*annul_true__") + MAX_DIGITS*2,
+ "*annul_true_%d_%d", delay->num, i / 3);
make_internal_attr (p, newexp, 1);
}
newexp = attr_rtx (IF_THEN_ELSE, condexp,
make_numeric_value (1),
make_numeric_value (0));
- p = attr_printf (18, "*annul_false_%d_%d", delay->num, i / 3);
+ p = attr_printf (sizeof ("*annul_false__") + MAX_DIGITS*2,
+ "*annul_false_%d_%d", delay->num, i / 3);
make_internal_attr (p, newexp, 1);
}
}
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;
i = right_value;
break;
+ case MIN_OP:
+ if (left_value < right_value)
+ i = left_value;
+ else
+ i = right_value;
+ break;
+
default:
abort ();
}
construct a number of attributes.
The first produces a function `function_units_used' which is given an
- insn and produces a mask showing which function units are required for
- the execution of that insn.
+ insn and produces an encoding showing which function units are required
+ for the execution of that insn. If the value is non-negative, the insn
+ uses that unit; otherwise, the value is a one's compliment mask of units
+ used.
The second produces a function `result_ready_cost' which is used to
determine the time that the result of an insn will be ready and hence
For each unit, a `<name>_unit_ready_cost' function will take an
insn and give the delay until that unit will be ready with the result
- and a `<name>_unit_busy_delay' function is given an insn already
+ 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 ()
{
- struct function_unit *unit;
- struct function_unit_op *op;
+ struct function_unit *unit, **unit_num;
+ struct function_unit_op *op, **op_array, ***unit_ops;
rtx unitsmask;
rtx readycost;
rtx newexp;
char *str;
+ int i, j, u, num, nvalues;
+
+ /* 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. */
- /* Initially, cost and masks are zero. */
- unitsmask = readycost = make_numeric_value (0);
+ for (unit = units; unit; unit = unit->next)
+ {
+ 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);
+ 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) + sizeof ("*_cost_") + MAX_DIGITS,
+ "*%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);
+ }
+ }
- /* Set up a conditional for costs and unit mask. */
+ /* Compute the mask of function units used. Initially, the unitsmask is
+ zero. Set up a conditional to compute each unit's contribution. */
+ unitsmask = make_numeric_value (0);
newexp = rtx_alloc (IF_THEN_ELSE);
XEXP (newexp, 2) = make_numeric_value (0);
- /* For each unit, insert its contribution to the above three values. */
+ /* Merge each function unit into the unit mask attributes. */
+ for (unit = units; unit; unit = unit->next)
+ {
+ XEXP (newexp, 0) = unit->condexp;
+ XEXP (newexp, 1) = make_numeric_value (1 << unit->num);
+ unitsmask = operate_exp (OR_OP, unitsmask, newexp);
+ }
+
+ /* Simplify the unit mask expression, encode it, and make an attribute
+ for the function_units_used function. */
+ unitsmask = simplify_by_exploding (unitsmask);
+ unitsmask = encode_units_mask (unitsmask);
+ make_internal_attr ("*function_units_used", unitsmask, 2);
+
+ /* Create an array of ops for each unit. Add an extra unit for the
+ result_ready_cost function that has the ops of all other units. */
+ unit_ops = (struct function_unit_op ***)
+ alloca ((num_units + 1) * sizeof (struct function_unit_op **));
+ unit_num = (struct function_unit **)
+ alloca ((num_units + 1) * sizeof (struct function_unit *));
+
+ unit_num[num_units] = unit = (struct function_unit *)
+ alloca (sizeof (struct function_unit));
+ unit->num = num_units;
+ unit->num_opclasses = 0;
+
+ for (unit = units; unit; unit = unit->next)
+ {
+ unit_num[num_units]->num_opclasses += unit->num_opclasses;
+ unit_num[unit->num] = unit;
+ unit_ops[unit->num] = op_array = (struct function_unit_op **)
+ alloca (unit->num_opclasses * sizeof (struct function_unit_op *));
+
+ for (op = unit->ops; op; op = op->next)
+ op_array[op->num] = op;
+ }
+
+ /* Compose the array of ops for the extra unit. */
+ unit_ops[num_units] = op_array = (struct function_unit_op **)
+ alloca (unit_num[num_units]->num_opclasses
+ * sizeof (struct function_unit_op *));
+
+ for (unit = units, i = 0; unit; i += unit->num_opclasses, unit = unit->next)
+ 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
+ condition for each non-default value. */
+ for (u = 0; u <= num_units; u++)
+ {
+ rtx orexp;
+ int value;
+
+ unit = unit_num[u];
+ op_array = unit_ops[unit->num];
+ num = unit->num_opclasses;
+
+ /* Sort the array of ops into increasing ready cost order. */
+ for (i = 0; i < num; i++)
+ for (j = num - 1; j > i; j--)
+ if (op_array[j-1]->ready < op_array[j]->ready)
+ {
+ op = op_array[j];
+ op_array[j] = op_array[j-1];
+ op_array[j-1] = op;
+ }
+
+ /* Determine how many distinct non-default ready cost values there
+ are. We use a default ready cost value of 1. */
+ nvalues = 0; value = 1;
+ for (i = num - 1; i >= 0; i--)
+ if (op_array[i]->ready > value)
+ {
+ value = op_array[i]->ready;
+ nvalues++;
+ }
+
+ if (nvalues == 0)
+ readycost = make_numeric_value (1);
+ else
+ {
+ /* Construct the ready cost expression as a COND of each value from
+ the largest to the smallest. */
+ readycost = rtx_alloc (COND);
+ XVEC (readycost, 0) = rtvec_alloc (nvalues * 2);
+ XEXP (readycost, 1) = make_numeric_value (1);
+
+ nvalues = 0; orexp = false_rtx; value = op_array[0]->ready;
+ for (i = 0; i < num; i++)
+ {
+ op = op_array[i];
+ if (op->ready <= 1)
+ break;
+ else if (op->ready == value)
+ orexp = insert_right_side (IOR, orexp, op->condexp, -2, -2);
+ else
+ {
+ XVECEXP (readycost, 0, nvalues * 2) = orexp;
+ XVECEXP (readycost, 0, nvalues * 2 + 1)
+ = make_numeric_value (value);
+ nvalues++;
+ value = op->ready;
+ orexp = op->condexp;
+ }
+ }
+ XVECEXP (readycost, 0, nvalues * 2) = orexp;
+ XVECEXP (readycost, 0, nvalues * 2 + 1) = make_numeric_value (value);
+ }
+
+ if (u < num_units)
+ {
+ 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.
+
+ 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)".
+
+ 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 = operate_exp (POS_MINUS_OP, readycost,
+ make_numeric_value (1));
+
+ if (unit->simultaneity != 0)
+ {
+ rtx filltime = make_numeric_value ((unit->simultaneity - 1)
+ * unit->issue_delay.min);
+ blockage = operate_exp (MIN_OP, blockage, filltime);
+ }
+
+ 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);
+
+ /* 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) + sizeof ("*_block_") + MAX_DIGITS,
+ "*%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) + sizeof ("*_unit_blockage_range"),
+ "*%s_unit_blockage_range", unit->name);
+ make_internal_attr (str, newexp, 4);
+ }
+
+ str = attr_printf (strlen (unit->name) + sizeof ("*_unit_ready_cost"),
+ "*%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);
+ }
+
+ /* For each unit that requires a conflict cost function, make an attribute
+ that maps insns to the operation number. */
for (unit = units; unit; unit = unit->next)
{
- /* An expression that computes the ready cost for this unit. */
- rtx readyexp = rtx_alloc (COND);
- /* An expression that maps insns to operation number for conflicts. */
- rtx caseexp = rtx_alloc (COND);
+ rtx caseexp;
- XVEC (readyexp, 0) = rtvec_alloc ((unit->num_opclasses - 1) * 2);
+ if (! unit->needs_conflict_function
+ && ! unit->needs_blockage_function)
+ continue;
+
+ caseexp = rtx_alloc (COND);
XVEC (caseexp, 0) = rtvec_alloc ((unit->num_opclasses - 1) * 2);
for (op = unit->ops; op; op = op->next)
{
- /* Validate the expressions we were given for the conditions
- and busy cost. Then make an attribute for use in the conflict
- function. */
- op->condexp = check_attr_test (op->condexp, 0);
- op->busyexp = check_attr_value (op->busyexp, 0);
- str = attr_printf (strlen (unit->name) + 11, "*%s_case_%d",
- unit->name, op->num);
- make_internal_attr (str, make_canonical (0, op->busyexp));
-
- /* Make our adjustment to the two COND's being computed. If we are
- the last operation class, place our values into the default of
- the COND. */
+ /* Make our adjustment to the COND being computed. If we are the
+ last operation class, place our values into the default of the
+ COND. */
if (op->num == unit->num_opclasses - 1)
{
- XEXP (readyexp, 1) = make_numeric_value (op->ready);
XEXP (caseexp, 1) = make_numeric_value (op->num);
}
else
{
- XVECEXP (readyexp, 0, op->num * 2) = op->condexp;
- XVECEXP (readyexp, 0, op->num * 2 + 1)
- = make_numeric_value (op->ready);
XVECEXP (caseexp, 0, op->num * 2) = op->condexp;
XVECEXP (caseexp, 0, op->num * 2 + 1)
= make_numeric_value (op->num);
}
}
- /* Make an attribute for the case number and ready delay. */
- str = attr_printf (strlen (unit->name) + 8, "*%s_cases", unit->name);
+ /* Simplifying caseexp with simplify_by_exploding doesn't win. */
+ str = attr_printf (strlen (unit->name) + sizeof ("*_cases"),
+ "*%s_cases", unit->name);
make_internal_attr (str, caseexp, 1);
+ }
+}
- str = attr_printf (strlen (unit->name) + 20, "*%s_unit_ready_cost",
- unit->name);
- make_internal_attr (str, readyexp, 0);
+/* Simplify EXP given KNOWN_TRUE. */
- /* Merge this function unit into the ready cost and unit mask
- attributes. */
- XEXP (newexp, 0) = check_attr_test (unit->condexp, 0);
- XEXP (newexp, 1) = make_numeric_value (1 << unit->num);
- unitsmask = operate_exp (OR_OP, unitsmask, newexp);
+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
+ and only one unit is used or the one's compliment of the bitmask. */
+
+static rtx
+encode_units_mask (x)
+ rtx x;
+{
+ register int i;
+ register int j;
+ register enum rtx_code code;
+ register char *fmt;
+
+ code = GET_CODE (x);
+
+ switch (code)
+ {
+ case CONST_STRING:
+ i = atoi (XSTR (x, 0));
+ if (i < 0)
+ abort (); /* The sign bit encodes a one's compliment mask. */
+ else if (i != 0 && i == (i & -i))
+ /* Only one bit is set, so yield that unit number. */
+ for (j = 0; (i >>= 1) != 0; j++)
+ ;
+ else
+ j = ~i;
+ return attr_rtx (CONST_STRING, attr_printf (MAX_DIGITS, "%d", j));
- XEXP (newexp, 1) = readyexp;
- readycost = operate_exp (MAX_OP, readycost, newexp);
+ case REG:
+ case QUEUED:
+ case CONST_INT:
+ case CONST_DOUBLE:
+ case SYMBOL_REF:
+ case CODE_LABEL:
+ case PC:
+ case CC0:
+ case EQ_ATTR:
+ return x;
}
- make_internal_attr ("*function_units_used", unitsmask, 0);
- make_internal_attr ("*result_ready_cost", readycost, 0);
+ /* Compare the elements. If any pair of corresponding elements
+ fail to match, return 0 for the whole things. */
+
+ fmt = GET_RTX_FORMAT (code);
+ for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
+ {
+ switch (fmt[i])
+ {
+ case 'V':
+ case 'E':
+ for (j = 0; j < XVECLEN (x, i); j++)
+ XVECEXP (x, i, j) = encode_units_mask (XVECEXP (x, i, j));
+ break;
+
+ case 'e':
+ XEXP (x, i) = encode_units_mask (XEXP (x, i));
+ break;
+ }
+ }
+ return x;
}
\f
/* Once all attributes and insns have been read and checked, we construct for
int i;
rtx value;
+ /* Don't fill constant attributes. The value is independent of
+ any particular insn. */
+ if (attr->is_const)
+ return;
+
for (id = defs; id; id = id->next)
{
/* If no value is specified for this insn for this attribute, use the
else
av = get_attr_value (value, attr, id->insn_code);
- ie = (struct insn_ent *) xmalloc (sizeof (struct insn_ent));
+ ie = (struct insn_ent *) oballoc (sizeof (struct insn_ent));
ie->insn_code = id->insn_code;
ie->insn_index = id->insn_code;
insert_insn_ent (av, ie);
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;
no_address_fn[i],
address_fn[i]),
new_attr, ie->insn_code);
- new_ie = (struct insn_ent *) xmalloc (sizeof (struct insn_ent));
+ new_ie = (struct insn_ent *) oballoc (sizeof (struct insn_ent));
new_ie->insn_code = ie->insn_code;
new_ie->insn_index = ie->insn_index;
insert_insn_ent (new_av, new_ie);
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 *spacer, *first_spacer;
+ 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. */
+ 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)
return compute_alternative_mask (XEXP (exp, 0), code)
| compute_alternative_mask (XEXP (exp, 1), code);
else if (code == AND && GET_CODE (exp) == NOT
&& GET_CODE (XEXP (exp, 0)) == EQ_ATTR
&& XSTR (XEXP (exp, 0), 0) == alternative_name)
- return 1 << atoi (XSTR (XEXP (exp, 0), 1));
+ string = XSTR (XEXP (exp, 0), 1);
else if (code == IOR && GET_CODE (exp) == EQ_ATTR
&& XSTR (exp, 0) == alternative_name)
- return 1 << atoi (XSTR (exp, 1));
+ string = XSTR (exp, 1);
else
return 0;
+
+ if (string[1] == 0)
+ return 1 << (string[0] - '0');
+ return 1 << atoi (string);
}
/* Given I, a single-bit mask, return RTX to compare the `alternative'
{
rtx newexp;
int i;
- char *alternative;
/* Find the bit. */
for (i = 0; (mask & (1 << i)) == 0; i++)
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;
+ if (current_alternative_string)
+ clear_struct_flag (value);
+
for (i = 0; i < XVECLEN (value, 0); i += 2)
{
rtx this = SIMPLIFY_TEST_EXP (XVECEXP (value, 0, i),
insn_code, insn_index);
+ SIMPLIFY_ALTERNATIVE (this);
+
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);
}
if (address_used)
{
+ /* This had `&& current_alternative_string', which seems to be wrong. */
if (! RTX_UNCHANGING_P (exp))
return copy_rtx_unchanging (exp);
return exp;
return exp;
}
\f
-/* Similiar to `simplify_and_tree', but for IOR trees. */
+/* Similar to `simplify_and_tree', but for IOR trees. */
static rtx
simplify_or_tree (exp, pterm, 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))
+ if (RTX_UNCHANGING_P (exp) || MEM_IN_STRUCT_P (exp))
return exp;
switch (GET_CODE (exp))
{
case AND:
left = SIMPLIFY_TEST_EXP (XEXP (exp, 0), insn_code, insn_index);
+ SIMPLIFY_ALTERNATIVE (left);
+ if (left == false_rtx)
+ {
+ obstack_free (rtl_obstack, spacer);
+ return false_rtx;
+ }
right = SIMPLIFY_TEST_EXP (XEXP (exp, 1), insn_code, insn_index);
+ SIMPLIFY_ALTERNATIVE (right);
+ if (left == false_rtx)
+ {
+ obstack_free (rtl_obstack, spacer);
+ return false_rtx;
+ }
/* If either side is an IOR and we have (eq_attr "alternative" ..")
present on both sides, apply the distributive law since this will
}
else if (left == true_rtx)
{
- obstack_free (rtl_obstack, spacer);
- return SIMPLIFY_TEST_EXP (XEXP (exp, 1), insn_code, insn_index);
+ return right;
}
else if (right == true_rtx)
{
- obstack_free (rtl_obstack, spacer);
- return SIMPLIFY_TEST_EXP (XEXP (exp, 0), insn_code, insn_index);
+ return left;
}
-
/* See if all or all but one of the insn's alternatives are specified
in this tree. Optimize if so. */
{
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;
case IOR:
left = SIMPLIFY_TEST_EXP (XEXP (exp, 0), insn_code, insn_index);
+ SIMPLIFY_ALTERNATIVE (left);
+ if (left == true_rtx)
+ {
+ obstack_free (rtl_obstack, spacer);
+ return true_rtx;
+ }
right = SIMPLIFY_TEST_EXP (XEXP (exp, 1), insn_code, insn_index);
+ SIMPLIFY_ALTERNATIVE (right);
+ if (right == true_rtx)
+ {
+ obstack_free (rtl_obstack, spacer);
+ return true_rtx;
+ }
right = simplify_or_tree (right, &left, insn_code, insn_index);
if (left == XEXP (exp, 0) && right == XEXP (exp, 1))
}
else if (left == false_rtx)
{
- obstack_free (rtl_obstack, spacer);
- return SIMPLIFY_TEST_EXP (XEXP (exp, 1), insn_code, insn_index);
+ return right;
}
else if (right == false_rtx)
{
- obstack_free (rtl_obstack, spacer);
- return SIMPLIFY_TEST_EXP (XEXP (exp, 0), insn_code, insn_index);
+ return left;
}
/* Test for simple cases where the distributive law is useful. I.e.,
{
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;
case NOT:
if (GET_CODE (XEXP (exp, 0)) == NOT)
- return SIMPLIFY_TEST_EXP (XEXP (XEXP (exp, 0), 0),
- insn_code, insn_index);
+ {
+ left = SIMPLIFY_TEST_EXP (XEXP (XEXP (exp, 0), 0),
+ insn_code, insn_index);
+ SIMPLIFY_ALTERNATIVE (left);
+ return left;
+ }
+
left = SIMPLIFY_TEST_EXP (XEXP (exp, 0), insn_code, insn_index);
+ SIMPLIFY_ALTERNATIVE (left);
if (GET_CODE (left) == NOT)
return XEXP (left, 0);
break;
case EQ_ATTR:
+ if (current_alternative_string && XSTR (exp, 0) == alternative_name)
+ return (XSTR (exp, 1) == current_alternative_string
+ ? true_rtx : false_rtx);
+
/* Look at the value for this insn code in the specified attribute.
We normally can replace this comparison with the condition that
would give this insn the values being tested for. */
/* We have already simplified this expression. Simplifying it again
won't buy anything unless we weren't given a valid insn code
to process (i.e., we are canonicalizing something.). */
- if (insn_code != -2 && ! RTX_UNCHANGING_P (newexp))
- {
- return copy_rtx_unchanging (newexp);
- }
+ if (insn_code != -2 /* Seems wrong: && current_alternative_string. */
+ && ! RTX_UNCHANGING_P (newexp))
+ return copy_rtx_unchanging (newexp);
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 *av;
- struct insn_ent *ie, *nextie;
+ struct insn_ent *ie;
rtx newexp;
int something_changed = 1;
+ int i;
+ struct attr_value_list { struct attr_value *av;
+ struct insn_ent *ie;
+ 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;
- /* Loop until nothing changes for one iteration. */
- while (something_changed)
- {
- something_changed = 0;
- for (attr = attrs; attr; attr = attr->next)
- for (av = attr->first_value; av; av = av->next)
- for (ie = av->first_insn; ie; ie = nextie)
- {
- struct obstack *old = rtl_obstack;
- char *spacer = (char *) obstack_finish (temp_obstack);
+ /* 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 ((char *) insn_code_values,
+ (insn_code_number + 2) * sizeof (struct attr_value_list *));
- nextie = ie->next;
- if (GET_CODE (av->value) != COND)
- continue;
+ /* Offset the table address so we can index by -2 or -1. */
+ insn_code_values += 2;
- rtl_obstack = temp_obstack;
- newexp = simplify_cond (av->value, ie->insn_code,
- ie->insn_index);
- rtl_obstack = old;
- if (newexp != av->value)
- {
- newexp = attr_copy_rtx (newexp);
- remove_insn_ent (av, ie);
- insert_insn_ent (get_attr_value (newexp, attr,
- ie->insn_code), ie);
- something_changed = 1;
- }
- obstack_free (temp_obstack, spacer);
- }
- }
-}
+ /* 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->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++)
+ {
+ /* Clear the MEM_IN_STRUCT_P flag everywhere relevant.
+ We use it to mean "already simplified for this insn". */
+ for (iv = insn_code_values[i]; iv; iv = iv->next)
+ clear_struct_flag (iv->av->value);
+
+ /* Loop until nothing changes for one iteration. */
+ something_changed = 1;
+ while (something_changed)
+ {
+ something_changed = 0;
+ for (iv = insn_code_values[i]; iv; iv = iv->next)
+ {
+ struct obstack *old = rtl_obstack;
+ char *spacer = (char *) obstack_finish (temp_obstack);
+
+ attr = iv->attr;
+ av = iv->av;
+ ie = iv->ie;
+ if (GET_CODE (av->value) != COND)
+ continue;
+
+ rtl_obstack = temp_obstack;
+#if 0 /* This was intended as a speed up, but it was slower. */
+ if (insn_n_alternatives[ie->insn_code] > 6
+ && count_sub_rtxs (av->value, 200) >= 200)
+ newexp = simplify_by_alternatives (av->value, ie->insn_code,
+ ie->insn_index);
+ else
+#endif
+ newexp = simplify_cond (av->value, ie->insn_code,
+ ie->insn_index);
+
+ rtl_obstack = old;
+ if (newexp != av->value)
+ {
+ newexp = attr_copy_rtx (newexp);
+ remove_insn_ent (av, ie);
+ av = get_attr_value (newexp, attr, ie->insn_code);
+ iv->av = av;
+ insert_insn_ent (av, ie);
+ something_changed = 1;
+ }
+ obstack_free (temp_obstack, spacer);
+ }
+ }
+ }
+
+ free (ivbuf);
+}
+
+#if 0
+static rtx
+simplify_by_alternatives (exp, insn_code, insn_index)
+ rtx exp;
+ int insn_code, insn_index;
+{
+ int i;
+ int len = insn_n_alternatives[insn_code];
+ rtx newexp = rtx_alloc (COND);
+ rtx ultimate;
+
+
+ XVEC (newexp, 0) = rtvec_alloc (len * 2);
+
+ /* It will not matter what value we use as the default value
+ of the new COND, since that default will never be used.
+ Choose something of the right type. */
+ for (ultimate = exp; GET_CODE (ultimate) == COND;)
+ ultimate = XEXP (ultimate, 1);
+ XEXP (newexp, 1) = ultimate;
+
+ for (i = 0; i < insn_n_alternatives[insn_code]; i++)
+ {
+ current_alternative_string = attr_numeral (i);
+ XVECEXP (newexp, 0, i * 2) = make_alternative_compare (1 << i);
+ XVECEXP (newexp, 0, i * 2 + 1)
+ = simplify_cond (exp, insn_code, insn_index);
+ }
+
+ current_alternative_string = 0;
+ return simplify_cond (newexp, insn_code, insn_index);
+}
+#endif
+\f
+/* 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. */
+
+static rtx
+simplify_by_exploding (exp)
+ rtx exp;
+{
+ rtx list = 0, link, condexp, defval;
+ struct dimension *space;
+ rtx *condtest, *condval;
+ 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, &ndim) || ndim == 0)
+ {
+ unmark_used_attributes (list, 0, 0);
+ return exp;
+ }
+
+ /* Create an attribute space from the list of used attributes. For each
+ dimension in the attribute space, record the attribute, list of values
+ used, and number of values used. Add members to the list of values to
+ cover the domain of the attribute. This makes the expanded COND form
+ order independent. */
+
+ space = (struct dimension *) alloca (ndim * sizeof (struct dimension));
+
+ total = 1;
+ for (ndim = 0; list; ndim++)
+ {
+ /* Pull the first attribute value from the list and record that
+ attribute as another dimension in the attribute space. */
+ char *name = XSTR (XEXP (list, 0), 0);
+ rtx *prev;
+
+ if ((space[ndim].attr = find_attr (name, 0)) == 0
+ || space[ndim].attr->is_numeric)
+ {
+ unmark_used_attributes (list, space, ndim);
+ return exp;
+ }
+
+ /* Add all remaining attribute values that refer to this attribute. */
+ space[ndim].num_values = 0;
+ space[ndim].values = 0;
+ prev = &list;
+ for (link = list; link; link = *prev)
+ if (! strcmp (XSTR (XEXP (link, 0), 0), name))
+ {
+ space[ndim].num_values++;
+ *prev = XEXP (link, 1);
+ XEXP (link, 1) = space[ndim].values;
+ space[ndim].values = link;
+ }
+ else
+ prev = &XEXP (link, 1);
+
+ /* Add sufficient members to the list of values to make the list
+ mutually exclusive and record the total size of the attribute
+ space. */
+ total *= add_values_to_cover (&space[ndim]);
+ }
+
+ /* Sort the attribute space so that the attributes go from non-constant
+ to constant and from most values to least values. */
+ for (i = 0; i < ndim; i++)
+ for (j = ndim - 1; j > i; j--)
+ if ((space[j-1].attr->is_const && !space[j].attr->is_const)
+ || space[j-1].num_values < space[j].num_values)
+ {
+ struct dimension tmp;
+ tmp = space[j];
+ space[j] = space[j-1];
+ space[j-1] = tmp;
+ }
+
+ /* Establish the initial current value. */
+ for (i = 0; i < ndim; i++)
+ space[i].current_value = space[i].values;
+
+ condtest = (rtx *) alloca (total * sizeof (rtx));
+ condval = (rtx *) alloca (total * sizeof (rtx));
+
+ /* Expand the tests and values by iterating over all values in the
+ attribute space. */
+ for (i = 0;; i++)
+ {
+ condtest[i] = test_for_current_value (space, ndim);
+ condval[i] = simplify_with_current_value (exp, space, ndim);
+ if (! increment_current_value (space, ndim))
+ break;
+ }
+ if (i != total - 1)
+ abort ();
+
+ /* We are now finished with the original expression. */
+ unmark_used_attributes (0, space, ndim);
+
+ /* Find the most used constant value and make that the default. */
+ most_tests = -1;
+ for (i = num_marks = 0; i < total; i++)
+ if (GET_CODE (condval[i]) == CONST_STRING
+ && ! MEM_VOLATILE_P (condval[i]))
+ {
+ /* Mark the unmarked constant value and count how many are marked. */
+ MEM_VOLATILE_P (condval[i]) = 1;
+ for (j = new_marks = 0; j < total; j++)
+ if (GET_CODE (condval[j]) == CONST_STRING
+ && MEM_VOLATILE_P (condval[j]))
+ new_marks++;
+ if (new_marks - num_marks > most_tests)
+ {
+ most_tests = new_marks - num_marks;
+ defval = condval[i];
+ }
+ num_marks = new_marks;
+ }
+ /* Clear all the marks. */
+ for (i = 0; i < total; i++)
+ MEM_VOLATILE_P (condval[i]) = 0;
+
+ /* Give up if nothing is constant. */
+ 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.) */
+ condexp = rtx_alloc (COND);
+ XVEC (condexp, 0) = rtvec_alloc ((total - most_tests) * 2);
+ XEXP (condexp, 1) = defval;
+ for (i = j = 0; i < total; i++)
+ if (condval[i] != defval)
+ {
+ XVECEXP (condexp, 0, 2 * j) = condtest[i];
+ XVECEXP (condexp, 0, 2 * j + 1) = condval[i];
+ j++;
+ }
+
+ return condexp;
+}
+
+/* Set the MEM_VOLATILE_P flag for all EQ_ATTR expressions in EXP and
+ verify that EXP can be simplified to a constant term if all the EQ_ATTR
+ tests have known value. */
+
+static int
+find_and_mark_used_attributes (exp, terms, nterms)
+ rtx exp, *terms;
+ int *nterms;
+{
+ int i;
+
+ switch (GET_CODE (exp))
+ {
+ case EQ_ATTR:
+ if (! MEM_VOLATILE_P (exp))
+ {
+ rtx link = rtx_alloc (EXPR_LIST);
+ 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, nterms))
+ return 0;
+ case IOR:
+ case AND:
+ 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, 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, nterms))
+ return 0;
+ if (! find_and_mark_used_attributes (XEXP (exp, 1), terms, nterms))
+ return 0;
+ return 1;
+ }
+
+ return 0;
+}
+
+/* Clear the MEM_VOLATILE_P flag in all EQ_ATTR expressions on LIST and
+ in the values of the NDIM-dimensional attribute space SPACE. */
+
+static void
+unmark_used_attributes (list, space, ndim)
+ rtx list;
+ struct dimension *space;
+ int ndim;
+{
+ rtx link, exp;
+ int i;
+
+ for (i = 0; i < ndim; i++)
+ unmark_used_attributes (space[i].values, 0, 0);
+
+ for (link = list; link; link = XEXP (link, 1))
+ {
+ exp = XEXP (link, 0);
+ if (GET_CODE (exp) == EQ_ATTR)
+ MEM_VOLATILE_P (exp) = 0;
+ }
+}
+
+/* Update the attribute dimension DIM so that all values of the attribute
+ are tested. Return the updated number of values. */
+
+static int
+add_values_to_cover (dim)
+ struct dimension *dim;
+{
+ struct attr_value *av;
+ rtx exp, link, *prev;
+ int nalt = 0;
+
+ for (av = dim->attr->first_value; av; av = av->next)
+ if (GET_CODE (av->value) == CONST_STRING)
+ nalt++;
+
+ if (nalt < dim->num_values)
+ abort ();
+ else if (nalt == dim->num_values)
+ ; /* Ok. */
+ else if (nalt * 2 < dim->num_values * 3)
+ {
+ /* Most all the values of the attribute are used, so add all the unused
+ values. */
+ prev = &dim->values;
+ for (link = dim->values; link; link = *prev)
+ prev = &XEXP (link, 1);
+
+ for (av = dim->attr->first_value; av; av = av->next)
+ if (GET_CODE (av->value) == CONST_STRING)
+ {
+ exp = attr_eq (dim->attr->name, XSTR (av->value, 0));
+ if (MEM_VOLATILE_P (exp))
+ continue;
+
+ link = rtx_alloc (EXPR_LIST);
+ XEXP (link, 0) = exp;
+ XEXP (link, 1) = 0;
+ *prev = link;
+ prev = &XEXP (link, 1);
+ }
+ dim->num_values = nalt;
+ }
+ else
+ {
+ rtx orexp = false_rtx;
+
+ /* Very few values are used, so compute a mutually exclusive
+ expression. (We could do this for numeric values if that becomes
+ important.) */
+ prev = &dim->values;
+ for (link = dim->values; link; link = *prev)
+ {
+ orexp = insert_right_side (IOR, orexp, XEXP (link, 0), -2, -2);
+ prev = &XEXP (link, 1);
+ }
+ link = rtx_alloc (EXPR_LIST);
+ XEXP (link, 0) = attr_rtx (NOT, orexp);
+ XEXP (link, 1) = 0;
+ *prev = link;
+ dim->num_values++;
+ }
+ return dim->num_values;
+}
+
+/* Increment the current value for the NDIM-dimensional attribute space SPACE
+ and return FALSE if the increment overflowed. */
+
+static int
+increment_current_value (space, ndim)
+ struct dimension *space;
+ int ndim;
+{
+ int i;
+
+ for (i = ndim - 1; i >= 0; i--)
+ {
+ if ((space[i].current_value = XEXP (space[i].current_value, 1)) == 0)
+ space[i].current_value = space[i].values;
+ else
+ return 1;
+ }
+ return 0;
+}
+
+/* Construct an expression corresponding to the current value for the
+ NDIM-dimensional attribute space SPACE. */
+
+static rtx
+test_for_current_value (space, ndim)
+ struct dimension *space;
+ int ndim;
+{
+ int i;
+ rtx exp = true_rtx;
+
+ for (i = 0; i < ndim; i++)
+ exp = insert_right_side (AND, exp, XEXP (space[i].current_value, 0),
+ -2, -2);
+
+ return exp;
+}
+
+/* Given the current value of the NDIM-dimensional attribute space SPACE,
+ set the corresponding EQ_ATTR expressions to that value and reduce
+ the expression EXP as much as possible. On input [and output], all
+ known EQ_ATTR expressions are set to FALSE. */
+
+static rtx
+simplify_with_current_value (exp, space, ndim)
+ rtx exp;
+ struct dimension *space;
+ int ndim;
+{
+ int i;
+ rtx x;
+
+ /* Mark each current value as TRUE. */
+ for (i = 0; i < ndim; i++)
+ {
+ x = XEXP (space[i].current_value, 0);
+ if (GET_CODE (x) == EQ_ATTR)
+ MEM_VOLATILE_P (x) = 0;
+ }
+
+ exp = simplify_with_current_value_aux (exp);
+
+ /* Change each current value back to FALSE. */
+ for (i = 0; i < ndim; i++)
+ {
+ x = XEXP (space[i].current_value, 0);
+ if (GET_CODE (x) == EQ_ATTR)
+ MEM_VOLATILE_P (x) = 1;
+ }
+
+ return exp;
+}
+
+/* Reduce the expression EXP based on the MEM_VOLATILE_P settings of
+ all EQ_ATTR expressions. */
+
+static rtx
+simplify_with_current_value_aux (exp)
+ rtx exp;
+{
+ register int i;
+ rtx cond;
+
+ switch (GET_CODE (exp))
+ {
+ case EQ_ATTR:
+ if (MEM_VOLATILE_P (exp))
+ return false_rtx;
+ else
+ return true_rtx;
+ case CONST_STRING:
+ return exp;
+
+ case IF_THEN_ELSE:
+ cond = simplify_with_current_value_aux (XEXP (exp, 0));
+ if (cond == true_rtx)
+ return simplify_with_current_value_aux (XEXP (exp, 1));
+ else if (cond == false_rtx)
+ return simplify_with_current_value_aux (XEXP (exp, 2));
+ else
+ return attr_rtx (IF_THEN_ELSE, cond,
+ simplify_with_current_value_aux (XEXP (exp, 1)),
+ simplify_with_current_value_aux (XEXP (exp, 2)));
+
+ case IOR:
+ cond = simplify_with_current_value_aux (XEXP (exp, 1));
+ if (cond == true_rtx)
+ return cond;
+ else if (cond == false_rtx)
+ return simplify_with_current_value_aux (XEXP (exp, 0));
+ else
+ return attr_rtx (IOR, cond,
+ simplify_with_current_value_aux (XEXP (exp, 0)));
+
+ case AND:
+ cond = simplify_with_current_value_aux (XEXP (exp, 1));
+ if (cond == true_rtx)
+ return simplify_with_current_value_aux (XEXP (exp, 0));
+ else if (cond == false_rtx)
+ return cond;
+ else
+ return attr_rtx (AND, cond,
+ simplify_with_current_value_aux (XEXP (exp, 0)));
+
+ case NOT:
+ cond = simplify_with_current_value_aux (XEXP (exp, 0));
+ if (cond == true_rtx)
+ return false_rtx;
+ else if (cond == false_rtx)
+ return true_rtx;
+ else
+ return attr_rtx (NOT, cond);
+
+ case COND:
+ for (i = 0; i < XVECLEN (exp, 0); i += 2)
+ {
+ cond = simplify_with_current_value_aux (XVECEXP (exp, 0, i));
+ if (cond == true_rtx)
+ return simplify_with_current_value_aux (XVECEXP (exp, 0, i + 1));
+ else if (cond == false_rtx)
+ continue;
+ else
+ abort (); /* With all EQ_ATTR's of known value, a case should
+ have been selected. */
+ }
+ return simplify_with_current_value_aux (XEXP (exp, 1));
+ }
+ abort ();
+}
+\f
+/* Clear the MEM_IN_STRUCT_P flag in EXP and its subexpressions. */
+
+static void
+clear_struct_flag (x)
+ rtx x;
+{
+ register int i;
+ register int j;
+ register enum rtx_code code;
+ register char *fmt;
+
+ MEM_IN_STRUCT_P (x) = 0;
+ if (RTX_UNCHANGING_P (x))
+ return;
+
+ code = GET_CODE (x);
+
+ switch (code)
+ {
+ case REG:
+ case QUEUED:
+ case CONST_INT:
+ case CONST_DOUBLE:
+ case SYMBOL_REF:
+ case CODE_LABEL:
+ case PC:
+ case CC0:
+ case EQ_ATTR:
+ case ATTR_FLAG:
+ return;
+ }
+
+ /* Compare the elements. If any pair of corresponding elements
+ fail to match, return 0 for the whole things. */
+
+ fmt = GET_RTX_FORMAT (code);
+ for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
+ {
+ switch (fmt[i])
+ {
+ case 'V':
+ case 'E':
+ for (j = 0; j < XVECLEN (x, i); j++)
+ clear_struct_flag (XVECEXP (x, i, j));
+ break;
+
+ case 'e':
+ clear_struct_flag (XEXP (x, i));
+ break;
+ }
+ }
+}
+
+/* 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;
+{
+ register int i;
+ register int j;
+ register enum rtx_code code;
+ register char *fmt;
+ int total = 0;
+
+ code = GET_CODE (x);
+
+ switch (code)
+ {
+ case REG:
+ case QUEUED:
+ case CONST_INT:
+ case CONST_DOUBLE:
+ case SYMBOL_REF:
+ case CODE_LABEL:
+ case PC:
+ case CC0:
+ case EQ_ATTR:
+ case ATTR_FLAG:
+ return 1;
+ }
+
+ /* Compare the elements. If any pair of corresponding elements
+ fail to match, return 0 for the whole things. */
+
+ fmt = GET_RTX_FORMAT (code);
+ for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
+ {
+ if (total >= max)
+ return total;
+
+ switch (fmt[i])
+ {
+ case 'V':
+ case 'E':
+ for (j = 0; j < XVECLEN (x, i); j++)
+ total += count_sub_rtxs (XVECEXP (x, i, j), max);
+ break;
+
+ case 'e':
+ total += count_sub_rtxs (XEXP (x, i), max);
+ break;
+ }
+ }
+ return total;
+
+}
\f
/* Create table entries for DEFINE_ATTR. */
name_ptr = XSTR (exp, 1);
while ((p = next_comma_elt (&name_ptr)) != NULL)
{
- av = (struct attr_value *) xmalloc (sizeof (struct attr_value));
+ av = (struct attr_value *) oballoc (sizeof (struct attr_value));
av->value = attr_rtx (CONST_STRING, p);
av->next = attr->first_value;
attr->first_value = av;
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);
}
{
struct insn_def *id;
- id = (struct insn_def *) xmalloc (sizeof (struct insn_def));
+ id = (struct insn_def *) oballoc (sizeof (struct insn_def));
id->next = defs;
defs = id;
id->def = exp;
have_annul_false = 1;
}
- delay = (struct delay_desc *) xmalloc (sizeof (struct delay_desc));
+ delay = (struct delay_desc *) oballoc (sizeof (struct delay_desc));
delay->def = def;
delay->num = ++num_delays;
delay->next = delays;
{
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 multipicity and simultaneity values are the same. If not, make
+ 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;
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 = (struct function_unit *) oballoc (sizeof (struct function_unit));
+ 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;
}
/* 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 = (struct function_unit_op *) oballoc (sizeof (struct function_unit_op));
+ 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))
{
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->busyexp = attr_rtx (IF_THEN_ELSE, orexp,
- make_numeric_value (XINT (def, 5)),
- make_numeric_value (0));
+ op->conflict_exp = orexp;
+ extend_range (&unit->issue_delay, 1, issue_delay);
}
else
- op->busyexp = make_numeric_value (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
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;
attr = find_attr (XSTR (exp, 0), 0);
if (! attr) abort ();
- printf ("get_attr_%s (insn) == ", attr->name);
- write_attr_valueq (attr, XSTR (exp, 1));
+
+ /* Now is the time to expand the value of a constant attribute. */
+ if (attr->is_const)
+ {
+ write_test_expr (evaluate_eq_attr (exp, attr->default_val->value,
+ -2, -2),
+ in_comparison);
+ }
+ else
+ {
+ printf ("get_attr_%s (insn) == ", attr->name);
+ write_attr_valueq (attr, XSTR (exp, 1));
+ }
+ 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. */
XSTR (exp, 1), XINT (exp, 0), GET_MODE_NAME (GET_MODE (exp)));
break;
- /* Constant integer. */
+ /* Constant integer. */
case CONST_INT:
- printf ("%d", XINT (exp, 0));
+#if HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_INT
+ printf ("%d", XWINT (exp, 0));
+#else
+ printf ("%ld", 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
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 ();
`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,
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_...'. */
/* 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);
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);
the specified insn can be annulled if the branch is true, and likewise
for `eligible_for_annul_false'.
- KIND is a string distingushing these three cases ("delay", "annul_true",
+ KIND is a string distinguishing these three cases ("delay", "annul_true",
or "annul_false"). */
static void
/* 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");
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)
{
- /* See if only one case exists and if there is a constant value for
- that case. If so, we don't need a function. */
- str = (char *) alloca (strlen (unit->name) + 10);
- sprintf (str, "*%s_cases", unit->name);
- attr = find_attr (str, 0);
- if (! attr) abort ();
- value = find_single_value (attr);
- if (value && GET_CODE (value) == CONST_STRING)
+ 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->needs_conflict_function)
{
- sprintf (str, "*%s_case_%s", unit->name, XSTR (value, 0));
- attr = find_attr (str, 0);
- if (! attr) abort ();
- value = find_single_value (attr);
- if (value && GET_CODE (value) == CONST_STRING)
- {
- unit->needs_conflict_function = 0;
- unit->default_cost = value;
- continue;
- }
+ 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);
+ write_complex_function (unit, "conflict_cost", "cost");
+ }
- 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");
+ /* Now that all functions have been written, write the table describing
+ the function units. The name is included for documentation purposes
+ only. */
- /* Write the `switch' statement to get the case value. */
- sprintf (str, "*%s_cases", unit->name);
- case_attr = find_attr (str, 0);
- if (! case_attr) abort ();
- common_av = find_most_used (case_attr);
+ printf ("struct function_unit_desc function_units[] = {\n");
- 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 out the descriptions in numeric order, but don't force that order
+ on the list. Doing so increases the runtime of genattrtab.c. */
+ for (i = 0; i < num_units; i++)
+ {
+ for (unit = units; unit; unit = unit->next)
+ if (unit->num == i)
+ break;
- write_attr_case (case_attr, common_av, 0,
- "casenum =", ";", 4, unit->condexp);
- printf (" }\n\n");
+ 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),
+ unit->issue_delay.max, unit->name);
- /* 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");
+ if (unit->needs_conflict_function)
+ printf ("%s_unit_conflict_cost, ", unit->name);
+ else
+ printf ("0, ");
- 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 ("%d, ", unit->max_blockage);
- printf (" case %d:\n", i);
- sprintf (str, "*%s_case_%d", unit->name, i);
- attr = find_attr (str, 0);
- if (! attr) abort ();
+ if (unit->needs_range_function)
+ printf ("%s_unit_blockage_range, ", unit->name);
+ else
+ printf ("0, ");
- /* 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");
+ if (unit->needs_blockage_function)
+ printf ("%s_unit_blockage", unit->name);
+ else
+ printf ("0");
- for (av = attr->first_value; av; av = av->next)
- if (av != common_av)
- write_attr_case (attr, av, 1,
- "return", ";", 8, unit->condexp);
+ printf ("}, \n");
+ }
- write_attr_case (attr, common_av, 0,
- "return", ";", 8, unit->condexp);
- printf (" }\n\n");
- }
- }
+ printf ("};\n\n");
+}
- printf (" }\n}\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;
- /* Now that all functions have been written, write the table describing
- the function units. The name is included for documenation purposes
- only. */
+ 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 = executing_insn;\n");
+ printf (" switch (recog_memoized (insn))\n");
+ printf (" {\n");
- printf ("struct function_unit_desc function_units[] = {\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 (unit = units; unit; unit = unit->next)
+ 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 = candidate_insn;\n");
+ printf (" switch (casenum)\n");
+ printf (" {\n");
+
+ for (i = 0; i < unit->num_opclasses; i++)
{
- printf (" {\"%s\", %d, %d, %d, %s, %s_unit_ready_cost, ",
- unit->name, 1 << unit->num, unit->multiplicity,
- unit->simultaneity, XSTR (unit->default_cost, 0), unit->name);
+ /* 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 (unit->needs_conflict_function)
- printf ("%s_unit_conflict_cost", unit->name);
+ 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, -2);
else
- printf ("0");
+ {
+ common_av = find_most_used (attr);
+ printf (" switch (recog_memoized (insn))\n");
+ printf ("\t{\n");
- printf ("}, \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");
+ printf (" }\n}\n\n");
}
\f
/* This page contains miscellaneous utility routines. */
int create;
{
struct attr_desc *attr;
- char *new_name;
+ int index;
/* Before we resort to using `strcmp', see if the string address matches
anywhere. In most cases, it should have been canonicalized to do so. */
if (name == alternative_name)
return NULL;
- for (attr = attrs; attr; attr = attr->next)
+ index = name[0] & (MAX_ATTRS_INDEX - 1);
+ for (attr = attrs[index]; attr; attr = attr->next)
if (name == attr->name)
return attr;
/* Otherwise, do it the slow way. */
- for (attr = attrs; attr; attr = attr->next)
+ for (attr = attrs[index]; attr; attr = attr->next)
if (name[0] == attr->name[0] && ! strcmp (name, attr->name))
return attr;
if (! create)
return NULL;
- new_name = (char *) xmalloc (strlen (name) + 1);
- strcpy (new_name, name);
-
- attr = (struct attr_desc *) xmalloc (sizeof (struct attr_desc));
- attr->name = new_name;
+ attr = (struct attr_desc *) oballoc (sizeof (struct attr_desc));
+ attr->name = attr_string (name, strlen (name));
attr->first_value = attr->default_val = NULL;
- attr->is_numeric = attr->is_const = attr->is_special = 0;
- attr->next = attrs;
- attrs = attr;
+ attr->is_numeric = attr->negative_ok = attr->is_const = attr->is_special = 0;
+ attr->next = attrs[index];
+ attrs[index] = attr;
return attr;
}
attr->is_numeric = 1;
attr->is_const = 0;
- attr->is_special = special;
+ 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);
}
if (n < 20 && int_values[n])
return int_values[n];
- p = attr_printf ((n < 1000 ? 4 : HOST_BITS_PER_INT * 3 / 10 + 3), "%d", n);
+ p = attr_printf (MAX_DIGITS, "%d", n);
exp = attr_rtx (CONST_STRING, p);
if (n < 20)
return exp;
}
\f
+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;
copy_rtx_unchanging (orig)
register rtx orig;
{
+#if 0
register rtx copy;
register RTX_CODE code;
+#endif
- if (RTX_UNCHANGING_P (orig))
+ if (RTX_UNCHANGING_P (orig) || MEM_IN_STRUCT_P (orig))
return orig;
- code = GET_CODE (orig);
+ MEM_IN_STRUCT_P (orig) = 1;
+ return orig;
+#if 0
+ code = GET_CODE (orig);
switch (code)
{
case CONST_INT:
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, i.e., the
+ number of delay slots is not a function of the length of the insn. */
+
+void
+write_const_num_delay_slots ()
+{
+ struct attr_desc *attr = find_attr ("*num_delay_slots", 0);
+ struct attr_value *av;
+ struct insn_ent *ie;
+ int i;
+
+ if (attr)
+ {
+ printf ("int\nconst_num_delay_slots (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)
+ {
+ 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 (" default:\n");
+ printf (" return 1;\n");
+ printf (" }\n}\n");
+ }
+}
+
\f
int
main (argc, argv)
FILE *infile;
register int c;
struct attr_desc *attr;
- struct attr_value *av;
struct insn_def *id;
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);
/* Set up true and false rtx's */
true_rtx = rtx_alloc (CONST_INT);
- XINT (true_rtx, 0) = 1;
+ XWINT (true_rtx, 0) = 1;
false_rtx = rtx_alloc (CONST_INT);
- XINT (false_rtx, 0) = 0;
+ XWINT (false_rtx, 0) = 0;
RTX_UNCHANGING_P (true_rtx) = RTX_UNCHANGING_P (false_rtx) = 1;
RTX_INTEGRATED_P (true_rtx) = RTX_INTEGRATED_P (false_rtx) = 1;
printf ("#define operands recog_operand\n\n");
/* Make `insn_alternatives'. */
- insn_alternatives = (int *) xmalloc (insn_code_number * sizeof (int));
+ insn_alternatives = (int *) oballoc (insn_code_number * sizeof (int));
for (id = defs; id; id = id->next)
if (id->insn_code >= 0)
insn_alternatives[id->insn_code] = (1 << id->num_alternatives) - 1;
+ /* Make `insn_n_alternatives'. */
+ insn_n_alternatives = (int *) oballoc (insn_code_number * sizeof (int));
+ for (id = defs; id; id = id->next)
+ if (id->insn_code >= 0)
+ insn_n_alternatives[id->insn_code] = id->num_alternatives;
+
/* Prepare to write out attribute subroutines by checking everything stored
away and building the attribute cases. */
check_defs ();
- for (attr = attrs; attr; attr = attr->next)
- {
- attr->default_val->value
- = check_attr_value (attr->default_val->value, attr);
- fill_attr (attr);
- }
+ 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);
+ fill_attr (attr);
+ }
/* 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
special routines (specifically before write_function_unit_info), so
that they get defined before they are used. */
- for (attr = attrs; attr; attr = attr->next)
- {
- if (! attr->is_special)
- write_attr_get (attr);
- }
+ for (i = 0; i < MAX_ATTRS_INDEX; i++)
+ for (attr = attrs[i]; attr; attr = attr->next)
+ {
+ if (! attr->is_special)
+ write_attr_get (attr);
+ }
/* Write out delay eligibility information, if DEFINE_DELAY present.
(The function to compute the number of delay slots will be written
if (num_units)
write_function_unit_info ();
+ /* Write out constant delay slot info */
+ write_const_num_delay_slots ();
+
fflush (stdout);
exit (ferror (stdout) != 0 ? FATAL_EXIT_CODE : SUCCESS_EXIT_CODE);
/* NOTREACHED */
OSDN Git Service
