/* 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 call `get_attr_...', one for each
+ It produces a series of functions named `get_attr_...', one for each insn
attribute. Each of these is given the rtx for an insn and returns a member
of the enum for the attribute.
changed are made. The resulting lengths are saved for use by
`get_attr_length'.
+ A special form of DEFINE_ATTR, where the expression for default value is a
+ CONST expression, indicates an attribute that is constant for a given run
+ of the compiler. The subroutine generated for these attributes has no
+ parameters as it does not depend on any particular insn. Constant
+ attributes are typically used to specify which variety of processor is
+ used.
+
Internal attributes are defined to handle DEFINE_DELAY and
DEFINE_FUNCTION_UNIT. Special routines are output for these cases.
optimization simplify them.
Once optimization is complete, any required routines and definitions
- will be written. */
-
-#include <stdio.h>
-#include "config.h"
+ will be written.
+
+ An optimization that is not yet implemented is to hoist the constant
+ expressions entirely out of the routines and definitions that are written.
+ A way to do this is to iterate over all possible combinations of values
+ 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).
+
+ 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
-static struct obstack obstack;
+/* We must include obstack.h after <sys/time.h>, to avoid lossage with
+ /usr/include/sys/stdtypes.h on Sun OS 4.x. */
+#include "obstack.h"
+
+static struct obstack obstack, obstack1, obstack2;
struct obstack *rtl_obstack = &obstack;
+struct obstack *hash_obstack = &obstack1;
+struct obstack *temp_obstack = &obstack2;
#define obstack_chunk_alloc xmalloc
#define obstack_chunk_free free
+/* Define this so we can link with print-rtl.o to get debug_rtx function. */
+char **insn_name_ptr = 0;
+
extern void free ();
+extern rtx read_rtx ();
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. */
- 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. */
+ 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. */
+};
+
+#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;
/* Used to reduce calls to `strcmp' */
-static char *alternative_name = "alternative";
+static char *alternative_name;
/* 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;
-
-static rtx check_attr_test ();
-static void check_attr_value ();
-static rtx convert_set_attr_alternative ();
-static rtx convert_set_attr ();
-static void check_defs ();
-static rtx make_canonical ();
-static struct attr_value *get_attr_value ();
-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 ();
+rtx frame_pointer_rtx, hard_frame_pointer_rtx, stack_pointer_rtx;
+rtx arg_pointer_rtx;
+
+static rtx attr_rtx PVPROTO((enum rtx_code, ...));
+#ifdef HAVE_VPRINTF
+static char *attr_printf PVPROTO((int, char *, ...));
+#else
+static char *attr_printf ();
+#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. */
+
+/* Each hash table slot is a bucket containing a chain of these structures.
+ Strings are given negative hash codes; RTL expressions are given positive
+ hash codes. */
+
+struct attr_hash
+{
+ struct attr_hash *next; /* Next structure in the bucket. */
+ int hashcode; /* Hash code of this rtx or string. */
+ union
+ {
+ char *str; /* The string (negative hash codes) */
+ rtx rtl; /* or the RTL recorded here. */
+ } u;
+};
+
+/* Now here is the hash table. When recording an RTL, it is added to
+ the slot whose index is the hash code mod the table size. Note
+ that the hash table is used for several kinds of RTL (see attr_rtx)
+ and for strings. While all these live in the same table, they are
+ completely independent, and the hash code is computed differently
+ for each. */
+
+#define RTL_HASH_SIZE 4093
+struct attr_hash *attr_hash_table[RTL_HASH_SIZE];
+
+/* Here is how primitive or already-shared RTL's hash
+ codes are made. */
+#define RTL_HASH(RTL) ((HOST_WIDE_INT) (RTL) & 0777777)
+
+/* Add an entry to the hash table for RTL with hash code HASHCODE. */
+
+static void
+attr_hash_add_rtx (hashcode, rtl)
+ int hashcode;
+ rtx rtl;
+{
+ register struct attr_hash *h;
+
+ h = (struct attr_hash *) obstack_alloc (hash_obstack,
+ sizeof (struct attr_hash));
+ h->hashcode = hashcode;
+ h->u.rtl = rtl;
+ h->next = attr_hash_table[hashcode % RTL_HASH_SIZE];
+ attr_hash_table[hashcode % RTL_HASH_SIZE] = h;
+}
+
+/* Add an entry to the hash table for STRING with hash code HASHCODE. */
+
+static void
+attr_hash_add_string (hashcode, str)
+ int hashcode;
+ char *str;
+{
+ register struct attr_hash *h;
+
+ h = (struct attr_hash *) obstack_alloc (hash_obstack,
+ sizeof (struct attr_hash));
+ h->hashcode = -hashcode;
+ h->u.str = str;
+ h->next = attr_hash_table[hashcode % RTL_HASH_SIZE];
+ attr_hash_table[hashcode % RTL_HASH_SIZE] = h;
+}
+
+/* Generate an RTL expression, but avoid duplicates.
+ Set the RTX_INTEGRATED_P flag for these permanent objects.
+
+ In some cases we cannot uniquify; then we return an ordinary
+ impermanent rtx with RTX_INTEGRATED_P clear.
+
+ Args are like gen_rtx, but without the mode:
+
+ rtx attr_rtx (code, [element1, ..., elementn]) */
+
+/*VARARGS1*/
+static rtx
+attr_rtx VPROTO((enum rtx_code code, ...))
+{
+#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... */
+ int hashcode;
+ register struct attr_hash *h;
+ struct obstack *old_obstack = rtl_obstack;
+
+ 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
+ to the table. */
+
+ if (GET_RTX_CLASS (code) == '1')
+ {
+ rtx arg0 = va_arg (p, rtx);
+
+ /* A permanent object cannot point to impermanent ones. */
+ if (! RTX_INTEGRATED_P (arg0))
+ {
+ rt_val = rtx_alloc (code);
+ XEXP (rt_val, 0) = arg0;
+ va_end (p);
+ return rt_val;
+ }
+
+ 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
+ && XEXP (h->u.rtl, 0) == arg0)
+ goto found;
+
+ if (h == 0)
+ {
+ rtl_obstack = hash_obstack;
+ rt_val = rtx_alloc (code);
+ XEXP (rt_val, 0) = arg0;
+ }
+ }
+ else if (GET_RTX_CLASS (code) == 'c'
+ || GET_RTX_CLASS (code) == '2'
+ || GET_RTX_CLASS (code) == '<')
+ {
+ rtx arg0 = va_arg (p, rtx);
+ rtx arg1 = va_arg (p, rtx);
+
+ /* A permanent object cannot point to impermanent ones. */
+ if (! RTX_INTEGRATED_P (arg0) || ! RTX_INTEGRATED_P (arg1))
+ {
+ rt_val = rtx_alloc (code);
+ XEXP (rt_val, 0) = arg0;
+ XEXP (rt_val, 1) = arg1;
+ va_end (p);
+ return rt_val;
+ }
+
+ 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
+ && XEXP (h->u.rtl, 0) == arg0
+ && XEXP (h->u.rtl, 1) == arg1)
+ goto found;
+
+ if (h == 0)
+ {
+ rtl_obstack = hash_obstack;
+ rt_val = rtx_alloc (code);
+ XEXP (rt_val, 0) = arg0;
+ XEXP (rt_val, 1) = arg1;
+ }
+ }
+ else if (GET_RTX_LENGTH (code) == 1
+ && GET_RTX_FORMAT (code)[0] == 's')
+ {
+ char * arg0 = va_arg (p, char *);
+
+ if (code == SYMBOL_REF)
+ arg0 = attr_string (arg0, strlen (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
+ && XSTR (h->u.rtl, 0) == arg0)
+ goto found;
+
+ if (h == 0)
+ {
+ rtl_obstack = hash_obstack;
+ rt_val = rtx_alloc (code);
+ XSTR (rt_val, 0) = arg0;
+ }
+ }
+ else if (GET_RTX_LENGTH (code) == 2
+ && GET_RTX_FORMAT (code)[0] == 's'
+ && GET_RTX_FORMAT (code)[1] == 's')
+ {
+ char *arg0 = va_arg (p, char *);
+ char *arg1 = va_arg (p, char *);
+
+ 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
+ && XSTR (h->u.rtl, 0) == arg0
+ && XSTR (h->u.rtl, 1) == arg1)
+ goto found;
+
+ if (h == 0)
+ {
+ rtl_obstack = hash_obstack;
+ rt_val = rtx_alloc (code);
+ XSTR (rt_val, 0) = arg0;
+ XSTR (rt_val, 1) = arg1;
+ }
+ }
+ else if (code == CONST_INT)
+ {
+ HOST_WIDE_INT arg0 = va_arg (p, HOST_WIDE_INT);
+ if (arg0 == 0)
+ return false_rtx;
+ if (arg0 == 1)
+ return true_rtx;
+ goto nohash;
+ }
+ else
+ {
+ nohash:
+ rt_val = rtx_alloc (code); /* Allocate the storage space. */
+
+ fmt = GET_RTX_FORMAT (code); /* Find the right format... */
+ for (i = 0; i < GET_RTX_LENGTH (code); i++)
+ {
+ switch (*fmt++)
+ {
+ case '0': /* Unused field. */
+ break;
+
+ case 'i': /* An integer? */
+ 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;
+
+ case 'e': /* An expression? */
+ case 'u': /* An insn? Same except when printing. */
+ XEXP (rt_val, i) = va_arg (p, rtx);
+ break;
+
+ case 'E': /* An RTX vector? */
+ XVEC (rt_val, i) = va_arg (p, rtvec);
+ break;
+
+ default:
+ abort();
+ }
+ }
+ va_end (p);
+ return rt_val;
+ }
+
+ rtl_obstack = old_obstack;
+ va_end (p);
+ attr_hash_add_rtx (hashcode, rt_val);
+ RTX_INTEGRATED_P (rt_val) = 1;
+ return rt_val;
+
+ found:
+ va_end (p);
+ return h->u.rtl;
+}
+
+/* Create a new string printed with the printf line arguments into a space
+ of at most LEN bytes:
+
+ rtx attr_printf (len, format, [arg1, ..., argn]) */
+
+#ifdef HAVE_VPRINTF
+
+/*VARARGS2*/
+static char *
+attr_printf VPROTO((register int len, char *fmt, ...))
+{
+#ifndef __STDC__
+ register int len;
+ char *fmt;
+#endif
+ va_list p;
+ register char *str;
+
+ VA_START (p, fmt);
+
+#ifndef __STDC__
+ len = va_arg (p, int);
+ 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 attr_string (str, strlen (str));
+}
+
+#else /* not HAVE_VPRINTF */
+
+static char *
+attr_printf (len, fmt, arg1, arg2, arg3)
+ int len;
+ char *fmt;
+ char *arg1, *arg2, *arg3; /* also int */
+{
+ register char *str;
+
+ /* Print the string into a temporary location. */
+ str = (char *) alloca (len);
+ sprintf (str, fmt, arg1, arg2, arg3);
+
+ return attr_string (str, strlen (str));
+}
+#endif /* not HAVE_VPRINTF */
+
+rtx
+attr_eq (name, value)
+ char *name, *value;
+{
+ return attr_rtx (EQ_ATTR, attr_string (name, strlen (name)),
+ attr_string (value, strlen (value)));
+}
+
+char *
+attr_numeral (n)
+ int n;
+{
+ return XSTR (make_numeric_value (n), 0);
+}
+
+/* Return a permanent (possibly shared) copy of a string STR (not assumed
+ to be null terminated) with LEN bytes. */
+
+static char *
+attr_string (str, len)
+ char *str;
+ int len;
+{
+ register struct attr_hash *h;
+ int hashcode;
+ int i;
+ register char *new_str;
+
+ /* Compute the hash code. */
+ hashcode = (len + 1) * 613 + (unsigned)str[0];
+ for (i = 1; i <= len; i += 2)
+ hashcode = ((hashcode * 613) + (unsigned)str[i]);
+ if (hashcode < 0)
+ hashcode = -hashcode;
+
+ /* Search the table for the string. */
+ for (h = attr_hash_table[hashcode % RTL_HASH_SIZE]; h; h = h->next)
+ if (h->hashcode == -hashcode && h->u.str[0] == str[0]
+ && !strncmp (h->u.str, str, len))
+ return h->u.str; /* <-- return if found. */
+
+ /* Not found; create a permanent copy and add it to the hash table. */
+ 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);
+
+ return new_str; /* Return the new string. */
+}
+
+/* Check two rtx's for equality of contents,
+ taking advantage of the fact that if both are hashed
+ then they can't be equal unless they are the same object. */
+
+int
+attr_equal_p (x, y)
+ rtx x, y;
+{
+ return (x == y || (! (RTX_INTEGRATED_P (x) && RTX_INTEGRATED_P (y))
+ && rtx_equal_p (x, y)));
+}
+\f
+/* Copy an attribute value expression,
+ descending to all depths, but not copying any
+ permanent hashed subexpressions. */
+
+rtx
+attr_copy_rtx (orig)
+ register rtx orig;
+{
+ register rtx copy;
+ register int i, j;
+ register RTX_CODE code;
+ register char *format_ptr;
+
+ /* No need to copy a permanent object. */
+ if (RTX_INTEGRATED_P (orig))
+ return orig;
+
+ code = GET_CODE (orig);
+
+ switch (code)
+ {
+ case REG:
+ case QUEUED:
+ case CONST_INT:
+ case CONST_DOUBLE:
+ case SYMBOL_REF:
+ case CODE_LABEL:
+ case PC:
+ case CC0:
+ return orig;
+ }
+
+ copy = rtx_alloc (code);
+ PUT_MODE (copy, GET_MODE (orig));
+ copy->in_struct = orig->in_struct;
+ copy->volatil = orig->volatil;
+ copy->unchanging = orig->unchanging;
+ copy->integrated = orig->integrated;
+
+ format_ptr = GET_RTX_FORMAT (GET_CODE (copy));
+
+ for (i = 0; i < GET_RTX_LENGTH (GET_CODE (copy)); i++)
+ {
+ switch (*format_ptr++)
+ {
+ case 'e':
+ XEXP (copy, i) = XEXP (orig, i);
+ if (XEXP (orig, i) != NULL)
+ XEXP (copy, i) = attr_copy_rtx (XEXP (orig, i));
+ break;
+
+ case 'E':
+ case 'V':
+ XVEC (copy, i) = XVEC (orig, i);
+ if (XVEC (orig, i) != NULL)
+ {
+ XVEC (copy, i) = rtvec_alloc (XVECLEN (orig, i));
+ for (j = 0; j < XVECLEN (copy, i); j++)
+ XVECEXP (copy, i, j) = attr_copy_rtx (XVECEXP (orig, i, j));
+ }
+ break;
+
+ case 'n':
+ case 'i':
+ XINT (copy, i) = XINT (orig, i);
+ break;
+
+ case 'w':
+ XWINT (copy, i) = XWINT (orig, i);
+ break;
+
+ case 's':
+ case 'S':
+ XSTR (copy, i) = XSTR (orig, i);
+ break;
+
+ default:
+ abort ();
+ }
+ }
+ return copy;
+}
\f
/* Given a test expression for an attribute, ensure it is validly formed.
+ IS_CONST indicates whether the expression is constant for each compiler
+ run (a constant expression may not test any particular insn).
+
Convert (eq_attr "att" "a1,a2") to (ior (eq_attr ... ) (eq_attrq ..))
and (eq_attr "att" "!a1") to (not (eq_attr "att" "a1")). Do the latter
test first so that (eq_attr "att" "!a1,a2,a3") works as expected.
Return the new expression, if any. */
static rtx
-check_attr_test (exp)
+check_attr_test (exp, is_const)
rtx exp;
+ int is_const;
{
struct attr_desc *attr;
struct attr_value *av;
case EQ_ATTR:
/* Handle negation test. */
if (XSTR (exp, 1)[0] == '!')
- {
- XSTR(exp, 1) = &XSTR(exp, 1)[1];
- newexp = rtx_alloc (NOT);
- XEXP (newexp, 0) = exp;
-
- return check_attr_test (newexp);
- }
+ return check_attr_test (attr_rtx (NOT,
+ attr_eq (XSTR (exp, 0),
+ &XSTR (exp, 1)[1])),
+ is_const);
else if (n_comma_elts (XSTR (exp, 1)) == 1)
{
- attr = find_attr (XEXP (exp, 0), 0);
+ attr = find_attr (XSTR (exp, 0), 0);
if (attr == NULL)
{
if (! strcmp (XSTR (exp, 0), "alternative"))
RTX_UNCHANGING_P (exp) = 1;
return exp;
}
- else
+ else
fatal ("Unknown attribute `%s' in EQ_ATTR", XEXP (exp, 0));
}
- XSTR (exp, 0) = attr->name;
+ if (is_const && ! attr->is_const)
+ fatal ("Constant expression uses insn attribute `%s' in EQ_ATTR",
+ XEXP (exp, 0));
+
+ /* Copy this just to make it permanent,
+ 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)
{
name_ptr = XSTR (exp, 1);
while ((p = next_comma_elt (&name_ptr)) != NULL)
{
- newexp = rtx_alloc (EQ_ATTR);
- XSTR (newexp, 0) = XSTR (exp, 0);
- XSTR (newexp, 1) = p;
- orexp = insert_right_side (IOR, orexp, newexp, -2);
+ newexp = attr_eq (XSTR (exp, 0), p);
+ orexp = insert_right_side (IOR, orexp, newexp, -2, -2);
}
- return check_attr_test (orexp);
+ 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;
case IOR:
case AND:
- XEXP (exp, 0) = check_attr_test (XEXP (exp, 0));
- XEXP (exp, 1) = check_attr_test (XEXP (exp, 1));
+ XEXP (exp, 0) = check_attr_test (XEXP (exp, 0), is_const);
+ XEXP (exp, 1) = check_attr_test (XEXP (exp, 1), is_const);
break;
case NOT:
- XEXP (exp, 0) = check_attr_test (XEXP (exp, 0));
+ XEXP (exp, 0) = check_attr_test (XEXP (exp, 0), is_const);
break;
case MATCH_OPERAND:
+ if (is_const)
+ fatal ("RTL operator \"%s\" not valid in constant attribute test",
+ GET_RTX_NAME (MATCH_OPERAND));
+ /* These cases can't be simplified. */
+ RTX_UNCHANGING_P (exp) = 1;
+ break;
+
case LE: case LT: case GT: case GE:
case LEU: case LTU: case GTU: case GEU:
case NE: case EQ:
+ if (GET_CODE (XEXP (exp, 0)) == SYMBOL_REF
+ && GET_CODE (XEXP (exp, 1)) == SYMBOL_REF)
+ exp = attr_rtx (GET_CODE (exp),
+ attr_rtx (SYMBOL_REF, XSTR (XEXP (exp, 0), 0)),
+ attr_rtx (SYMBOL_REF, XSTR (XEXP (exp, 1), 0)));
/* These cases can't be simplified. */
RTX_UNCHANGING_P (exp) = 1;
break;
+ case SYMBOL_REF:
+ if (is_const)
+ {
+ /* These cases are valid for constant attributes, but can't be
+ simplified. */
+ exp = attr_rtx (SYMBOL_REF, XSTR (exp, 0));
+ RTX_UNCHANGING_P (exp) = 1;
+ break;
+ }
default:
fatal ("RTL operator \"%s\" not valid in attribute test",
GET_RTX_NAME (GET_CODE (exp)));
\f
/* Given an expression, ensure that it is validly formed and that all named
attribute values are valid for the given attribute. Issue a fatal error
- if not. If no attribute is specified, assume a numeric attribute. */
+ if not. If no attribute is specified, assume a numeric attribute.
-static void
+ Return a perhaps modified replacement expression for the value. */
+
+static rtx
check_attr_value (exp, attr)
rtx exp;
struct attr_desc *attr;
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 ? "internal" : attr->name);
+ attr ? attr->name : "internal");
break;
}
if (av == NULL)
fatal ("Unknown value `%s' for `%s' attribute",
- XSTR (exp, 0), attr ? "internal" : attr->name);
+ XSTR (exp, 0), attr ? attr->name : "internal");
- return;
+ break;
case IF_THEN_ELSE:
- XEXP (exp, 0) = check_attr_test (XEXP (exp, 0));
- check_attr_value (XEXP (exp, 1), attr);
- check_attr_value (XEXP (exp, 2), attr);
- return;
+ XEXP (exp, 0) = check_attr_test (XEXP (exp, 0),
+ attr ? attr->is_const : 0);
+ XEXP (exp, 1) = check_attr_value (XEXP (exp, 1), attr);
+ XEXP (exp, 2) = check_attr_value (XEXP (exp, 2), attr);
+ break;
case COND:
if (XVECLEN (exp, 0) % 2 != 0)
for (i = 0; i < XVECLEN (exp, 0); i += 2)
{
- XVECEXP (exp, 0, i) = check_attr_test (XVECEXP (exp, 0, i));
- check_attr_value (XVECEXP (exp, 0, i + 1), attr);
+ XVECEXP (exp, 0, i) = check_attr_test (XVECEXP (exp, 0, i),
+ attr ? attr->is_const : 0);
+ XVECEXP (exp, 0, i + 1)
+ = check_attr_value (XVECEXP (exp, 0, i + 1), attr);
}
- check_attr_value (XEXP (exp, 1), attr);
- return;
+ XEXP (exp, 1) = check_attr_value (XEXP (exp, 1), attr);
+ break;
+
+ case SYMBOL_REF:
+ if (attr && attr->is_const)
+ /* 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... */
default:
- fatal ("Illegal operation `%s' for attribute value",
+ fatal ("Invalid operation `%s' for attribute value",
GET_RTX_NAME (GET_CODE (exp)));
}
+
+ return exp;
}
\f
/* Given an SET_ATTR_ALTERNATIVE expression, convert to the canonical SET.
int num_alt;
int insn_code, insn_index;
{
- rtx newexp;
rtx condexp;
int i;
for (i = 0; i < num_alt - 1; i++)
{
+ char *p;
+ p = attr_numeral (i);
+
+ XVECEXP (condexp, 0, 2 * i) = attr_eq (alternative_name, p);
+#if 0
+ /* Sharing this EQ_ATTR rtl causes trouble. */
XVECEXP (condexp, 0, 2 * i) = rtx_alloc (EQ_ATTR);
XSTR (XVECEXP (condexp, 0, 2 * i), 0) = alternative_name;
- XSTR (XVECEXP (condexp, 0, 2 * i), 1) = (char *) xmalloc (3);
- sprintf (XSTR (XVECEXP (condexp, 0, 2 * i), 1), "%d", i);
+ XSTR (XVECEXP (condexp, 0, 2 * i), 1) = p;
+#endif
XVECEXP (condexp, 0, 2 * i + 1) = XVECEXP (exp, 1, i);
}
XEXP (condexp, 1) = XVECEXP (exp, 1, i);
- newexp = rtx_alloc (SET);
- XEXP (newexp, 0) = rtx_alloc (ATTR);
- XSTR (XEXP (newexp, 0), 0) = XSTR (exp, 0);
- XEXP (newexp, 1) = condexp;
-
- return newexp;
+ return attr_rtx (SET, attr_rtx (ATTR, XSTR (exp, 0)), condexp);
}
\f
/* Given a SET_ATTR, convert to the appropriate SET. If a comma-separated
/* See how many alternative specified. */
n = n_comma_elts (XSTR (exp, 1));
if (n == 1)
- {
- newexp = rtx_alloc (SET);
- XEXP (newexp, 0) = rtx_alloc (ATTR);
- XSTR (XEXP (newexp, 0), 0) = XSTR (exp, 0);
- XEXP (newexp, 1) = rtx_alloc (CONST_STRING);
- XSTR (XEXP (newexp, 1), 0) = XSTR (exp, 1);
-
- return newexp;
- }
+ return attr_rtx (SET,
+ attr_rtx (ATTR, XSTR (exp, 0)),
+ attr_rtx (CONST_STRING, XSTR (exp, 1)));
newexp = rtx_alloc (SET_ATTR_ALTERNATIVE);
XSTR (newexp, 0) = XSTR (exp, 0);
name_ptr = XSTR (exp, 1);
n = 0;
while ((p = next_comma_elt (&name_ptr)) != NULL)
- {
- XVECEXP (newexp, 1, n) = rtx_alloc (CONST_STRING);
- XSTR (XVECEXP (newexp, 1, n++), 0) = p;
- }
+ XVECEXP (newexp, 1, n++) = attr_rtx (CONST_STRING, p);
return convert_set_attr_alternative (newexp, num_alt, insn_code, insn_index);
}
\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 ()
XSTR (XEXP (value, 0), 0), id->insn_index);
XVECEXP (id->def, id->vec_idx, i) = value;
- check_attr_value (XEXP (value, 1), attr);
+ XEXP (value, 1) = check_attr_value (XEXP (value, 1), attr);
}
}
}
\f
+/* Given a constant SYMBOL_REF expression, convert to a COND that
+ explicitly tests each enumerated value. */
+
+static rtx
+convert_const_symbol_ref (exp, attr)
+ rtx exp;
+ struct attr_desc *attr;
+{
+ rtx condexp;
+ struct attr_value *av;
+ int i;
+ int num_alt = 0;
+
+ for (av = attr->first_value; av; av = av->next)
+ num_alt++;
+
+ /* Make a COND with all tests but the last, and in the original order.
+ Select the last value via the default. Note that the attr values
+ are constructed in reverse order. */
+
+ condexp = rtx_alloc (COND);
+ XVEC (condexp, 0) = rtvec_alloc ((num_alt - 1) * 2);
+ av = attr->first_value;
+ XEXP (condexp, 1) = av->value;
+
+ for (i = num_alt - 2; av = av->next, i >= 0; i--)
+ {
+ char *p, *string;
+ rtx value;
+
+ string = p = (char *) oballoc (2
+ + strlen (attr->name)
+ + strlen (XSTR (av->value, 0)));
+ strcpy (p, attr->name);
+ strcat (p, "_");
+ strcat (p, XSTR (av->value, 0));
+ for (; *p != '\0'; p++)
+ if (*p >= 'a' && *p <= 'z')
+ *p -= 'a' - 'A';
+
+ value = attr_rtx (SYMBOL_REF, string);
+ RTX_UNCHANGING_P (value) = 1;
+
+ XVECEXP (condexp, 0, 2 * i) = attr_rtx (EQ, exp, value);
+
+ XVECEXP (condexp, 0, 2 * i + 1) = av->value;
+ }
+
+ return condexp;
+}
+\f
/* Given a valid expression for an attribute value, remove any IF_THEN_ELSE
expressions by converting them into a COND. This removes cases from this
program. Also, replace an attribute value of "*" with the default attribute
break;
- case IF_THEN_ELSE:
- newexp = rtx_alloc (COND);
+ 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);
+ /* Goto COND case since this is now a COND. Note that while the
+ new expression is rescanned, all symbol_ref notes are mared as
+ unchanging. */
+ goto cond;
+
+ case IF_THEN_ELSE:
+ newexp = rtx_alloc (COND);
XVEC (newexp, 0) = rtvec_alloc (2);
XVECEXP (newexp, 0, 0) = XEXP (exp, 0);
XVECEXP (newexp, 0, 1) = XEXP (exp, 1);
/* Fall through to COND case since this is now a COND. */
case COND:
- /* First, check for degenerate COND. */
- if (XVECLEN (exp, 0) == 0)
- return make_canonical (attr, XEXP (exp, 1));
+ cond:
+ {
+ int allsame = 1;
+ rtx defval;
- for (i = 0; i < XVECLEN (exp, 0); i += 2)
- XVECEXP (exp, 0, i + 1)
- = make_canonical (attr, XVECEXP (exp, 0, i + 1));
+ /* 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));
- XEXP (exp, 1) = make_canonical (attr, XEXP (exp, 1));
- break;
+ for (i = 0; i < XVECLEN (exp, 0); i += 2)
+ {
+ XVECEXP (exp, 0, i) = copy_boolean (XVECEXP (exp, 0, i));
+ XVECEXP (exp, 0, i + 1)
+ = make_canonical (attr, XVECEXP (exp, 0, i + 1));
+ if (! rtx_equal_p (XVECEXP (exp, 0, i + 1), defval))
+ allsame = 0;
+ }
+ if (allsame)
+ return defval;
+ break;
+ }
}
return exp;
}
+
+static rtx
+copy_boolean (exp)
+ rtx exp;
+{
+ if (GET_CODE (exp) == AND || GET_CODE (exp) == IOR)
+ return attr_rtx (GET_CODE (exp), copy_boolean (XEXP (exp, 0)),
+ copy_boolean (XEXP (exp, 1)));
+ return exp;
+}
\f
/* Given a value and an attribute description, return a `struct attr_value *'
that represents that value. This is either an existing structure, if the
|| 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)
{
for (i = 0; i < XVECLEN (delay->def, 1); i += 3)
{
- newexp = rtx_alloc (IF_THEN_ELSE);
condexp = XVECEXP (delay->def, 1, i);
if (condexp == 0) condexp = false_rtx;
- XEXP (newexp, 0) = condexp;
- XEXP (newexp, 1) = make_numeric_value (1);
- XEXP (newexp, 2) = make_numeric_value (0);
+ newexp = attr_rtx (IF_THEN_ELSE, condexp,
+ make_numeric_value (1), make_numeric_value (0));
- p = (char *) xmalloc (13);
- sprintf (p, "*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 = rtx_alloc (IF_THEN_ELSE);
condexp = XVECEXP (delay->def, 1, i + 1);
if (condexp == 0) condexp = false_rtx;
- XEXP (newexp, 0) = condexp;
- XEXP (newexp, 1) = make_numeric_value (1);
- XEXP (newexp, 2) = make_numeric_value (0);
- p = (char *) xmalloc (18);
- sprintf (p, "*annul_true_%d_%d", delay->num, i / 3);
+ newexp = attr_rtx (IF_THEN_ELSE, condexp,
+ make_numeric_value (1),
+ make_numeric_value (0));
+ p = attr_printf (sizeof ("*annul_true__") + MAX_DIGITS*2,
+ "*annul_true_%d_%d", delay->num, i / 3);
make_internal_attr (p, newexp, 1);
}
if (have_annul_false)
{
- newexp = rtx_alloc (IF_THEN_ELSE);
condexp = XVECEXP (delay->def, 1, i + 2);
if (condexp == 0) condexp = false_rtx;
- XEXP (newexp, 0) = condexp;
- XEXP (newexp, 1) = make_numeric_value (1);
- XEXP (newexp, 2) = make_numeric_value (0);
- p = (char *) xmalloc (18);
- sprintf (p, "*annul_false_%d_%d", delay->num, i / 3);
+ newexp = attr_rtx (IF_THEN_ELSE, condexp,
+ make_numeric_value (1),
+ make_numeric_value (0));
+ 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 ();
}
else if (GET_CODE (right) == IF_THEN_ELSE)
{
/* Apply recursively to all values within. */
- newexp = rtx_alloc (IF_THEN_ELSE);
- XEXP (newexp, 0) = XEXP (right, 0);
- XEXP (newexp, 1) = operate_exp (op, left, XEXP (right, 1));
- XEXP (newexp, 2) = operate_exp (op, left, XEXP (right, 2));
-
- return newexp;
+ rtx newleft = operate_exp (op, left, XEXP (right, 1));
+ rtx newright = operate_exp (op, left, XEXP (right, 2));
+ if (rtx_equal_p (newleft, newright))
+ return newleft;
+ return attr_rtx (IF_THEN_ELSE, XEXP (right, 0), newleft, newright);
}
else if (GET_CODE (right) == COND)
{
+ int allsame = 1;
+ rtx defval;
+
newexp = rtx_alloc (COND);
XVEC (newexp, 0) = rtvec_alloc (XVECLEN (right, 0));
+ defval = XEXP (newexp, 1) = operate_exp (op, left, XEXP (right, 1));
+
for (i = 0; i < XVECLEN (right, 0); i += 2)
{
XVECEXP (newexp, 0, i) = XVECEXP (right, 0, i);
XVECEXP (newexp, 0, i + 1)
= operate_exp (op, left, XVECEXP (right, 0, i + 1));
+ if (! rtx_equal_p (XVECEXP (newexp, 0, i + 1),
+ defval))
+ allsame = 0;
+ }
+
+ /* If the resulting cond is trivial (all alternatives
+ give the same value), optimize it away. */
+ if (allsame)
+ {
+ obstack_free (rtl_obstack, newexp);
+ return operate_exp (op, left, XEXP (right, 1));
}
- XEXP (newexp, 1) = operate_exp (op, left, XEXP (right, 1));
+ /* If the result is the same as the RIGHT operand,
+ just use that. */
+ if (rtx_equal_p (newexp, right))
+ {
+ obstack_free (rtl_obstack, newexp);
+ return right;
+ }
return newexp;
}
/* Otherwise, do recursion the other way. */
else if (GET_CODE (left) == IF_THEN_ELSE)
{
- newexp = rtx_alloc (IF_THEN_ELSE);
- XEXP (newexp, 0) = XEXP (left, 0);
- XEXP (newexp, 1) = operate_exp (op, XEXP (left, 1), right);
- XEXP (newexp, 2) = operate_exp (op, XEXP (left, 2), right);
-
- return newexp;
+ rtx newleft = operate_exp (op, XEXP (left, 1), right);
+ rtx newright = operate_exp (op, XEXP (left, 2), right);
+ if (rtx_equal_p (newleft, newright))
+ return newleft;
+ return attr_rtx (IF_THEN_ELSE, XEXP (left, 0), newleft, newright);
}
-
else if (GET_CODE (left) == COND)
{
+ int allsame = 1;
+ rtx defval;
+
newexp = rtx_alloc (COND);
XVEC (newexp, 0) = rtvec_alloc (XVECLEN (left, 0));
+ defval = XEXP (newexp, 1) = operate_exp (op, XEXP (left, 1), right);
+
for (i = 0; i < XVECLEN (left, 0); i += 2)
{
XVECEXP (newexp, 0, i) = XVECEXP (left, 0, i);
XVECEXP (newexp, 0, i + 1)
= operate_exp (op, XVECEXP (left, 0, i + 1), right);
+ if (! rtx_equal_p (XVECEXP (newexp, 0, i + 1),
+ defval))
+ allsame = 0;
+ }
+
+ /* If the cond is trivial (all alternatives give the same value),
+ optimize it away. */
+ if (allsame)
+ {
+ obstack_free (rtl_obstack, newexp);
+ return operate_exp (op, XEXP (left, 1), right);
}
- XEXP (newexp, 1) = operate_exp (op, XEXP (left, 1), right);
+ /* If the result is the same as the LEFT operand,
+ just use that. */
+ if (rtx_equal_p (newexp, left))
+ {
+ obstack_free (rtl_obstack, newexp);
+ return left;
+ }
return newexp;
}
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. */
+
+ 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);
+ }
- /* Initially, cost and masks are zero. */
- unitsmask = readycost = make_numeric_value (0);
+ /* 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)
{
- /* 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);
+ XEXP (newexp, 0) = unit->condexp;
+ XEXP (newexp, 1) = make_numeric_value (1 << unit->num);
+ unitsmask = operate_exp (OR_OP, unitsmask, newexp);
+ }
- XVEC (readyexp, 0) = rtvec_alloc ((unit->num_opclasses - 1) * 2);
- XVEC (caseexp, 0) = rtvec_alloc ((unit->num_opclasses - 1) * 2);
+ /* 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)
{
- str = (char *) xmalloc (strlen (unit->name) + 11);
+ 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)
+ {
+ rtx caseexp;
- /* 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);
- check_attr_value (op->busyexp, 0);
- sprintf (str, "*%s_case_%d", unit->name, op->num);
- make_internal_attr (str, make_canonical (0, op->busyexp));
+ if (! unit->needs_conflict_function
+ && ! unit->needs_blockage_function)
+ continue;
+
+ caseexp = rtx_alloc (COND);
+ XVEC (caseexp, 0) = rtvec_alloc ((unit->num_opclasses - 1) * 2);
- /* 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. */
+ for (op = unit->ops; op; op = op->next)
+ {
+ /* 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 = (char *) xmalloc (strlen (unit->name) + 8);
- sprintf (str, "*%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 = (char *) xmalloc (strlen (unit->name) + 20);
- sprintf (str, "*%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);
- 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;
- XEXP (newexp, 1) = readyexp;
- readycost = operate_exp (MAX_OP, readycost, newexp);
+ 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));
+
+ 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);
if (address_used)
return (*address_fn) (exp);
- newexp = rtx_alloc (IF_THEN_ELSE);
- XEXP (newexp, 0) = substitute_address (XEXP (exp, 0),
- no_address_fn, address_fn);
- XEXP (newexp, 1) = substitute_address (XEXP (exp, 1),
- no_address_fn, address_fn);
- XEXP (newexp, 2) = substitute_address (XEXP (exp, 2),
- no_address_fn, address_fn);
-
- return newexp;
+ return attr_rtx (IF_THEN_ELSE,
+ substitute_address (XEXP (exp, 0),
+ no_address_fn, address_fn),
+ substitute_address (XEXP (exp, 1),
+ no_address_fn, address_fn),
+ substitute_address (XEXP (exp, 2),
+ no_address_fn, address_fn));
}
return (*no_address_fn) (exp);
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;
if (! length_attr->is_numeric)
fatal ("length attribute must be numeric.");
+ length_attr->is_const = 0;
length_attr->is_special = 1;
/* Make each new attribute, in turn. */
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);
Also call ourselves on any COND operations that are values of this COND.
- We only do the first replacement found directly and call ourselves
- recursively for subsequent replacements. */
+ We do not modify EXP; rather, we make and return a new rtx. */
static rtx
simplify_cond (exp, insn_code, insn_index)
int insn_code, insn_index;
{
int i, j;
- rtx newtest;
- rtx value;
- rtx newexp = exp;
-
- for (i = 0; i < XVECLEN (exp, 0); i += 2)
- {
- newtest = SIMPLIFY_TEST_EXP (XVECEXP (exp, 0, i), insn_code, insn_index);
- if (newtest == true_rtx)
- {
- /* Make a new COND with any previous conditions and the value for
- this pair as the default value. */
- newexp = rtx_alloc (COND);
- XVEC (newexp, 0) = rtvec_alloc (i);
- for (j = 0; j < i; j++)
- XVECEXP (newexp, 0, j) = XVECEXP (exp, 0, j);
+ /* We store the desired contents here,
+ 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);
+ rtunion *tests = (rtunion *) alloca (len * sizeof (rtunion));
+ int allsame = 1;
+ char *first_spacer;
- XEXP (newexp, 1) = XVECEXP (exp, 0, i + 1);
- break;
- }
+ /* This lets us free all storage allocated below, if appropriate. */
+ first_spacer = (char *) obstack_finish (rtl_obstack);
- else if (newtest == false_rtx)
- {
- /* Build a new COND without this test. */
- newexp = rtx_alloc (COND);
- XVEC (newexp, 0) = rtvec_alloc (XVECLEN (exp, 0) - 2);
- for (j = 0; j < i; j++)
- XVECEXP (newexp, 0, j) = XVECEXP (exp, 0, j);
+ bcopy ((char *) XVEC (exp, 0)->elem, (char *) tests, len * sizeof (rtunion));
- for (j = i; j < XVECLEN (newexp, 0); j++)
- XVECEXP (newexp, 0, j) = XVECEXP (exp, 0, j + 2);
+ /* See if default value needs simplification. */
+ if (GET_CODE (defval) == COND)
+ new_defval = simplify_cond (defval, insn_code, insn_index);
- XEXP (newexp, 1) = XEXP (exp, 1);
- break;
- }
+ /* Simplify the subexpressions, and see what tests we can get rid of. */
- else if (newtest != XVECEXP (exp, 0, i))
- {
- newexp = rtx_alloc (COND);
- XVEC (newexp, 0) = rtvec_alloc (XVECLEN (exp, 0));
- for (j = 0; j < XVECLEN (exp, 0); j++)
- XVECEXP (newexp, 0, j) = XVECEXP (exp, 0, j);
- XEXP (newexp, 1) = XEXP (exp, 1);
+ for (i = 0; i < len; i += 2)
+ {
+ rtx newtest, newval;
- XVECEXP (newexp, 0, i) = newtest;
- break;
- }
+ /* Simplify this test. */
+ newtest = SIMPLIFY_TEST_EXP (tests[i].rtx, insn_code, insn_index);
+ tests[i].rtx = newtest;
+ newval = tests[i + 1].rtx;
/* See if this value may need simplification. */
- if (GET_CODE (XVECEXP (exp, 0, i + 1)) == COND)
- {
- value = simplify_cond (XVECEXP (exp, 0, i + 1),
- insn_code, insn_index);
- if (value != XVECEXP (exp, 0, i + 1))
- {
- newexp = rtx_alloc (COND);
- XVEC (newexp, 0) = rtvec_alloc (XVECLEN (exp, 0));
- for (j = 0; j < XVECLEN (exp, 0); j++)
- XVECEXP (newexp, 0, j) = XVECEXP (exp, 0, j);
- XEXP (newexp, 1) = XEXP (exp, 1);
+ if (GET_CODE (newval) == COND)
+ newval = simplify_cond (newval, insn_code, insn_index);
- XVECEXP (newexp, 0, i + 1) = value;
- break;
- }
+ /* Look for ways to delete or combine this test. */
+ if (newtest == true_rtx)
+ {
+ /* If test is true, make this value the default
+ and discard this + any following tests. */
+ len = i;
+ defval = tests[i + 1].rtx;
+ new_defval = newval;
}
- /* If this is the last condition in a COND and our value is the same
- as the default value, our test isn't needed. */
- if (i == XVECLEN (exp, 0) - 2
- && rtx_equal_p (XVECEXP (exp, 0, i + 1), XEXP (exp, 1)))
+ else if (newtest == false_rtx)
{
- newexp = rtx_alloc (COND);
- XVEC (newexp, 0) = rtvec_alloc (XVECLEN (exp, 0) - 2);
- for (j = 0; j < i; j++)
- XVECEXP (newexp, 0, j) = XVECEXP (exp, 0, j);
- XEXP (newexp, 1) = XEXP (exp, 1);
- break;
+ /* If test is false, discard it and its value. */
+ for (j = i; j < len - 2; j++)
+ tests[j].rtx = tests[j + 2].rtx;
+ len -= 2;
}
- /* If this value and the value for the next test are the same, merge the
- tests. */
- else if (i != XVECLEN (exp, 0) - 2
- && rtx_equal_p (XVECEXP (exp, 0, i + 1),
- XVECEXP (exp, 0, i + 3)))
+ else if (i > 0 && attr_equal_p (newval, tests[i - 1].rtx))
{
- newexp = rtx_alloc (COND);
- XVEC (newexp, 0) = rtvec_alloc (XVECLEN (exp, 0) - 2);
- for (j = 0; j < i; j++)
- XVECEXP (newexp, 0, j) = XVECEXP (exp, 0, j);
+ /* If this value and the value for the prev test are the same,
+ merge the tests. */
- XVECEXP (newexp, 0, j)
- = insert_right_side (IOR, XVECEXP (exp, 0, i),
- XVECEXP (exp, 0, i + 2),
+ tests[i - 2].rtx
+ = insert_right_side (IOR, tests[i - 2].rtx, newtest,
insn_code, insn_index);
- XVECEXP (newexp, 0, j + 1) = XVECEXP (exp, 0, i + 1);
-
- for (j = i + 2; j < XVECLEN (newexp, 0); j++)
- XVECEXP (newexp, 0, j) = XVECEXP (exp, 0, j + 2);
- XEXP (newexp, 1) = XEXP (exp, 1);
- break;
+ /* Delete this test/value. */
+ for (j = i; j < len - 2; j++)
+ tests[j].rtx = tests[j + 2].rtx;
+ len -= 2;
}
+
+ else
+ tests[i + 1].rtx = newval;
}
- /* See if default value needs simplification. */
- if (GET_CODE (XEXP (exp, 1)) == COND)
- {
- value = simplify_cond (XEXP (exp, 1), insn_code, insn_index);
- if (value != XEXP (exp, 1))
+ /* 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].rtx, new_defval))
+ len -= 2;
+
+ /* See if we changed anything. */
+ if (len != XVECLEN (exp, 0) || new_defval != XEXP (exp, 1))
+ allsame = 0;
+ else
+ for (i = 0; i < len; i++)
+ if (! attr_equal_p (tests[i].rtx, XVECEXP (exp, 0, i)))
{
- newexp = rtx_alloc (COND);
- XVEC (newexp, 0) = rtvec_alloc (XVECLEN (exp, 0));
- for (j = 0; j < XVECLEN (exp, 0); j++)
- XVECEXP (newexp, 0, j) = XVECEXP (exp, 0, j);
- XEXP (newexp, 1) = value;
+ allsame = 0;
+ break;
}
+
+ if (len == 0)
+ {
+ obstack_free (rtl_obstack, first_spacer);
+ if (GET_CODE (defval) == COND)
+ return simplify_cond (defval, insn_code, insn_index);
+ return defval;
+ }
+ else if (allsame)
+ {
+ obstack_free (rtl_obstack, first_spacer);
+ return exp;
}
-
- if (exp == newexp)
- return exp;
- else if (XVECLEN (newexp, 0) == 1)
- return XVECEXP (newexp, 0, 0);
else
- return simplify_cond (newexp, insn_code, insn_index);
+ {
+ rtx newexp = rtx_alloc (COND);
+
+ XVEC (newexp, 0) = rtvec_alloc (len);
+ bcopy ((char *) tests, (char *) XVEC (newexp, 0)->elem,
+ len * sizeof (rtunion));
+ XEXP (newexp, 1) = new_defval;
+ return newexp;
+ }
}
\f
/* Remove an insn entry from an attribute value. */
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;
{
rtx newexp;
+ /* Avoid consing in some special cases. */
+ if (code == AND && term == true_rtx)
+ return exp;
+ if (code == AND && term == false_rtx)
+ return false_rtx;
+ if (code == AND && exp == true_rtx)
+ return term;
+ if (code == AND && exp == false_rtx)
+ return false_rtx;
+ if (code == IOR && term == true_rtx)
+ return true_rtx;
+ if (code == IOR && term == false_rtx)
+ return exp;
+ if (code == IOR && exp == true_rtx)
+ return true_rtx;
+ if (code == IOR && exp == false_rtx)
+ return term;
+ if (attr_equal_p (exp, term))
+ return exp;
+
if (GET_CODE (term) == code)
{
exp = insert_right_side (code, exp, XEXP (term, 0),
if (GET_CODE (exp) == code)
{
- /* Make a copy of this expression and call recursively. */
- newexp = rtx_alloc (code);
- XEXP (newexp, 0) = XEXP (exp, 0);
- XEXP (newexp, 1) = insert_right_side (code, XEXP (exp, 1),
- term, insn_code, insn_index);
+ rtx new = insert_right_side (code, XEXP (exp, 1),
+ term, insn_code, insn_index);
+ if (new != XEXP (exp, 1))
+ /* Make a copy of this expression and call recursively. */
+ newexp = attr_rtx (code, XEXP (exp, 0), new);
+ else
+ newexp = exp;
}
else
{
/* Insert the new term. */
- newexp = rtx_alloc (code);
- XEXP (newexp, 0) = exp;
- XEXP (newexp, 1) = term;
- }
+ newexp = attr_rtx (code, exp, term);
+ }
return SIMPLIFY_TEST_EXP (newexp, 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++)
;
- alternative = (char *) xmalloc (3);
- sprintf (alternative, "%d", i);
-
- newexp = rtx_alloc (EQ_ATTR);
- XSTR (newexp, 0) = alternative_name;
- XSTR (newexp, 1) = alternative;
+ newexp = attr_rtx (EQ_ATTR, alternative_name, attr_numeral (i));
RTX_UNCHANGING_P (newexp) = 1;
return newexp;
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.
+
+ 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)
{
- right = insert_right_side (AND, andexp,
- XVECEXP (value, 0, i),
+ 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);
/* Add this condition into the AND expression. */
- newexp = rtx_alloc (NOT);
- XEXP (newexp, 0) = XVECEXP (value, 0, i);
+ newexp = attr_rtx (NOT, this);
andexp = insert_right_side (AND, andexp, newexp,
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);
}
else
abort ();
- /* If uses an address, must return original expression. */
+ /* If uses an address, must return original expression. But set the
+ RTX_UNCHANGING_P bit so we don't try to simplify it again. */
address_used = 0;
walk_attr_value (newexp);
if (address_used)
- return exp;
+ {
+ /* This had `&& current_alternative_string', which seems to be wrong. */
+ if (! RTX_UNCHANGING_P (exp))
+ return copy_rtx_unchanging (exp);
+ return exp;
+ }
else
return newexp;
}
right = simplify_and_tree (XEXP (exp, 1), pterm, insn_code, insn_index);
if (left != XEXP (exp, 0) || right != XEXP (exp, 1))
{
- newexp = rtx_alloc (GET_CODE (exp));
- XEXP (newexp, 0) = left;
- XEXP (newexp, 1) = right;
+ newexp = attr_rtx (GET_CODE (exp), left, right);
exp = SIMPLIFY_TEST_EXP (newexp, insn_code, insn_index);
}
if (left != XEXP (exp, 0) || right != XEXP (exp, 1))
{
- newexp = rtx_alloc (GET_CODE (exp));
- XEXP (newexp, 0) = left;
- XEXP (newexp, 1) = right;
+ newexp = attr_rtx (GET_CODE (exp), left, right);
exp = SIMPLIFY_TEST_EXP (newexp, insn_code, insn_index);
}
else if (GET_CODE (exp) == NOT && GET_CODE (*pterm) == NOT)
{
- if (rtx_equal_p (XEXP (exp, 0), XEXP (*pterm, 0)))
+ if (attr_equal_p (XEXP (exp, 0), XEXP (*pterm, 0)))
return true_rtx;
}
else if (GET_CODE (exp) == NOT)
{
- if (rtx_equal_p (XEXP (exp, 0), *pterm))
+ if (attr_equal_p (XEXP (exp, 0), *pterm))
return false_rtx;
}
else if (GET_CODE (*pterm) == NOT)
{
- if (rtx_equal_p (XEXP (*pterm, 0), exp))
+ if (attr_equal_p (XEXP (*pterm, 0), exp))
return false_rtx;
}
- else if (rtx_equal_p (exp, *pterm))
+ else if (attr_equal_p (exp, *pterm))
return true_rtx;
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)
right = simplify_or_tree (XEXP (exp, 1), pterm, insn_code, insn_index);
if (left != XEXP (exp, 0) || right != XEXP (exp, 1))
{
- newexp = rtx_alloc (GET_CODE (exp));
- XEXP (newexp, 0) = left;
- XEXP (newexp, 1) = right;
+ newexp = attr_rtx (GET_CODE (exp), left, right);
exp = SIMPLIFY_TEST_EXP (newexp, insn_code, insn_index);
}
if (left != XEXP (exp, 0) || right != XEXP (exp, 1))
{
- newexp = rtx_alloc (GET_CODE (exp));
- XEXP (newexp, 0) = left;
- XEXP (newexp, 1) = right;
+ newexp = attr_rtx (GET_CODE (exp), left, right);
exp = SIMPLIFY_TEST_EXP (newexp, insn_code, insn_index);
}
}
- if (rtx_equal_p (exp, *pterm))
+ if (attr_equal_p (exp, *pterm))
return false_rtx;
- else if (GET_CODE (exp) == NOT && rtx_equal_p (XEXP (exp, 0), *pterm))
+ else if (GET_CODE (exp) == NOT && attr_equal_p (XEXP (exp, 0), *pterm))
return true_rtx;
- else if (GET_CODE (*pterm) == NOT && rtx_equal_p (XEXP (*pterm, 0), exp))
+ else if (GET_CODE (*pterm) == NOT && attr_equal_p (XEXP (*pterm, 0), exp))
return true_rtx;
else if (GET_CODE (*pterm) == EQ_ATTR && GET_CODE (exp) == NOT
struct insn_ent *ie;
int i;
rtx newexp = exp;
+ char *spacer = (char *) obstack_finish (rtl_obstack);
+
+ /* Don't re-simplify something we already simplified. */
+ 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
- yield simplications. */
+ yield simplifications. */
if ((GET_CODE (left) == IOR || GET_CODE (right) == IOR)
&& compute_alternative_mask (left, IOR)
&& compute_alternative_mask (right, IOR))
right = tem;
}
- newexp = rtx_alloc (IOR);
- XEXP (newexp, 0) = rtx_alloc (AND);
- XEXP (newexp, 1) = rtx_alloc (AND);
- XEXP (XEXP (newexp, 0), 0) = XEXP (XEXP (newexp, 1), 0) = left;
- XEXP (XEXP (newexp, 0), 1) = XEXP (right, 0);
- XEXP (XEXP (newexp, 1), 1) = XEXP (right, 1);
+ newexp = attr_rtx (IOR,
+ attr_rtx (AND, left, XEXP (right, 0)),
+ attr_rtx (AND, left, XEXP (right, 1)));
return SIMPLIFY_TEST_EXP (newexp, insn_code, insn_index);
}
left = simplify_and_tree (left, &right, insn_code, insn_index);
if (left == false_rtx || right == false_rtx)
- return false_rtx;
+ {
+ obstack_free (rtl_obstack, spacer);
+ return false_rtx;
+ }
else if (left == true_rtx)
- return right;
+ {
+ return right;
+ }
else if (right == true_rtx)
- return left;
-
+ {
+ 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;
alternative and we have tested none of them! */
left = make_alternative_compare (i);
right = simplify_and_tree (exp, &left, insn_code, insn_index);
- newexp = rtx_alloc (AND);
- XEXP (newexp, 0) = left;
- XEXP (newexp, 1) = right;
+ newexp = attr_rtx (AND, left, right);
return SIMPLIFY_TEST_EXP (newexp, insn_code, insn_index);
}
if (left != XEXP (exp, 0) || right != XEXP (exp, 1))
{
- newexp = rtx_alloc (AND);
- XEXP (newexp, 0) = left;
- XEXP (newexp, 1) = right;
+ newexp = attr_rtx (AND, left, right);
return SIMPLIFY_TEST_EXP (newexp, insn_code, insn_index);
}
break;
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))
left = simplify_or_tree (left, &right, insn_code, insn_index);
if (right == true_rtx || left == true_rtx)
- return true_rtx;
+ {
+ obstack_free (rtl_obstack, spacer);
+ return true_rtx;
+ }
else if (left == false_rtx)
- return right;
+ {
+ return right;
+ }
else if (right == false_rtx)
- return left;
+ {
+ return left;
+ }
/* Test for simple cases where the distributive law is useful. I.e.,
convert (ior (and (x) (y))
*/
else if (GET_CODE (left) == AND && GET_CODE (right) == AND
- && rtx_equal_p (XEXP (left, 0), XEXP (right, 0)))
+ && attr_equal_p (XEXP (left, 0), XEXP (right, 0)))
{
- newexp = rtx_alloc (IOR);
- XEXP (newexp, 0) = XEXP (left, 1);
- XEXP (newexp, 1) = XEXP (right, 1);
+ newexp = attr_rtx (IOR, XEXP (left, 1), XEXP (right, 1));
left = XEXP (left, 0);
right = newexp;
- newexp = rtx_alloc (AND);
- XEXP (newexp, 0) = left;
- XEXP (newexp, 1) = right;
+ newexp = attr_rtx (AND, left, right);
return SIMPLIFY_TEST_EXP (newexp, insn_code, insn_index);
}
{
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;
alternative and we have tested none of them! */
left = make_alternative_compare (i);
right = simplify_and_tree (exp, &left, insn_code, insn_index);
- newexp = rtx_alloc (IOR);
- XEXP (newexp, 0) = rtx_alloc (NOT);
- XEXP (XEXP (newexp, 0), 0) = left;
- XEXP (newexp, 1) = right;
+ newexp = attr_rtx (IOR, attr_rtx (NOT, left), right);
return SIMPLIFY_TEST_EXP (newexp, insn_code, insn_index);
}
if (left != XEXP (exp, 0) || right != XEXP (exp, 1))
{
- newexp = rtx_alloc (IOR);
- XEXP (newexp, 0) = left;
- XEXP (newexp, 1) = right;
+ newexp = attr_rtx (IOR, left, right);
return SIMPLIFY_TEST_EXP (newexp, insn_code, insn_index);
}
break;
case NOT:
+ if (GET_CODE (XEXP (exp, 0)) == NOT)
+ {
+ 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);
if (left == false_rtx)
- return true_rtx;
+ {
+ obstack_free (rtl_obstack, spacer);
+ return true_rtx;
+ }
else if (left == true_rtx)
- return false_rtx;
+ {
+ obstack_free (rtl_obstack, spacer);
+ return false_rtx;
+ }
/* Try to apply De`Morgan's laws. */
else if (GET_CODE (left) == IOR)
{
- newexp = rtx_alloc (AND);
- XEXP (newexp, 0) = rtx_alloc (NOT);
- XEXP (XEXP (newexp, 0), 0) = XEXP (left, 0);
- XEXP (newexp, 1) = rtx_alloc (NOT);
- XEXP (XEXP (newexp, 1), 0) = XEXP (left, 1);
+ newexp = attr_rtx (AND,
+ attr_rtx (NOT, XEXP (left, 0)),
+ attr_rtx (NOT, XEXP (left, 1)));
newexp = SIMPLIFY_TEST_EXP (newexp, insn_code, insn_index);
}
else if (GET_CODE (left) == AND)
{
- newexp = rtx_alloc (IOR);
- XEXP (newexp, 0) = rtx_alloc (NOT);
- XEXP (XEXP (newexp, 0), 0) = XEXP (left, 0);
- XEXP (newexp, 1) = rtx_alloc (NOT);
- XEXP (XEXP (newexp, 1), 0) = XEXP (left, 1);
+ newexp = attr_rtx (IOR,
+ attr_rtx (NOT, XEXP (left, 0)),
+ attr_rtx (NOT, XEXP (left, 1)));
+
+ newexp = SIMPLIFY_TEST_EXP (newexp, insn_code, insn_index);
+ }
+ else if (left != XEXP (exp, 0))
+ {
+ newexp = attr_rtx (NOT, left);
+ }
+ 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. */
+ if (XSTR (exp, 0) != alternative_name
+ && (attr = find_attr (XSTR (exp, 0), 0)) != NULL)
+ for (av = attr->first_value; av; av = av->next)
+ for (ie = av->first_insn; ie; ie = ie->next)
+ if (ie->insn_code == insn_code)
+ return evaluate_eq_attr (exp, av->value, insn_code, insn_index);
+ }
+
+ /* 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 /* Seems wrong: && current_alternative_string. */
+ && ! RTX_UNCHANGING_P (newexp))
+ return copy_rtx_unchanging (newexp);
+
+ return newexp;
+}
+\f
+/* Optimize the attribute lists by seeing if we can determine conditional
+ values from the known values of other attributes. This will save subroutine
+ calls during the compilation. */
+
+static void
+optimize_attrs ()
+{
+ struct attr_desc *attr;
+ struct attr_value *av;
+ 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;
+
+ /* 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 *));
+
+ /* Offset the table address so we can index by -2 or -1. */
+ insn_code_values += 2;
+
+ /* Allocate the attr_value_list structures using xmalloc rather than
+ alloca, because using alloca can overflow the maximum permitted
+ stack limit on SPARC Lynx. */
+ iv = ivbuf = ((struct attr_value_list *)
+ xmalloc (num_insn_ents * sizeof (struct attr_value_list)));
+
+ for (i = 0; i < MAX_ATTRS_INDEX; i++)
+ for (attr = attrs[i]; attr; attr = attr->next)
+ for (av = attr->first_value; av; av = av->next)
+ for (ie = av->first_insn; ie; ie = ie->next)
+ {
+ iv->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;
- newexp = SIMPLIFY_TEST_EXP (newexp, insn_code, insn_index);
- }
- else if (left != XEXP (exp, 0))
- {
- newexp = rtx_alloc (NOT);
- XEXP (newexp, 0) = left;
- }
- break;
+ 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:
- /* 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. */
- if (XSTR (exp, 0) != alternative_name
- && (attr = find_attr (XSTR (exp, 0), 0)) != NULL)
- for (av = attr->first_value; av; av = av->next)
- for (ie = av->first_insn; ie; ie = ie->next)
- if (ie->insn_code == insn_code)
- return evaluate_eq_attr (exp, av->value, insn_code, insn_index);
+ case ATTR_FLAG:
+ return;
}
- /* 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) = 1;
+ /* Compare the elements. If any pair of corresponding elements
+ fail to match, return 0 for the whole things. */
- return newexp;
+ 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;
+ }
+ }
}
-\f
-/* Optimize the attribute lists by seeing if we can determine conditional
- values from the known values of other attributes. This will save subroutine
- calls during the compilation. */
-static void
-optimize_attrs ()
+/* 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;
{
- struct attr_desc *attr;
- struct attr_value *av;
- struct insn_ent *ie, *nextie;
- rtx newexp;
- int something_changed = 1;
+ 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. */
- /* Loop until nothing changes for one iteration. */
- while (something_changed)
+ fmt = GET_RTX_FORMAT (code);
+ for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
{
- 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)
- {
- nextie = ie->next;
- if (GET_CODE (av->value) != COND)
- continue;
+ if (total >= max)
+ return total;
- newexp = simplify_cond (av->value, ie->insn_code,
- ie->insn_index);
- if (newexp != av->value)
- {
- remove_insn_ent (av, ie);
- insert_insn_ent (get_attr_value (newexp, attr,
- ie->insn_code), ie);
- something_changed = 1;
- }
- }
+ 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->value = rtx_alloc (CONST_STRING);
- XSTR (av->value, 0) = p;
+ 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;
av->first_insn = NULL;
}
}
+ if (GET_CODE (XEXP (exp, 2)) == CONST)
+ {
+ attr->is_const = 1;
+ if (attr->is_numeric)
+ fatal ("Constant attributes may not take numeric values");
+ /* Get rid of the CONST node. It is allowed only at top-level. */
+ XEXP (exp, 2) = XEXP (XEXP (exp, 2), 0);
+ }
+
if (! strcmp (attr->name, "length") && ! attr->is_numeric)
fatal ("`length' attribute must take numeric values");
- /* Set up the default value. */
- check_attr_value (XEXP (exp, 2), attr);
+ /* 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);
}
\f
{
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 = rtx_alloc (IF_THEN_ELSE);
- XEXP (op->busyexp, 0) = orexp;
- XEXP (op->busyexp, 1) = make_numeric_value (XINT (def, 5));
- XEXP (op->busyexp, 2) = 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
switch (code)
{
case SYMBOL_REF:
- /* Since this is an arbitrary expression, it can look at anything. */
- must_extract = must_constrain = 1;
+ if (! RTX_UNCHANGING_P (exp))
+ /* Since this is an arbitrary expression, it can look at anything.
+ However, constant expressions do not depend on any particular
+ insn. */
+ must_extract = must_constrain = 1;
return;
case MATCH_OPERAND:
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_...'. */
if (attr->name[0] == '*')
printf ("%s (insn)\n", &attr->name[1]);
- else
+ else if (attr->is_const == 0)
printf ("get_attr_%s (insn)\n", attr->name);
+ else
+ {
+ printf ("get_attr_%s ()\n", attr->name);
+ printf ("{\n");
+
+ for (av = attr->first_value; av; av = av->next)
+ if (av->num_insns != 0)
+ write_attr_set (attr, 2, av->value, "return", ";",
+ true_rtx, av->first_insn->insn_code,
+ av->first_insn->insn_index);
+
+ printf ("}\n\n");
+ return;
+ }
printf (" rtx insn;\n");
printf ("{\n");
printf (" switch (recog_memoized (insn))\n");
testexp = eliminate_known_true (our_known_true,
XVECEXP (value, 0, i),
insn_code, insn_index);
- newexp = rtx_alloc (NOT);
- XEXP (newexp, 0) = testexp;
+ newexp = attr_rtx (NOT, testexp);
newexp = insert_right_side (AND, our_known_true, newexp,
insn_code, insn_index);
/* 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 *) xmalloc (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;
+ printf ("%d, ", unit->max_blockage);
- if (! using_case)
- continue;
+ if (unit->needs_range_function)
+ printf ("%s_unit_blockage_range, ", unit->name);
+ else
+ printf ("0, ");
- printf (" case %d:\n", i);
- sprintf (str, "*%s_case_%d", unit->name, i);
- attr = find_attr (str, 0);
- if (! attr) abort ();
+ if (unit->needs_blockage_function)
+ printf ("%s_unit_blockage", 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");
+ 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);
+ printf ("};\n\n");
+}
- write_attr_case (attr, common_av, 0,
- "return", ";", 8, unit->condexp);
- printf (" }\n\n");
- }
- }
+static void
+write_complex_function (unit, name, connection)
+ struct function_unit *unit;
+ char *name, *connection;
+{
+ struct attr_desc *case_attr, *attr;
+ struct attr_value *av, *common_av;
+ rtx value;
+ char *str;
+ int using_case;
+ int i;
- printf (" }\n}\n\n");
- }
+ 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");
- /* Now that all functions have been written, write the table describing
- the function units. The name is included for documenation purposes
- only. */
+ /* 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);
- 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);
- for (unit = units; unit; unit = unit->next)
+ 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. */
for (p = *pstr; *p != ',' && *p != '\0'; p++)
;
- out_str = (char *) xmalloc (p - *pstr + 1);
- for (p = out_str; **pstr != ',' && **pstr != '\0'; (*pstr)++)
- *p++ = **pstr;
+ out_str = attr_string (*pstr, p - *pstr);
+ *pstr = p;
- *p++ = '\0';
if (**pstr == ',')
(*pstr)++;
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)
- if (! strcmp (name, attr->name))
+ 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_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;
}
abort ();
attr->is_numeric = 1;
- attr->is_special = special;
+ attr->is_const = 0;
+ attr->is_special = (special & 1) != 0;
+ attr->negative_ok = (special & 2) != 0;
+ attr->unsigned_p = (special & 4) != 0;
attr->default_val = get_attr_value (value, attr, -2);
}
{
static rtx int_values[20];
rtx exp;
+ char *p;
if (n < 0)
abort ();
if (n < 20 && int_values[n])
return int_values[n];
- exp = rtx_alloc (CONST_STRING);
- XSTR (exp, 0) = (char *) xmalloc ((n < 1000 ? 4
- : HOST_BITS_PER_INT * 3 / 10 + 3));
- sprintf (XSTR (exp, 0), "%d", n);
+ p = attr_printf (MAX_DIGITS, "%d", n);
+ exp = attr_rtx (CONST_STRING, p);
if (n < 20)
int_values[n] = exp;
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;
return val;
}
+static rtx
+copy_rtx_unchanging (orig)
+ register rtx orig;
+{
+#if 0
+ register rtx copy;
+ register RTX_CODE code;
+#endif
+
+ if (RTX_UNCHANGING_P (orig) || MEM_IN_STRUCT_P (orig))
+ return orig;
+
+ MEM_IN_STRUCT_P (orig) = 1;
+ return orig;
+
+#if 0
+ code = GET_CODE (orig);
+ switch (code)
+ {
+ case CONST_INT:
+ case CONST_DOUBLE:
+ case SYMBOL_REF:
+ case CODE_LABEL:
+ return orig;
+ }
+
+ copy = rtx_alloc (code);
+ PUT_MODE (copy, GET_MODE (orig));
+ RTX_UNCHANGING_P (copy) = 1;
+
+ 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)
{
rtx desc;
FILE *infile;
- extern rtx read_rtx ();
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);
+ obstack_init (temp_obstack);
if (argc <= 1)
fatal ("No input file name.");
/* Set up true and false rtx's */
true_rtx = rtx_alloc (CONST_INT);
+ XWINT (true_rtx, 0) = 1;
false_rtx = rtx_alloc (CONST_INT);
- XINT (true_rtx, 0) = 1;
- 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;
+
+ alternative_name = attr_string ("alternative", strlen ("alternative"));
printf ("/* Generated automatically by the program `genattrtab'\n\
from the machine description file `md'. */\n\n");
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)
- {
- 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
