/* Generate code from machine description to compute values of attributes.
Copyright (C) 1991 Free Software Foundation, Inc.
Contributed by Richard Kenner (kenner@nyu.edu)
This file is part of GNU CC.
GNU CC is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
GNU CC is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
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. */
/* This program handles insn attributes and the DEFINE_DELAY and
DEFINE_FUNCTION_UNIT definitions.
It produces a series of functions named `get_attr_...', one for each insn
attribute. Each of these is given the rtx for an insn and returns a member
of the enum for the attribute.
These subroutines have the form of a `switch' on the INSN_CODE (via
`recog_memoized'). Each case either returns a constant attribute value
or a value that depends on tests on other attributes, the form of
operands, or some random C expression (encoded with a SYMBOL_REF
If the attribute `alternative', or a random C expression is present,
`constrain_operands' is called. If either of these cases of a reference to
an operand is found, `insn_extract' is called.
The special attribute `length' is also recognized. For this operand,
expressions involving the address of an operand or the current insn,
(address (pc)), are valid. In this case, an initial pass is made to
set all lengths that do not depend on address. Those that do are set to
the maximum length. Then each insn that depends on an address is checked
and possibly has its length changed. The process repeats until no further
changed are made. The resulting lengths are saved for use by
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
Internal attributes are defined to handle DEFINE_DELAY and
DEFINE_FUNCTION_UNIT. Special routines are output for these cases.
This program works by keeping a list of possible values for each attribute.
These include the basic attribute choices, default values for attribute, and
As the description file is read, the definition for each insn is saved in a
`struct insn_def'. When the file reading is complete, a `struct insn_ent'
is created for each insn and chained to the corresponding attribute value,
either that specified, or the default.
An optimization phase is then run. This simplifies expressions for each
insn. EQ_ATTR tests are resolved, whenever possible, to a test that
indicates when the attribute has the specified value for the insn. This
avoids recursive calls during compilation.
The strategy used when processing DEFINE_DELAY and DEFINE_FUNCTION_UNIT
definitions is to create arbitrarily complex expressions and have the
optimization simplify them.
Once optimization is complete, any required routines and definitions
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
`volatil' (MEM_VOLATILE_P): During simplify_by_exploding the value of an
EQ_ATTR rtx is true if !volatil and false if volatil. */
#include "insn-config.h" /* For REGISTER_CONSTRAINTS */
#include <sys/resource.h>
/* We must include obstack.h after <sys/time.h>, to avoid lossage with
/usr/include/sys/stdtypes.h on Sun OS 4.x. */
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;
/* 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
encountered, we store all the relevant information into a
`struct insn_def'. This is done to allow attribute definitions to occur
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'. */
/* Once everything has been read in, we store in each attribute value a list
of insn codes that have that value. Here is the structure used for the
int insn_code
; /* Instruction number. */
int insn_index
; /* Index of definition in file */
struct insn_ent
*next
; /* Next in chain. */
/* Each value of an attribute (either constant or computed) is assigned a
structure which is used as the listhead of the insns that have that
rtx value
; /* Value of attribute. */
struct attr_value
*next
; /* Next attribute value in chain. */
struct insn_ent
*first_insn
; /* First insn with this value. */
int num_insns
; /* Number of insns with this value. */
int has_asm_insn
; /* True if this value used for `asm' insns */
/* Structure for each 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
/* Structure for each DEFINE_DELAY. */
rtx def
; /* DEFINE_DELAY expression. */
struct delay_desc
*next
; /* Next DEFINE_DELAY. */
int num
; /* Number of DEFINE_DELAY, starting at 1. */
/* Record information about each DEFINE_FUNCTION_UNIT. */
rtx condexp
; /* Expression TRUE for applicable insn. */
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. */
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
char *name
; /* Function unit name. */
struct function_unit
*next
; /* Next function unit. */
int num
; /* Ordinal of this unit type. */
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. */
int num_opclasses
; /* Number of different operation types. */
struct function_unit_op
*ops
; /* Pointer to first operation type. */
int needs_conflict_function
; /* Nonzero if a conflict function required. */
int needs_blockage_function
; /* Nonzero if a blockage function required. */
int needs_range_function
; /* Nonzero if a blockage range function required. */
rtx default_cost
; /* Conflict cost, if constant. */
struct range issue_delay
; /* Range of issue delay values. */
int max_blockage
; /* Maximum time an insn blocks the unit. */
/* Listheads of above structures. */
/* 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
;
static int insn_code_number
;
static int insn_index_number
;
static int got_define_asm_attributes
;
static int must_constrain
;
static int have_annul_true
, have_annul_false
;
/* Used as operand to `operate_exp': */
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
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
;
/* Simplify an expression. Only call the routine if there is something to
#define SIMPLIFY_TEST_EXP(EXP,INSN_CODE,INSN_INDEX) \
(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 \
/* 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 char *attr_printf ();
static char *attr_string ();
static rtx
check_attr_test ();
static rtx
check_attr_value ();
static rtx
convert_set_attr_alternative ();
static rtx
convert_set_attr ();
static void check_defs ();
static rtx
convert_const_symbol_ref ();
static rtx
make_canonical ();
static struct attr_value
*get_attr_value ();
static rtx
copy_rtx_unchanging ();
static rtx
copy_boolean ();
static void expand_delays ();
static rtx
operate_exp ();
static void expand_units ();
static rtx
simplify_knowing ();
static rtx
encode_units_mask ();
static void fill_attr ();
static rtx
substitute_address ();
static void make_length_attrs ();
static rtx
identity_fn ();
static rtx
simplify_cond ();
static rtx
simplify_by_alternatives ();
static rtx
simplify_by_exploding ();
static int find_and_mark_used_attributes ();
static void unmark_used_attributes ();
static int add_values_to_cover ();
static int increment_current_value ();
static rtx
test_for_current_value ();
static rtx
simplify_with_current_value ();
static rtx
simplify_with_current_value_aux ();
static void remove_insn_ent ();
static void insert_insn_ent ();
static rtx
insert_right_side ();
static rtx
make_alternative_compare ();
static int compute_alternative_mask ();
static rtx
evaluate_eq_attr ();
static rtx
simplify_and_tree ();
static rtx
simplify_or_tree ();
static rtx
simplify_test_exp ();
static void optimize_attrs ();
static int count_alternatives ();
static int compares_alternatives_p ();
static int contained_in_p ();
static void gen_delay ();
static void write_test_expr ();
static int max_attr_value ();
static void walk_attr_value ();
static void write_attr_get ();
static rtx
eliminate_known_true ();
static void write_attr_set ();
static void write_attr_case ();
static void write_attr_value ();
static void write_attr_valueq ();
static void write_upcase ();
static void write_indent ();
static void write_eligible_delay ();
static void write_function_unit_info ();
static void write_complex_function ();
static int n_comma_elts ();
static char *next_comma_elt ();
static struct attr_desc
*find_attr ();
static void make_internal_attr ();
static struct attr_value
*find_most_used ();
static rtx
find_single_value ();
static rtx
make_numeric_value ();
static void extend_range ();
#define oballoc(size) obstack_alloc (hash_obstack, size)
/* 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
struct attr_hash
*next
; /* Next structure in the bucket. */
int hashcode
; /* Hash code of this rtx or string. */
char *str
; /* The string (negative hash codes) */
rtx rtl
; /* or the RTL recorded here. */
/* 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
#define RTL_HASH_SIZE 4093
struct attr_hash
*attr_hash_table
[RTL_HASH_SIZE
];
/* Here is how primitive or already-shared RTL's hash
#define RTL_HASH(RTL) ((HOST_WIDE_INT) (RTL) & 0777777)
/* Add an entry to the hash table for RTL with hash code HASHCODE. */
attr_hash_add_rtx (hashcode
, rtl
)
register struct attr_hash
*h
;
h
= (struct attr_hash
*) obstack_alloc (hash_obstack
,
sizeof (struct attr_hash
));
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. */
attr_hash_add_string (hashcode
, str
)
register struct attr_hash
*h
;
h
= (struct attr_hash
*) obstack_alloc (hash_obstack
,
sizeof (struct attr_hash
));
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]) */
register int i
; /* Array indices... */
register char *fmt
; /* Current rtx's format... */
register rtx rt_val
; /* RTX to return to caller... */
register struct attr_hash
*h
;
struct obstack
*old_obstack
= rtl_obstack
;
code
= va_arg (p
, enum rtx_code
);
/* 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
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
);
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
)
rtl_obstack
= hash_obstack
;
rt_val
= rtx_alloc (code
);
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
);
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
)
rtl_obstack
= hash_obstack
;
rt_val
= rtx_alloc (code
);
else if (GET_RTX_LENGTH (code
) == 1
&& GET_RTX_FORMAT (code
)[0] == 's')
char * arg0
= va_arg (p
, char *);
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
)
rtl_obstack
= hash_obstack
;
rt_val
= rtx_alloc (code
);
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
)
rtl_obstack
= hash_obstack
;
rt_val
= rtx_alloc (code
);
else if (code
== CONST_INT
)
HOST_WIDE_INT arg0
= va_arg (p
, HOST_WIDE_INT
);
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
++)
case '0': /* Unused field. */
case 'i': /* An integer? */
XINT (rt_val
, i
) = va_arg (p
, int);
case 'w': /* A wide integer? */
XWINT (rt_val
, i
) = va_arg (p
, HOST_WIDE_INT
);
case 's': /* A string? */
XSTR (rt_val
, i
) = va_arg (p
, char *);
case 'e': /* An expression? */
case 'u': /* An insn? Same except when printing. */
XEXP (rt_val
, i
) = va_arg (p
, rtx
);
case 'E': /* An RTX vector? */
XVEC (rt_val
, i
) = va_arg (p
, rtvec
);
rtl_obstack
= old_obstack
;
attr_hash_add_rtx (hashcode
, rt_val
);
RTX_INTEGRATED_P (rt_val
) = 1;
/* Create a new string printed with the printf line arguments into a space
rtx attr_printf (len, format, [arg1, ..., argn]) */
/* Print the string into a temporary location. */
str
= (char *) alloca (len
);
fmt
= va_arg (p
, char *);
return attr_string (str
, strlen (str
));
#else /* not HAVE_VPRINTF */
attr_printf (len
, fmt
, arg1
, arg2
, arg3
)
char *arg1
, *arg2
, *arg3
; /* also int */
/* 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 */
return attr_rtx (EQ_ATTR
, attr_string (name
, strlen (name
)),
attr_string (value
, strlen (value
)));
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. */
register struct attr_hash
*h
;
/* Compute the hash code. */
hashcode
= (len
+ 1) * 613 + (unsigned)str
[0];
for (i
= 1; i
<= len
; i
+= 2)
hashcode
= ((hashcode
* 613) + (unsigned)str
[i
]);
/* 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
);
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. */
return (x
== y
|| (! (RTX_INTEGRATED_P (x
) && RTX_INTEGRATED_P (y
))
/* Copy an attribute value expression,
descending to all depths, but not copying any
permanent hashed subexpressions. */
register char *format_ptr
;
/* No need to copy a permanent object. */
if (RTX_INTEGRATED_P (orig
))
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
++)
XEXP (copy
, i
) = XEXP (orig
, i
);
if (XEXP (orig
, i
) != NULL
)
XEXP (copy
, i
) = attr_copy_rtx (XEXP (orig
, i
));
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
));
XINT (copy
, i
) = XINT (orig
, i
);
XWINT (copy
, i
) = XWINT (orig
, i
);
XSTR (copy
, i
) = XSTR (orig
, i
);
/* 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.
Update the string address in EQ_ATTR expression to be the same used
in the attribute (or `alternative_name') to speed up subsequent
`find_attr' calls and eliminate most `strcmp' calls.
Return the new expression, if any. */
check_attr_test (exp
, is_const
)
/* Handle negation test. */
if (XSTR (exp
, 1)[0] == '!')
return check_attr_test (attr_rtx (NOT
,
else if (n_comma_elts (XSTR (exp
, 1)) == 1)
attr
= find_attr (XSTR (exp
, 0), 0);
if (! strcmp (XSTR (exp
, 0), "alternative"))
XSTR (exp
, 0) = alternative_name
;
/* This can't be simplified any further. */
RTX_UNCHANGING_P (exp
) = 1;
fatal ("Unknown attribute `%s' in EQ_ATTR", XEXP (exp
, 0));
if (is_const
&& ! attr
->is_const
)
fatal ("Constant expression uses insn attribute `%s' in EQ_ATTR",
/* 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. */
RTX_UNCHANGING_P (exp
) = 1;
for (p
= XSTR (exp
, 1); *p
; p
++)
if (*p
< '0' || *p
> '9')
fatal ("Attribute `%s' takes only numeric values",
for (av
= attr
->first_value
; av
; av
= av
->next
)
if (GET_CODE (av
->value
) == CONST_STRING
&& ! strcmp (XSTR (exp
, 1), XSTR (av
->value
, 0)))
fatal ("Unknown value `%s' for `%s' attribute",
XEXP (exp
, 1), XEXP (exp
, 0));
/* Make an IOR tree of the possible values. */
name_ptr
= XSTR (exp
, 1);
while ((p
= next_comma_elt (&name_ptr
)) != NULL
)
newexp
= attr_eq (XSTR (exp
, 0), p
);
orexp
= insert_right_side (IOR
, orexp
, newexp
, -2);
return check_attr_test (orexp
, is_const
);
/* Either TRUE or FALSE. */
XEXP (exp
, 0) = check_attr_test (XEXP (exp
, 0), is_const
);
XEXP (exp
, 1) = check_attr_test (XEXP (exp
, 1), is_const
);
XEXP (exp
, 0) = check_attr_test (XEXP (exp
, 0), 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;
case LE
: case LT
: case GT
: case GE
:
case LEU
: case LTU
: case GTU
: case GEU
:
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;
/* These cases are valid for constant attributes, but can't be
exp
= attr_rtx (SYMBOL_REF
, XSTR (exp
, 0));
RTX_UNCHANGING_P (exp
) = 1;
fatal ("RTL operator \"%s\" not valid in attribute test",
GET_RTX_NAME (GET_CODE (exp
)));
/* Given an expression, ensure that it is validly formed and that all named
attribute values are valid for the given attribute. Issue a fatal error
if not. If no attribute is specified, assume a numeric attribute.
Return a perhaps modified replacement expression for the value. */
check_attr_value (exp
, attr
)
if (attr
&& ! attr
->is_numeric
)
fatal ("CONST_INT not valid for non-numeric `%s' attribute",
fatal ("Negative numeric value specified for `%s' attribute",
if (! strcmp (XSTR (exp
, 0), "*"))
if (attr
== 0 || attr
->is_numeric
)
if (attr
&& attr
->negative_ok
&& *p
== '-')
if (*p
> '9' || *p
< '0')
fatal ("Non-numeric value for numeric `%s' attribute",
attr
? attr
->name
: "internal");
for (av
= attr
->first_value
; av
; av
= av
->next
)
if (GET_CODE (av
->value
) == CONST_STRING
&& ! strcmp (XSTR (av
->value
, 0), XSTR (exp
, 0)))
fatal ("Unknown value `%s' for `%s' attribute",
XSTR (exp
, 0), attr
? attr
->name
: "internal");
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
);
if (XVECLEN (exp
, 0) % 2 != 0)
fatal ("First operand of COND must have even length");
for (i
= 0; i
< XVECLEN (exp
, 0); i
+= 2)
XVECEXP (exp
, 0, i
) = check_attr_test (XVECEXP (exp
, 0, i
),
attr
? attr
->is_const
: 0);
= check_attr_value (XVECEXP (exp
, 0, i
+ 1), attr
);
XEXP (exp
, 1) = check_attr_value (XEXP (exp
, 1), attr
);
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... */
fatal ("Illegal operation `%s' for attribute value",
GET_RTX_NAME (GET_CODE (exp
)));
/* Given an SET_ATTR_ALTERNATIVE expression, convert to the canonical SET.
It becomes a COND with each test being (eq_attr "alternative "n") */
convert_set_attr_alternative (exp
, num_alt
, insn_code
, insn_index
)
int insn_code
, insn_index
;
if (XVECLEN (exp
, 1) != num_alt
)
fatal ("Bad number of entries in SET_ATTR_ALTERNATIVE for insn %d",
/* Make a COND with all tests but the last. Select the last value via the
condexp
= rtx_alloc (COND
);
XVEC (condexp
, 0) = rtvec_alloc ((num_alt
- 1) * 2);
for (i
= 0; i
< num_alt
- 1; i
++)
XVECEXP (condexp
, 0, 2 * i
) = attr_eq (alternative_name
, p
);
/* 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) = p
;
XVECEXP (condexp
, 0, 2 * i
+ 1) = XVECEXP (exp
, 1, i
);
XEXP (condexp
, 1) = XVECEXP (exp
, 1, i
);
return attr_rtx (SET
, attr_rtx (ATTR
, XSTR (exp
, 0)), condexp
);
/* Given a SET_ATTR, convert to the appropriate SET. If a comma-separated
list of values is given, convert to SET_ATTR_ALTERNATIVE first. */
convert_set_attr (exp
, num_alt
, insn_code
, insn_index
)
int insn_code
, insn_index
;
/* See how many alternative specified. */
n
= n_comma_elts (XSTR (exp
, 1));
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);
XVEC (newexp
, 1) = rtvec_alloc (n
);
/* Process each comma-separated name. */
name_ptr
= XSTR (exp
, 1);
while ((p
= next_comma_elt (&name_ptr
)) != NULL
)
XVECEXP (newexp
, 1, n
++) = attr_rtx (CONST_STRING
, p
);
return convert_set_attr_alternative (newexp
, num_alt
, insn_code
, insn_index
);
/* Scan all definitions, checking for validity. Also, convert any SET_ATTR
and SET_ATTR_ALTERNATIVE expressions to the corresponding SET
for (id
= defs
; id
; id
= id
->next
)
if (XVEC (id
->def
, id
->vec_idx
) == NULL
)
for (i
= 0; i
< XVECLEN (id
->def
, id
->vec_idx
); i
++)
value
= XVECEXP (id
->def
, id
->vec_idx
, i
);
switch (GET_CODE (value
))
if (GET_CODE (XEXP (value
, 0)) != ATTR
)
fatal ("Bad attribute set in pattern %d", id
->insn_index
);
case SET_ATTR_ALTERNATIVE
:
value
= convert_set_attr_alternative (value
,
value
= convert_set_attr (value
, id
->num_alternatives
,
id
->insn_code
, id
->insn_index
);
fatal ("Invalid attribute code `%s' for pattern %d",
GET_RTX_NAME (GET_CODE (value
)), id
->insn_index
);
if ((attr
= find_attr (XSTR (XEXP (value
, 0), 0), 0)) == NULL
)
fatal ("Unknown attribute `%s' for pattern number %d",
XSTR (XEXP (value
, 0), 0), id
->insn_index
);
XVECEXP (id
->def
, id
->vec_idx
, i
) = value
;
XEXP (value
, 1) = check_attr_value (XEXP (value
, 1), attr
);
/* Given a constant SYMBOL_REF expression, convert to a COND that
explicitly tests each enumerated value. */
convert_const_symbol_ref (exp
, attr
)
for (av
= attr
->first_value
; av
; av
= av
->next
)
/* 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);
XEXP (condexp
, 1) = av
->value
;
for (i
= num_alt
- 2; av
= av
->next
, i
>= 0; i
--)
string
= p
= (char *) oballoc (2
+ strlen (XSTR (av
->value
, 0)));
strcat (p
, XSTR (av
->value
, 0));
if (*p
>= 'a' && *p
<= 'z')
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
;
/* 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
make_canonical (attr
, exp
)
exp
= make_numeric_value (INTVAL (exp
));
if (! strcmp (XSTR (exp
, 0), "*"))
if (attr
== 0 || attr
->default_val
== 0)
fatal ("(attr_value \"*\") used in invalid context.");
exp
= attr
->default_val
->value
;
if (!attr
->is_const
|| RTX_UNCHANGING_P (exp
))
/* 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
newexp
= rtx_alloc (COND
);
XVEC (newexp
, 0) = rtvec_alloc (2);
XVECEXP (newexp
, 0, 0) = XEXP (exp
, 0);
XVECEXP (newexp
, 0, 1) = XEXP (exp
, 1);
XEXP (newexp
, 1) = XEXP (exp
, 2);
/* Fall through to COND case since this is now a COND. */
/* First, check for degenerate COND. */
if (XVECLEN (exp
, 0) == 0)
return make_canonical (attr
, XEXP (exp
, 1));
defval
= XEXP (exp
, 1) = make_canonical (attr
, XEXP (exp
, 1));
for (i
= 0; i
< XVECLEN (exp
, 0); i
+= 2)
XVECEXP (exp
, 0, i
) = copy_boolean (XVECEXP (exp
, 0, i
));
= make_canonical (attr
, XVECEXP (exp
, 0, i
+ 1));
if (! rtx_equal_p (XVECEXP (exp
, 0, i
+ 1), defval
))
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)));
/* Given a value and an attribute description, return a `struct attr_value *'
that represents that value. This is either an existing structure, if the
value has been previously encountered, or a newly-created structure.
`insn_code' is the code of an insn whose attribute has the specified
value (-2 if not processing an insn). We ensure that all insns for
a given value have the same number of alternatives if the value checks
static struct attr_value
*
get_attr_value (value
, attr
, insn_code
)
value
= make_canonical (attr
, value
);
if (compares_alternatives_p (value
))
if (insn_code
< 0 || insn_alternatives
== NULL
)
fatal ("(eq_attr \"alternatives\" ...) used in non-insn context");
num_alt
= insn_alternatives
[insn_code
];
for (av
= attr
->first_value
; av
; av
= av
->next
)
if (rtx_equal_p (value
, av
->value
)
&& (num_alt
== 0 || av
->first_insn
== NULL
|| insn_alternatives
[av
->first_insn
->insn_code
]))
av
= (struct attr_value
*) oballoc (sizeof (struct attr_value
));
av
->next
= attr
->first_value
;
/* After all DEFINE_DELAYs have been read in, create internal attributes
to generate the required routines.
First, we compute the number of delay slots for each insn (as a COND of
each of the test expressions in DEFINE_DELAYs). Then, if more than one
delay type is specified, we compute a similar function giving the
DEFINE_DELAY ordinal for each insn.
Finally, for each [DEFINE_DELAY, slot #] pair, we compute an attribute that
tells whether a given insn can be in that delay slot.
Normal attribute filling and optimization expands these to contain the
information needed to handle delay slots. */
struct delay_desc
*delay
;
/* First, generate data for `num_delay_slots' function. */
condexp
= rtx_alloc (COND
);
XVEC (condexp
, 0) = rtvec_alloc (num_delays
* 2);
XEXP (condexp
, 1) = make_numeric_value (0);
for (i
= 0, delay
= delays
; delay
; i
+= 2, delay
= delay
->next
)
XVECEXP (condexp
, 0, i
) = XEXP (delay
->def
, 0);
XVECEXP (condexp
, 0, i
+ 1)
= make_numeric_value (XVECLEN (delay
->def
, 1) / 3);
make_internal_attr ("*num_delay_slots", condexp
, 0);
/* If more than one delay type, do the same for computing the delay type. */
condexp
= rtx_alloc (COND
);
XVEC (condexp
, 0) = rtvec_alloc (num_delays
* 2);
XEXP (condexp
, 1) = make_numeric_value (0);
for (i
= 0, delay
= delays
; delay
; i
+= 2, delay
= delay
->next
)
XVECEXP (condexp
, 0, i
) = XEXP (delay
->def
, 0);
XVECEXP (condexp
, 0, i
+ 1) = make_numeric_value (delay
->num
);
make_internal_attr ("*delay_type", condexp
, 1);
/* 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)
condexp
= XVECEXP (delay
->def
, 1, i
);
if (condexp
== 0) condexp
= false_rtx
;
newexp
= attr_rtx (IF_THEN_ELSE
, condexp
,
make_numeric_value (1), make_numeric_value (0));
p
= attr_printf (sizeof ("*delay__") + MAX_DIGITS
*2, "*delay_%d_%d",
make_internal_attr (p
, newexp
, 1);
condexp
= XVECEXP (delay
->def
, 1, i
+ 1);
if (condexp
== 0) condexp
= false_rtx
;
newexp
= attr_rtx (IF_THEN_ELSE
, condexp
,
p
= attr_printf (sizeof ("*annul_true__") + MAX_DIGITS
*2,
"*annul_true_%d_%d", delay
->num
, i
/ 3);
make_internal_attr (p
, newexp
, 1);
condexp
= XVECEXP (delay
->def
, 1, i
+ 2);
if (condexp
== 0) condexp
= false_rtx
;
newexp
= attr_rtx (IF_THEN_ELSE
, condexp
,
p
= attr_printf (sizeof ("*annul_false__") + MAX_DIGITS
*2,
"*annul_false_%d_%d", delay
->num
, i
/ 3);
make_internal_attr (p
, newexp
, 1);
/* This function is given a left and right side expression and an operator.
Each side is a conditional expression, each alternative of which has a
numerical value. The function returns another conditional expression
which, for every possible set of condition values, returns a value that is
the operator applied to the values of the two sides.
Since this is called early, it must also support IF_THEN_ELSE. */
operate_exp (op
, left
, right
)
int left_value
, right_value
;
/* If left is a string, apply operator to it and the right side. */
if (GET_CODE (left
) == CONST_STRING
)
/* If right is also a string, just perform the operation. */
if (GET_CODE (right
) == CONST_STRING
)
left_value
= atoi (XSTR (left
, 0));
right_value
= atoi (XSTR (right
, 0));
i
= left_value
+ right_value
;
i
= left_value
- right_value
;
case POS_MINUS_OP
: /* The positive part of LEFT - RIGHT. */
if (left_value
> right_value
)
i
= left_value
- right_value
;
i
= left_value
| right_value
;
i
= left_value
== right_value
;
i
= (left_value
<< (HOST_BITS_PER_INT
/ 2)) | right_value
;
if (left_value
> right_value
)
if (left_value
< right_value
)
return make_numeric_value (i
);
else if (GET_CODE (right
) == IF_THEN_ELSE
)
/* Apply recursively to all values within. */
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 attr_rtx (IF_THEN_ELSE
, XEXP (right
, 0), newleft
, newright
);
else if (GET_CODE (right
) == COND
)
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),
/* If the resulting cond is trivial (all alternatives
give the same value), optimize it away. */
obstack_free (rtl_obstack
, newexp
);
return operate_exp (op
, left
, XEXP (right
, 1));
/* If the result is the same as the RIGHT operand,
if (rtx_equal_p (newexp
, right
))
obstack_free (rtl_obstack
, newexp
);
fatal ("Badly formed attribute value");
/* Otherwise, do recursion the other way. */
else if (GET_CODE (left
) == IF_THEN_ELSE
)
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 attr_rtx (IF_THEN_ELSE
, XEXP (left
, 0), newleft
, newright
);
else if (GET_CODE (left
) == COND
)
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),
/* If the cond is trivial (all alternatives give the same value),
obstack_free (rtl_obstack
, newexp
);
return operate_exp (op
, XEXP (left
, 1), right
);
/* If the result is the same as the LEFT operand,
if (rtx_equal_p (newexp
, left
))
obstack_free (rtl_obstack
, newexp
);
fatal ("Badly formed attribute value.");
/* Once all attributes and DEFINE_FUNCTION_UNITs have been read, we
construct a number of attributes.
The first produces a function `function_units_used' which is given an
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
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
Both of these produce quite complex expressions which are then set as the
default value of internal attributes. Normal attribute simplification
should produce reasonable expressions.
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_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).
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. */
struct function_unit
*unit
, **unit_num
;
struct function_unit_op
*op
, **op_array
, ***unit_ops
;
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
for (unit
= units
; unit
; unit
= unit
->next
)
rtx min_issue
= make_numeric_value (unit
->issue_delay
.min
);
unit
->condexp
= check_attr_test (unit
->condexp
, 0);
for (op
= unit
->ops
; op
; op
= op
->next
)
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
= simplify_knowing (issue_exp
, unit
->condexp
);
op
->issue_exp
= issue_exp
;
/* Make an attribute for use in the conflict function if needed. */
unit
->needs_conflict_function
= (unit
->issue_delay
.min
!= unit
->issue_delay
.max
);
if (unit
->needs_conflict_function
)
str
= attr_printf (strlen (unit
->name
) + sizeof ("*_cost_") + MAX_DIGITS
,
"*%s_cost_%d", unit
->name
, op
->num
);
make_internal_attr (str
, issue_exp
, 1);
/* Validate the condition. */
op
->condexp
= check_attr_test (op
->condexp
, 0);
/* 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);
/* Merge each function unit into the unit mask attributes. */
for (unit
= units
; unit
; unit
= unit
->next
)
XEXP (newexp
, 0) = unit
->condexp
;
XEXP (newexp
, 1) = make_numeric_value (1 << unit
->num
);
unitsmask
= operate_exp (OR_OP
, unitsmask
, newexp
);
/* Simplify the unit mask expression, encode it, and make an attribute
for the function_units_used function. */
unitsmask
= simplify_by_exploding (unitsmask
);
unitsmask
= encode_units_mask (unitsmask
);
make_internal_attr ("*function_units_used", unitsmask
, 2);
/* Create an array of ops for each unit. Add an extra unit for the
result_ready_cost function that has the ops of all other units. */
unit_ops
= (struct function_unit_op
***)
alloca ((num_units
+ 1) * sizeof (struct function_unit_op
**));
unit_num
= (struct function_unit
**)
alloca ((num_units
+ 1) * sizeof (struct function_unit
*));
unit_num
[num_units
] = unit
= (struct function_unit
*)
alloca (sizeof (struct function_unit
));
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
)
/* 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 (unit_ops
[unit
->num
], &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
++)
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_array
[j
] = op_array
[j
-1];
/* Determine how many distinct non-default ready cost values there
are. We use a default ready cost value of 1. */
for (i
= num
- 1; i
>= 0; i
--)
if (op_array
[i
]->ready
> value
)
value
= op_array
[i
]->ready
;
readycost
= make_numeric_value (1);
/* 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
++)
else if (op
->ready
== value
)
orexp
= insert_right_side (IOR
, orexp
, op
->condexp
, -2);
XVECEXP (readycost
, 0, nvalues
* 2) = orexp
;
XVECEXP (readycost
, 0, nvalues
* 2 + 1)
= make_numeric_value (value
);
XVECEXP (readycost
, 0, nvalues
* 2) = orexp
;
XVECEXP (readycost
, 0, nvalues
* 2 + 1) = make_numeric_value (value
);
rtx max_blockage
= 0, min_blockage
= 0;
/* Simplify the readycost expression by only considering insns
readycost
= simplify_knowing (readycost
, unit
->condexp
);
/* Determine the blockage cost the executing insn (E) given
the candidate insn (C). This is the maximum of the issue
delay, the pipeline delay, and the simultaneity constraint.
Each function_unit_op represents the characteristics of the
candidate insn, so in the expressions below, C is a known
term and E is an unknown term.
The issue delay function for C is op->issue_exp and is used to
write the `<name>_unit_conflict_cost' function. Symbolicly
this is "ISSUE-DELAY (E,C)".
The pipeline delay results form the FIFO constraint on the
function unit and is "READY-COST (E) + 1 - READY-COST (C)".
The simultaneity constraint is based on how long it takes to
fill the unit given the minimum issue delay. FILL-TIME is the
constant "MIN (ISSUE-DELAY (*,*)) * (SIMULTANEITY - 1)", and
the simultaneity constraint is "READY-COST (E) - FILL-TIME"
if SIMULTANEITY is non-zero and zero otherwise.
Thus, BLOCKAGE (E,C) when SIMULTANEITY is zero is
READY-COST (E) - (READY-COST (C) - 1))
READY-COST (E) - (READY-COST (C) - 1),
READY-COST (E) - FILL-TIME)
The `<name>_unit_blockage' function is computed by determining
this value for each candidate insn. As these values are
computed, we also compute the upper and lower bounds for
BLOCKAGE (E,*). These are combined to form the function
`<name>_unit_blockage_range'. Finally, the maximum blockage
cost, MAX (BLOCKAGE (*,*)), is computed. */
for (op
= unit
->ops
; op
; op
= op
->next
)
rtx blockage
= readycost
;
int delay
= op
->ready
- 1;
if (unit
->simultaneity
!= 0)
delay
= MIN (delay
, ((unit
->simultaneity
- 1)
* unit
->issue_delay
.min
));
blockage
= operate_exp (POS_MINUS_OP
, blockage
,
make_numeric_value (delay
));
blockage
= operate_exp (MAX_OP
, blockage
, op
->issue_exp
);
blockage
= simplify_knowing (blockage
, unit
->condexp
);
/* Add this op's contribution to MAX (BLOCKAGE (E,*)) and
max_blockage
= min_blockage
= blockage
;
= simplify_knowing (operate_exp (MAX_OP
, max_blockage
,
= simplify_knowing (operate_exp (MIN_OP
, min_blockage
,
/* 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
);
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
)
if (! unit
->needs_conflict_function
&& ! unit
->needs_blockage_function
)
caseexp
= rtx_alloc (COND
);
XVEC (caseexp
, 0) = rtvec_alloc ((unit
->num_opclasses
- 1) * 2);
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
if (op
->num
== unit
->num_opclasses
- 1)
XEXP (caseexp
, 1) = make_numeric_value (op
->num
);
XVECEXP (caseexp
, 0, op
->num
* 2) = op
->condexp
;
XVECEXP (caseexp
, 0, op
->num
* 2 + 1)
= make_numeric_value (op
->num
);
/* 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);
/* Simplify EXP given KNOWN_TRUE. */
simplify_knowing (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
);
/* 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. */
register enum rtx_code code
;
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
++)
return attr_rtx (CONST_STRING
, attr_printf (MAX_DIGITS
, "%d", j
));
/* 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
--)
for (j
= 0; j
< XVECLEN (x
, i
); j
++)
XVECEXP (x
, i
, j
) = encode_units_mask (XVECEXP (x
, i
, j
));
XEXP (x
, i
) = encode_units_mask (XEXP (x
, i
));
/* Once all attributes and insns have been read and checked, we construct for
each attribute value a list of all the insns that have that value for
/* Don't fill constant attributes. The value is independent of
for (id
= defs
; id
; id
= id
->next
)
/* If no value is specified for this insn for this attribute, use the
if (XVEC (id
->def
, id
->vec_idx
))
for (i
= 0; i
< XVECLEN (id
->def
, id
->vec_idx
); i
++)
if (! strcmp (XSTR (XEXP (XVECEXP (id
->def
, id
->vec_idx
, i
), 0), 0),
value
= XEXP (XVECEXP (id
->def
, id
->vec_idx
, i
), 1);
av
= get_attr_value (value
, attr
, id
->insn_code
);
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
);
/* Given an expression EXP, see if it is a COND or IF_THEN_ELSE that has a
test that checks relative positions of insns (uses MATCH_DUP or PC).
If so, replace it with what is obtained by passing the expression to
ADDRESS_FN. If not but it is a COND or IF_THEN_ELSE, call this routine
recursively on each value (including the default value). Otherwise,
return the value returned by NO_ADDRESS_FN applied to EXP. */
substitute_address (exp
, no_address_fn
, address_fn
)
if (GET_CODE (exp
) == COND
)
/* See if any tests use addresses. */
for (i
= 0; i
< XVECLEN (exp
, 0); i
+= 2)
walk_attr_value (XVECEXP (exp
, 0, i
));
return (*address_fn
) (exp
);
/* Make a new copy of this COND, replacing each element. */
newexp
= rtx_alloc (COND
);
XVEC (newexp
, 0) = rtvec_alloc (XVECLEN (exp
, 0));
for (i
= 0; i
< XVECLEN (exp
, 0); i
+= 2)
XVECEXP (newexp
, 0, i
) = XVECEXP (exp
, 0, i
);
XVECEXP (newexp
, 0, i
+ 1)
= substitute_address (XVECEXP (exp
, 0, i
+ 1),
no_address_fn
, address_fn
);
XEXP (newexp
, 1) = substitute_address (XEXP (exp
, 1),
no_address_fn
, address_fn
);
else if (GET_CODE (exp
) == IF_THEN_ELSE
)
walk_attr_value (XEXP (exp
, 0));
return (*address_fn
) (exp
);
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
);
/* Make new attributes from the `length' attribute. The following are made,
each corresponding to a function called from `shorten_branches' or
*insn_default_length This is the length of the insn to be returned
by `get_attr_length' before `shorten_branches'
has been called. In each case where the length
depends on relative addresses, the largest
possible is used. This routine is also used
to compute the initial size of the insn.
*insn_variable_length_p This returns 1 if the insn's length depends
on relative addresses, zero otherwise.
*insn_current_length This is only called when it is known that the
insn has a variable length and returns the
current length, based on relative addresses.
static char *new_names
[] = {"*insn_default_length",
"*insn_variable_length_p",
static rtx (*no_address_fn
[]) () = {identity_fn
, zero_fn
, zero_fn
};
static rtx (*address_fn
[]) () = {max_fn
, one_fn
, identity_fn
};
struct attr_desc
*length_attr
, *new_attr
;
struct attr_value
*av
, *new_av
;
struct insn_ent
*ie
, *new_ie
;
/* See if length attribute is defined. If so, it must be numeric. Make
it special so we don't output anything for it. */
length_attr
= find_attr ("length", 0);
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. */
for (i
= 0; i
< sizeof new_names
/ sizeof new_names
[0]; i
++)
make_internal_attr (new_names
[i
],
substitute_address (length_attr
->default_val
->value
,
no_address_fn
[i
], address_fn
[i
]),
new_attr
= find_attr (new_names
[i
], 0);
for (av
= length_attr
->first_value
; av
; av
= av
->next
)
for (ie
= av
->first_insn
; ie
; ie
= ie
->next
)
new_av
= get_attr_value (substitute_address (av
->value
,
new_attr
, ie
->insn_code
);
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
);
/* Utility functions called from above routine. */
return make_numeric_value (0);
return make_numeric_value (1);
return make_numeric_value (max_attr_value (exp
));
/* Take a COND expression and see if any of the conditions in it can be
simplified. If any are known true or known false for the particular insn
code, the COND can be further simplified.
Also call ourselves on any COND operations that are values of this COND.
We do not modify EXP; rather, we make and return a new rtx. */
simplify_cond (exp
, insn_code
, insn_index
)
int insn_code
, insn_index
;
/* 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);
rtx
*tests
= (rtx
*) alloca (len
* sizeof (rtx
));
/* This lets us free all storage allocated below, if appropriate. */
first_spacer
= (char *) obstack_finish (rtl_obstack
);
bcopy (&XVECEXP (exp
, 0, 0), tests
, len
* sizeof (rtx
));
/* See if default value needs simplification. */
if (GET_CODE (defval
) == COND
)
new_defval
= simplify_cond (defval
, insn_code
, insn_index
);
/* Simplify the subexpressions, and see what tests we can get rid of. */
for (i
= 0; i
< len
; i
+= 2)
/* Simplify this test. */
newtest
= SIMPLIFY_TEST_EXP (tests
[i
], insn_code
, insn_index
);
/* See if this value may need simplification. */
if (GET_CODE (newval
) == COND
)
newval
= simplify_cond (newval
, insn_code
, insn_index
);
/* Look for ways to delete or combine this test. */
/* If test is true, make this value the default
and discard this + any following tests. */
else if (newtest
== false_rtx
)
/* If test is false, discard it and its value. */
for (j
= i
; j
< len
- 2; j
++)
else if (i
> 0 && attr_equal_p (newval
, tests
[i
- 1]))
/* If this value and the value for the prev test are the same,
= insert_right_side (IOR
, tests
[i
- 2], newtest
,
/* Delete this test/value. */
for (j
= i
; j
< len
- 2; j
++)
/* If the last test in a COND has the same value
as the default value, that test isn't needed. */
while (len
> 0 && attr_equal_p (tests
[len
- 1], new_defval
))
/* See if we changed anything. */
if (len
!= XVECLEN (exp
, 0) || new_defval
!= XEXP (exp
, 1))
for (i
= 0; i
< len
; i
++)
if (! attr_equal_p (tests
[i
], XVECEXP (exp
, 0, i
)))
obstack_free (rtl_obstack
, first_spacer
);
if (GET_CODE (defval
) == COND
)
return simplify_cond (defval
, insn_code
, insn_index
);
obstack_free (rtl_obstack
, first_spacer
);
rtx newexp
= rtx_alloc (COND
);
XVEC (newexp
, 0) = rtvec_alloc (len
);
bcopy (tests
, &XVECEXP (newexp
, 0, 0), len
* sizeof (rtx
));
XEXP (newexp
, 1) = new_defval
;
/* Remove an insn entry from an attribute value. */
if (av
->first_insn
== ie
)
av
->first_insn
= ie
->next
;
for (previe
= av
->first_insn
; previe
->next
!= ie
; previe
= previe
->next
)
/* Insert an insn entry in an attribute value list. */
ie
->next
= av
->first_insn
;
/* This is a utility routine to take an expression that is a tree of either
AND or IOR expressions and insert a new term. The new term will be
inserted at the right side of the first node whose code does not match
the root. A new node will be created with the root's code. Its left
side will be the old right side and its right side will be the new
If the `term' is itself a tree, all its leaves will be inserted. */
insert_right_side (code
, exp
, term
, insn_code
, insn_index
)
int insn_code
, insn_index
;
/* Avoid consing in some special cases. */
if (code
== AND
&& term
== true_rtx
)
if (code
== AND
&& term
== false_rtx
)
if (code
== AND
&& exp
== true_rtx
)
if (code
== AND
&& exp
== false_rtx
)
if (code
== IOR
&& term
== true_rtx
)
if (code
== IOR
&& term
== false_rtx
)
if (code
== IOR
&& exp
== true_rtx
)
if (code
== IOR
&& exp
== false_rtx
)
if (attr_equal_p (exp
, term
))
if (GET_CODE (term
) == code
)
exp
= insert_right_side (code
, exp
, XEXP (term
, 0),
exp
= insert_right_side (code
, exp
, XEXP (term
, 1),
if (GET_CODE (exp
) == code
)
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);
/* Insert the new term. */
newexp
= attr_rtx (code
, exp
, term
);
return SIMPLIFY_TEST_EXP (newexp
, insn_code
, insn_index
);
/* If we have an expression which AND's a bunch of
(not (eq_attrq "alternative" "n"))
terms, we may have covered all or all but one of the possible alternatives.
If so, we can optimize. Similarly for IOR's of EQ_ATTR.
This routine is passed an expression and either AND or IOR. It returns a
bitmask indicating which alternatives are present.
??? What does "present" mean? */
compute_alternative_mask (exp
, code
)
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
)
string
= XSTR (XEXP (exp
, 0), 1);
else if (code
== IOR
&& GET_CODE (exp
) == EQ_ATTR
&& XSTR (exp
, 0) == alternative_name
)
return 1 << (string
[0] - '0');
return 1 << atoi (string
);
/* Given I, a single-bit mask, return RTX to compare the `alternative'
attribute with the value represented by that bit. */
make_alternative_compare (mask
)
for (i
= 0; (mask
& (1 << i
)) == 0; i
++)
newexp
= attr_rtx (EQ_ATTR
, alternative_name
, attr_numeral (i
));
RTX_UNCHANGING_P (newexp
) = 1;
/* If we are processing an (eq_attr "attr" "value") test, we find the value
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. */
/* ??? Kenner, document the meanings of the arguments!!! */
evaluate_eq_attr (exp
, value
, insn_code
, insn_index
)
int insn_code
, insn_index
;
if (GET_CODE (value
) == CONST_STRING
)
if (! strcmp (XSTR (value
, 0), XSTR (exp
, 1)))
else if (GET_CODE (value
) == COND
)
/* We construct an IOR of all the cases for which the requested attribute
value is present. Since we start with FALSE, if it is not present,
Each case is the AND of the NOT's of the previous conditions with the
current condition; in the default case the current condition is TRUE.
For each possible COND value, call ourselves recursively.
The extra TRUE and FALSE expressions will be eliminated by another
call to the simplification routine. */
if (current_alternative_string
)
clear_struct_flag (value
);
for (i
= 0; i
< XVECLEN (value
, 0); i
+= 2)
rtx
this = SIMPLIFY_TEST_EXP (XVECEXP (value
, 0, i
),
SIMPLIFY_ALTERNATIVE (this);
right
= insert_right_side (AND
, andexp
, this,
right
= insert_right_side (AND
, right
,
evaluate_eq_attr (exp
, XVECEXP (value
, 0, i
+ 1),
orexp
= insert_right_side (IOR
, orexp
, right
,
/* Add this condition into the AND expression. */
newexp
= attr_rtx (NOT
, this);
andexp
= insert_right_side (AND
, andexp
, newexp
,
/* Handle the default case. */
right
= insert_right_side (AND
, andexp
,
evaluate_eq_attr (exp
, XEXP (value
, 1),
newexp
= insert_right_side (IOR
, orexp
, right
, insn_code
, insn_index
);
/* If uses an address, must return original expression. But set the
RTX_UNCHANGING_P bit so we don't try to simplify it again. */
walk_attr_value (newexp
);
/* This had `&& current_alternative_string', which seems to be wrong. */
if (! RTX_UNCHANGING_P (exp
))
return copy_rtx_unchanging (exp
);
/* This routine is called when an AND of a term with a tree of AND's is
encountered. If the term or its complement is present in the tree, it
can be replaced with TRUE or FALSE, respectively.
Note that (eq_attr "att" "v1") and (eq_attr "att" "v2") cannot both
be true and hence are complementary.
There is one special case: If we see
(and (not (eq_attr "att" "v1"))
this can be replaced by (eq_attr "att" "v2"). To do this we need to
replace the term, not anything in the AND tree. So we pass a pointer to
simplify_and_tree (exp
, pterm
, insn_code
, insn_index
)
int insn_code
, insn_index
;
int left_eliminates_term
, right_eliminates_term
;
if (GET_CODE (exp
) == AND
)
left
= simplify_and_tree (XEXP (exp
, 0), pterm
, insn_code
, insn_index
);
right
= simplify_and_tree (XEXP (exp
, 1), pterm
, insn_code
, insn_index
);
if (left
!= XEXP (exp
, 0) || right
!= XEXP (exp
, 1))
newexp
= attr_rtx (GET_CODE (exp
), left
, right
);
exp
= SIMPLIFY_TEST_EXP (newexp
, insn_code
, insn_index
);
else if (GET_CODE (exp
) == IOR
)
/* For the IOR case, we do the same as above, except that we can
only eliminate `term' if both sides of the IOR would do so. */
left
= simplify_and_tree (XEXP (exp
, 0), &temp
, insn_code
, insn_index
);
left_eliminates_term
= (temp
== true_rtx
);
right
= simplify_and_tree (XEXP (exp
, 1), &temp
, insn_code
, insn_index
);
right_eliminates_term
= (temp
== true_rtx
);
if (left_eliminates_term
&& right_eliminates_term
)
if (left
!= XEXP (exp
, 0) || right
!= XEXP (exp
, 1))
newexp
= attr_rtx (GET_CODE (exp
), left
, right
);
exp
= SIMPLIFY_TEST_EXP (newexp
, insn_code
, insn_index
);
/* Check for simplifications. Do some extra checking here since this
routine is called so many times. */
else if (GET_CODE (exp
) == NOT
&& XEXP (exp
, 0) == *pterm
)
else if (GET_CODE (*pterm
) == NOT
&& exp
== XEXP (*pterm
, 0))
else if (GET_CODE (exp
) == EQ_ATTR
&& GET_CODE (*pterm
) == EQ_ATTR
)
if (XSTR (exp
, 0) != XSTR (*pterm
, 0))
if (! strcmp (XSTR (exp
, 1), XSTR (*pterm
, 1)))
else if (GET_CODE (*pterm
) == EQ_ATTR
&& GET_CODE (exp
) == NOT
&& GET_CODE (XEXP (exp
, 0)) == EQ_ATTR
)
if (XSTR (*pterm
, 0) != XSTR (XEXP (exp
, 0), 0))
if (! strcmp (XSTR (*pterm
, 1), XSTR (XEXP (exp
, 0), 1)))
else if (GET_CODE (exp
) == EQ_ATTR
&& GET_CODE (*pterm
) == NOT
&& GET_CODE (XEXP (*pterm
, 0)) == EQ_ATTR
)
if (XSTR (exp
, 0) != XSTR (XEXP (*pterm
, 0), 0))
if (! strcmp (XSTR (exp
, 1), XSTR (XEXP (*pterm
, 0), 1)))
else if (GET_CODE (exp
) == NOT
&& GET_CODE (*pterm
) == NOT
)
if (attr_equal_p (XEXP (exp
, 0), XEXP (*pterm
, 0)))
else if (GET_CODE (exp
) == NOT
)
if (attr_equal_p (XEXP (exp
, 0), *pterm
))
else if (GET_CODE (*pterm
) == NOT
)
if (attr_equal_p (XEXP (*pterm
, 0), exp
))
else if (attr_equal_p (exp
, *pterm
))
/* Similar to `simplify_and_tree', but for IOR trees. */
simplify_or_tree (exp
, pterm
, insn_code
, insn_index
)
int insn_code
, insn_index
;
int left_eliminates_term
, right_eliminates_term
;
if (GET_CODE (exp
) == IOR
)
left
= simplify_or_tree (XEXP (exp
, 0), 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
= attr_rtx (GET_CODE (exp
), left
, right
);
exp
= SIMPLIFY_TEST_EXP (newexp
, insn_code
, insn_index
);
else if (GET_CODE (exp
) == AND
)
/* For the AND case, we do the same as above, except that we can
only eliminate `term' if both sides of the AND would do so. */
left
= simplify_or_tree (XEXP (exp
, 0), &temp
, insn_code
, insn_index
);
left_eliminates_term
= (temp
== false_rtx
);
right
= simplify_or_tree (XEXP (exp
, 1), &temp
, insn_code
, insn_index
);
right_eliminates_term
= (temp
== false_rtx
);
if (left_eliminates_term
&& right_eliminates_term
)
if (left
!= XEXP (exp
, 0) || right
!= XEXP (exp
, 1))
newexp
= attr_rtx (GET_CODE (exp
), left
, right
);
exp
= SIMPLIFY_TEST_EXP (newexp
, insn_code
, insn_index
);
if (attr_equal_p (exp
, *pterm
))
else if (GET_CODE (exp
) == NOT
&& attr_equal_p (XEXP (exp
, 0), *pterm
))
else if (GET_CODE (*pterm
) == NOT
&& attr_equal_p (XEXP (*pterm
, 0), exp
))
else if (GET_CODE (*pterm
) == EQ_ATTR
&& GET_CODE (exp
) == NOT
&& GET_CODE (XEXP (exp
, 0)) == EQ_ATTR
&& XSTR (*pterm
, 0) == XSTR (XEXP (exp
, 0), 0))
else if (GET_CODE (exp
) == EQ_ATTR
&& GET_CODE (*pterm
) == NOT
&& GET_CODE (XEXP (*pterm
, 0)) == EQ_ATTR
&& XSTR (exp
, 0) == XSTR (XEXP (*pterm
, 0), 0))
/* Given an expression, see if it can be simplified for a particular insn
code based on the values of other attributes being tested. This can
eliminate nested get_attr_... calls.
Note that if an endless recursion is specified in the patterns, the
optimization will loop. However, it will do so in precisely the cases where
an infinite recursion loop could occur during compilation. It's better that
simplify_test_exp (exp
, insn_code
, insn_index
)
int insn_code
, insn_index
;
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
))
left
= SIMPLIFY_TEST_EXP (XEXP (exp
, 0), insn_code
, insn_index
);
SIMPLIFY_ALTERNATIVE (left
);
obstack_free (rtl_obstack
, spacer
);
right
= SIMPLIFY_TEST_EXP (XEXP (exp
, 1), insn_code
, insn_index
);
SIMPLIFY_ALTERNATIVE (right
);
obstack_free (rtl_obstack
, spacer
);
/* If either side is an IOR and we have (eq_attr "alternative" ..")
present on both sides, apply the distributive law since this will
yield simplifications. */
if ((GET_CODE (left
) == IOR
|| GET_CODE (right
) == IOR
)
&& compute_alternative_mask (left
, IOR
)
&& compute_alternative_mask (right
, IOR
))
if (GET_CODE (left
) == IOR
)
attr_rtx (AND
, left
, XEXP (right
, 0)),
attr_rtx (AND
, left
, XEXP (right
, 1)));
return SIMPLIFY_TEST_EXP (newexp
, insn_code
, insn_index
);
/* Try with the term on both sides. */
right
= simplify_and_tree (right
, &left
, insn_code
, insn_index
);
if (left
== XEXP (exp
, 0) && right
== XEXP (exp
, 1))
left
= simplify_and_tree (left
, &right
, insn_code
, insn_index
);
if (left
== false_rtx
|| right
== false_rtx
)
obstack_free (rtl_obstack
, spacer
);
else if (left
== true_rtx
)
else if (right
== true_rtx
)
/* See if all or all but one of the insn's alternatives are specified
in this tree. Optimize if so. */
&& (GET_CODE (left
) == AND
|| (GET_CODE (left
) == NOT
&& GET_CODE (XEXP (left
, 0)) == EQ_ATTR
&& XSTR (XEXP (left
, 0), 0) == alternative_name
)
|| GET_CODE (right
) == AND
|| (GET_CODE (right
) == NOT
&& GET_CODE (XEXP (right
, 0)) == EQ_ATTR
&& XSTR (XEXP (right
, 0), 0) == alternative_name
)))
i
= compute_alternative_mask (exp
, AND
);
if (i
& ~insn_alternatives
[insn_code
])
fatal ("Illegal alternative specified for pattern number %d",
/* If all alternatives are excluded, this is false. */
i
^= insn_alternatives
[insn_code
];
else if ((i
& (i
- 1)) == 0 && insn_alternatives
[insn_code
] > 1)
/* If just one excluded, AND a comparison with that one to the
front of the tree. The others will be eliminated by
optimization. We do not want to do this if the insn has one
alternative and we have tested none of them! */
left
= make_alternative_compare (i
);
right
= simplify_and_tree (exp
, &left
, insn_code
, insn_index
);
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
= attr_rtx (AND
, left
, right
);
return SIMPLIFY_TEST_EXP (newexp
, insn_code
, insn_index
);
left
= SIMPLIFY_TEST_EXP (XEXP (exp
, 0), insn_code
, insn_index
);
SIMPLIFY_ALTERNATIVE (left
);
obstack_free (rtl_obstack
, spacer
);
right
= SIMPLIFY_TEST_EXP (XEXP (exp
, 1), insn_code
, insn_index
);
SIMPLIFY_ALTERNATIVE (right
);
obstack_free (rtl_obstack
, spacer
);
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
)
obstack_free (rtl_obstack
, spacer
);
else if (left
== false_rtx
)
else if (right
== false_rtx
)
/* 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
&& attr_equal_p (XEXP (left
, 0), XEXP (right
, 0)))
newexp
= attr_rtx (IOR
, XEXP (left
, 1), XEXP (right
, 1));
newexp
= attr_rtx (AND
, left
, right
);
return SIMPLIFY_TEST_EXP (newexp
, insn_code
, insn_index
);
/* See if all or all but one of the insn's alternatives are specified
in this tree. Optimize if so. */
&& (GET_CODE (left
) == IOR
|| (GET_CODE (left
) == EQ_ATTR
&& XSTR (left
, 0) == alternative_name
)
|| GET_CODE (right
) == IOR
|| (GET_CODE (right
) == EQ_ATTR
&& XSTR (right
, 0) == alternative_name
)))
i
= compute_alternative_mask (exp
, IOR
);
if (i
& ~insn_alternatives
[insn_code
])
fatal ("Illegal alternative specified for pattern number %d",
/* If all alternatives are included, this is true. */
i
^= insn_alternatives
[insn_code
];
else if ((i
& (i
- 1)) == 0 && insn_alternatives
[insn_code
] > 1)
/* If just one excluded, IOR a comparison with that one to the
front of the tree. The others will be eliminated by
optimization. We do not want to do this if the insn has one
alternative and we have tested none of them! */
left
= make_alternative_compare (i
);
right
= simplify_and_tree (exp
, &left
, insn_code
, insn_index
);
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
= attr_rtx (IOR
, left
, right
);
return SIMPLIFY_TEST_EXP (newexp
, insn_code
, insn_index
);
if (GET_CODE (XEXP (exp
, 0)) == NOT
)
left
= SIMPLIFY_TEST_EXP (XEXP (XEXP (exp
, 0), 0),
SIMPLIFY_ALTERNATIVE (left
);
left
= SIMPLIFY_TEST_EXP (XEXP (exp
, 0), insn_code
, insn_index
);
SIMPLIFY_ALTERNATIVE (left
);
if (GET_CODE (left
) == NOT
)
obstack_free (rtl_obstack
, spacer
);
else if (left
== true_rtx
)
obstack_free (rtl_obstack
, spacer
);
/* Try to apply De`Morgan's laws. */
else if (GET_CODE (left
) == IOR
)
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
)
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
);
if (current_alternative_string
&& XSTR (exp
, 0) == alternative_name
)
return (XSTR (exp
, 1) == current_alternative_string
/* 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
);
/* 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. */
int something_changed
= 1;
struct attr_value_list
{ struct attr_value
*av
;
struct attr_value_list
*next
; };
struct attr_value_list
**insn_code_values
;
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. */
/* Make 2 extra elements, for "code" values -2 and -1. */
= (struct attr_value_list
**) alloca ((insn_code_number
+ 2)
* sizeof (struct attr_value_list
*));
(insn_code_number
+ 2) * sizeof (struct attr_value_list
*));
/* Offset the table address so we can index by -2 or -1. */
for (i
= 0; i
< MAX_ATTRS_INDEX
; i
++)
for (attr
= attrs
[i
]; attr
; attr
= attr
->next
)
for (av
= attr
->first_value
; av
; av
= av
->next
)
for (ie
= av
->first_insn
; ie
; ie
= ie
->next
)
iv
= ((struct attr_value_list
*)
alloca (sizeof (struct attr_value_list
)));
iv
->next
= insn_code_values
[ie
->insn_code
];
insn_code_values
[ie
->insn_code
] = iv
;
/* 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. */
while (something_changed
)
for (iv
= insn_code_values
[i
]; iv
; iv
= iv
->next
)
struct obstack
*old
= rtl_obstack
;
char *spacer
= (char *) obstack_finish (temp_obstack
);
if (GET_CODE (av
->value
) != COND
)
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
,
newexp
= simplify_cond (av
->value
, ie
->insn_code
,
newexp
= attr_copy_rtx (newexp
);
remove_insn_ent (av
, ie
);
av
= get_attr_value (newexp
, attr
, ie
->insn_code
);
insert_insn_ent (av
, ie
);
obstack_free (temp_obstack
, spacer
);
simplify_by_alternatives (exp
, insn_code
, insn_index
)
int insn_code
, insn_index
;
int len
= insn_n_alternatives
[insn_code
];
rtx newexp
= rtx_alloc (COND
);
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
);
/* 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
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
Once the dimensions are created, the algorithm enumerates all possible
values and computes the current value of the given expression. */
struct attr_desc
*attr
; /* Attribute for this dimension. */
rtx values
; /* List of attribute values used. */
rtx current_value
; /* Position in the list for the TRUE value. */
int num_values
; /* Length of the values list. */
/* If EXP is a suitable expression, reorganize it by constructing an
equivalent expression that is a COND with the tests being all combinations
of attribute values and the values being simple constants. */
simplify_by_exploding (exp
)
rtx list
= 0, link
, condexp
, defval
;
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);
/* 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
space
= (struct dimension
*) alloca (ndim
* sizeof (struct dimension
));
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);
if ((space
[ndim
].attr
= find_attr (name
, 0)) == 0
|| space
[ndim
].attr
->is_numeric
)
unmark_used_attributes (list
, space
, ndim
);
/* Add all remaining attribute values that refer to this attribute. */
space
[ndim
].num_values
= 0;
for (link
= list
; link
; link
= *prev
)
if (! strcmp (XSTR (XEXP (link
, 0), 0), name
))
space
[ndim
].num_values
++;
XEXP (link
, 1) = space
[ndim
].values
;
space
[ndim
].values
= link
;
/* Add sufficient members to the list of values to make the list
mutually exclusive and record the total size of the attribute
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
)
/* 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
condtest
[i
] = test_for_current_value (space
, ndim
);
condval
[i
] = simplify_with_current_value (exp
, space
, ndim
);
if (! increment_current_value (space
, ndim
))
/* 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. */
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
]))
if (new_marks
- num_marks
> most_tests
)
most_tests
= new_marks
- num_marks
;
/* Clear all the marks. */
for (i
= 0; i
< total
; i
++)
MEM_VOLATILE_P (condval
[i
]) = 0;
/* Give up if nothing is constant. */
/* If all values are the default, use that. */
/* 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
];
/* 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. */
find_and_mark_used_attributes (exp
, terms
, nterms
)
if (! MEM_VOLATILE_P (exp
))
rtx link
= rtx_alloc (EXPR_LIST
);
MEM_VOLATILE_P (exp
) = 1;
if (! find_and_mark_used_attributes (XEXP (exp
, 2), terms
, nterms
))
if (! find_and_mark_used_attributes (XEXP (exp
, 1), terms
, nterms
))
if (! find_and_mark_used_attributes (XEXP (exp
, 0), terms
, nterms
))
for (i
= 0; i
< XVECLEN (exp
, 0); i
++)
if (! find_and_mark_used_attributes (XVECEXP (exp
, 0, i
), terms
, nterms
))
if (! find_and_mark_used_attributes (XEXP (exp
, 1), terms
, nterms
))
/* Clear the MEM_VOLATILE_P flag in all EQ_ATTR expressions on LIST and
in the values of the NDIM-dimensional attribute space SPACE. */
unmark_used_attributes (list
, space
, ndim
)
for (i
= 0; i
< ndim
; i
++)
unmark_used_attributes (space
[i
].values
, 0, 0);
for (link
= list
; link
; link
= XEXP (link
, 1))
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. */
add_values_to_cover (dim
)
for (av
= dim
->attr
->first_value
; av
; av
= av
->next
)
if (GET_CODE (av
->value
) == CONST_STRING
)
if (nalt
< dim
->num_values
)
else if (nalt
== dim
->num_values
)
else if (nalt
* 2 < dim
->num_values
* 3)
/* Most all the values of the attribute are used, so add all the unused
for (link
= dim
->values
; link
; link
= *prev
)
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
))
link
= rtx_alloc (EXPR_LIST
);
/* Very few values are used, so compute a mutually exclusive
expression. (We could do this for numeric values if that becomes
for (link
= dim
->values
; link
; link
= *prev
)
orexp
= insert_right_side (IOR
, orexp
, XEXP (link
, 0), -2);
link
= rtx_alloc (EXPR_LIST
);
XEXP (link
, 0) = attr_rtx (NOT
, orexp
);
/* Increment the current value for the NDIM-dimensional attribute space SPACE
and return FALSE if the increment overflowed. */
increment_current_value (space
, ndim
)
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
;
/* Construct an expression corresponding to the current value for the
NDIM-dimensional attribute space SPACE. */
test_for_current_value (space
, ndim
)
for (i
= 0; i
< ndim
; i
++)
exp
= insert_right_side (AND
, exp
, XEXP (space
[i
].current_value
, 0), -2);
/* 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. */
simplify_with_current_value (exp
, space
, ndim
)
/* 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
)
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
)
/* Reduce the expression EXP based on the MEM_VOLATILE_P settings of
all EQ_ATTR expressions. */
simplify_with_current_value_aux (exp
)
if (MEM_VOLATILE_P (exp
))
cond
= simplify_with_current_value_aux (XEXP (exp
, 0));
return simplify_with_current_value_aux (XEXP (exp
, 1));
else if (cond
== false_rtx
)
return simplify_with_current_value_aux (XEXP (exp
, 2));
return attr_rtx (IF_THEN_ELSE
, cond
,
simplify_with_current_value_aux (XEXP (exp
, 1)),
simplify_with_current_value_aux (XEXP (exp
, 2)));
cond
= simplify_with_current_value_aux (XEXP (exp
, 1));
else if (cond
== false_rtx
)
return simplify_with_current_value_aux (XEXP (exp
, 0));
return attr_rtx (IOR
, cond
,
simplify_with_current_value_aux (XEXP (exp
, 0)));
cond
= simplify_with_current_value_aux (XEXP (exp
, 1));
return simplify_with_current_value_aux (XEXP (exp
, 0));
else if (cond
== false_rtx
)
return attr_rtx (AND
, cond
,
simplify_with_current_value_aux (XEXP (exp
, 0)));
cond
= simplify_with_current_value_aux (XEXP (exp
, 0));
else if (cond
== false_rtx
)
return attr_rtx (NOT
, cond
);
for (i
= 0; i
< XVECLEN (exp
, 0); i
+= 2)
cond
= simplify_with_current_value_aux (XVECEXP (exp
, 0, i
));
return simplify_with_current_value_aux (XVECEXP (exp
, 0, i
+ 1));
else if (cond
== false_rtx
)
abort (); /* With all EQ_ATTR's of known value, a case should
return simplify_with_current_value_aux (XEXP (exp
, 1));
/* Clear the MEM_IN_STRUCT_P flag in EXP and its subexpressions. */
register enum rtx_code code
;
if (RTX_UNCHANGING_P (x
))
/* 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
--)
for (j
= 0; j
< XVECLEN (x
, i
); j
++)
clear_struct_flag (XVECEXP (x
, i
, j
));
clear_struct_flag (XEXP (x
, i
));
/* Return the number of RTX objects making up the expression X.
But if we count more more than MAX objects, stop counting. */
register enum rtx_code code
;
/* 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
--)
for (j
= 0; j
< XVECLEN (x
, i
); j
++)
total
+= count_sub_rtxs (XVECEXP (x
, i
, j
), max
);
total
+= count_sub_rtxs (XEXP (x
, i
), max
);
/* Create table entries for DEFINE_ATTR. */
/* Make a new attribute structure. Check for duplicate by looking at
attr->default_val, since it is initialized by this routine. */
attr
= find_attr (XSTR (exp
, 0), 1);
fatal ("Duplicate definition for `%s' attribute", attr
->name
);
if (*XSTR (exp
, 1) == '\0')
name_ptr
= XSTR (exp
, 1);
while ((p
= next_comma_elt (&name_ptr
)) != NULL
)
av
= (struct attr_value
*) oballoc (sizeof (struct attr_value
));
av
->value
= attr_rtx (CONST_STRING
, p
);
av
->next
= attr
->first_value
;
if (GET_CODE (XEXP (exp
, 2)) == CONST
)
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. */
XEXP (exp
, 2) = check_attr_value (XEXP (exp
, 2), attr
);
attr
->default_val
= get_attr_value (XEXP (exp
, 2), attr
, -2);
/* Given a pattern for DEFINE_PEEPHOLE or DEFINE_INSN, return the number of
alternatives in the constraints. Assume all MATCH_OPERANDs have the same
number of alternatives as this should be checked elsewhere. */
if (GET_CODE (exp
) == MATCH_OPERAND
)
return n_comma_elts (XSTR (exp
, 2));
for (i
= 0, fmt
= GET_RTX_FORMAT (GET_CODE (exp
));
i
< GET_RTX_LENGTH (GET_CODE (exp
)); i
++)
n
= count_alternatives (XEXP (exp
, i
));
if (XVEC (exp
, i
) != NULL
)
for (j
= 0; j
< XVECLEN (exp
, i
); j
++)
n
= count_alternatives (XVECEXP (exp
, i
, j
));
/* Returns non-zero if the given expression contains an EQ_ATTR with the
`alternative' attribute. */
compares_alternatives_p (exp
)
if (GET_CODE (exp
) == EQ_ATTR
&& XSTR (exp
, 0) == alternative_name
)
for (i
= 0, fmt
= GET_RTX_FORMAT (GET_CODE (exp
));
i
< GET_RTX_LENGTH (GET_CODE (exp
)); i
++)
if (compares_alternatives_p (XEXP (exp
, i
)))
for (j
= 0; j
< XVECLEN (exp
, i
); j
++)
if (compares_alternatives_p (XVECEXP (exp
, i
, j
)))
/* Returns non-zero is INNER is contained in EXP. */
contained_in_p (inner
, exp
)
if (rtx_equal_p (inner
, exp
))
for (i
= 0, fmt
= GET_RTX_FORMAT (GET_CODE (exp
));
i
< GET_RTX_LENGTH (GET_CODE (exp
)); i
++)
if (contained_in_p (inner
, XEXP (exp
, i
)))
for (j
= 0; j
< XVECLEN (exp
, i
); j
++)
if (contained_in_p (inner
, XVECEXP (exp
, i
, j
)))
/* Process DEFINE_PEEPHOLE, DEFINE_INSN, and DEFINE_ASM_ATTRIBUTES. */
id
= (struct insn_def
*) oballoc (sizeof (struct insn_def
));
id
->insn_code
= insn_code_number
++;
id
->insn_index
= insn_index_number
++;
id
->num_alternatives
= count_alternatives (exp
);
if (id
->num_alternatives
== 0)
id
->num_alternatives
= 1;
id
->insn_code
= insn_code_number
++;
id
->insn_index
= insn_index_number
++;
id
->num_alternatives
= count_alternatives (exp
);
if (id
->num_alternatives
== 0)
id
->num_alternatives
= 1;
case DEFINE_ASM_ATTRIBUTES
:
id
->num_alternatives
= 1;
got_define_asm_attributes
= 1;
/* Process a DEFINE_DELAY. Validate the vector length, check if annul
true or annul false is specified, and make a `struct delay_desc'. */
struct delay_desc
*delay
;
if (XVECLEN (def
, 1) % 3 != 0)
fatal ("Number of elements in DEFINE_DELAY must be multiple of three.");
for (i
= 0; i
< XVECLEN (def
, 1); i
+= 3)
if (XVECEXP (def
, 1, i
+ 1))
if (XVECEXP (def
, 1, i
+ 2))
delay
= (struct delay_desc
*) oballoc (sizeof (struct delay_desc
));
delay
->num
= ++num_delays
;
/* Process a DEFINE_FUNCTION_UNIT.
This gives information about a function unit contained in the CPU.
We fill in a `struct function_unit_op' and a `struct function_unit'
with information used later by `expand_unit'. */
struct function_unit
*unit
;
struct function_unit_op
*op
;
char *name
= XSTR (def
, 0);
int multiplicity
= XINT (def
, 1);
int simultaneity
= XINT (def
, 2);
rtx condexp
= XEXP (def
, 3);
int ready_cost
= MAX (XINT (def
, 4), 1);
int issue_delay
= MAX (XINT (def
, 5), 1);
/* See if we have already seen this function unit. If so, check that
the multiplicity and simultaneity values are the same. If not, make
a structure for this function unit. */
for (unit
= units
; unit
; unit
= unit
->next
)
if (! strcmp (unit
->name
, name
))
if (unit
->multiplicity
!= multiplicity
|| unit
->simultaneity
!= simultaneity
)
fatal ("Differing specifications given for `%s' function unit.",
unit
= (struct function_unit
*) oballoc (sizeof (struct function_unit
));
unit
->multiplicity
= multiplicity
;
unit
->simultaneity
= simultaneity
;
unit
->issue_delay
.min
= unit
->issue_delay
.max
= issue_delay
;
unit
->condexp
= false_rtx
;
/* Make a new operation class structure entry and initialize it. */
op
= (struct function_unit_op
*) oballoc (sizeof (struct function_unit_op
));
op
->num
= unit
->num_opclasses
++;
op
->issue_delay
= issue_delay
;
/* Set our issue expression based on whether or not an optional conflict
/* Compute the IOR of all the specified expressions. */
for (i
= 0; i
< XVECLEN (def
, 6); i
++)
orexp
= insert_right_side (IOR
, orexp
, XVECEXP (def
, 6, i
), -2);
op
->conflict_exp
= orexp
;
extend_range (&unit
->issue_delay
, 1, issue_delay
);
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);
/* Given a piece of RTX, print a C expression to test it's truth value.
We use AND and IOR both for logical and bit-wise operations, so
interpret them as logical unless they are inside a comparison expression.
The second operand of this function will be non-zero in that case. */
write_test_expr (exp
, in_comparison
)
int comparison_operator
= 0;
/* In order not to worry about operator precedence, surround our part of
the expression with parentheses. */
case GE
: case GT
: case GEU
: case GTU
:
case LE
: case LT
: case LEU
: case LTU
:
case PLUS
: case MINUS
: case MULT
: case DIV
: case MOD
:
case AND
: case IOR
: case XOR
:
case LSHIFT
: case ASHIFT
: case LSHIFTRT
: case ASHIFTRT
:
write_test_expr (XEXP (exp
, 0), in_comparison
|| comparison_operator
);
printf (" >= (unsigned) ");
printf (" > (unsigned) ");
printf (" <= (unsigned) ");
printf (" < (unsigned) ");
write_test_expr (XEXP (exp
, 1), in_comparison
|| comparison_operator
);
/* Special-case (not (eq_attrq "alternative" "x")) */
if (! in_comparison
&& GET_CODE (XEXP (exp
, 0)) == EQ_ATTR
&& XSTR (XEXP (exp
, 0), 0) == alternative_name
)
printf ("which_alternative != %s", XSTR (XEXP (exp
, 0), 1));
/* Otherwise, fall through to normal unary operator. */
write_test_expr (XEXP (exp
, 0), in_comparison
);
/* Comparison test of an attribute with a value. Most of these will
have been removed by optimization. Handle "alternative"
specially and give error if EQ_ATTR present inside a comparison. */
fatal ("EQ_ATTR not valid inside comparison");
if (XSTR (exp
, 0) == alternative_name
)
printf ("which_alternative == %s", XSTR (exp
, 1));
attr
= find_attr (XSTR (exp
, 0), 0);
/* Now is the time to expand the value of a constant attribute. */
write_test_expr (evaluate_eq_attr (exp
, attr
->default_val
->value
,
printf ("get_attr_%s (insn) == ", attr
->name
);
write_attr_valueq (attr
, XSTR (exp
, 1));
/* See if an operand matches a predicate. */
/* If only a mode is given, just ensure the mode matches the operand.
If neither a mode nor predicate is given, error. */
if (XSTR (exp
, 1) == NULL
|| *XSTR (exp
, 1) == '\0')
if (GET_MODE (exp
) == VOIDmode
)
fatal ("Null MATCH_OPERAND specified as test");
printf ("GET_MODE (operands[%d]) == %smode",
XINT (exp
, 0), GET_MODE_NAME (GET_MODE (exp
)));
printf ("%s (operands[%d], %smode)",
XSTR (exp
, 1), XINT (exp
, 0), GET_MODE_NAME (GET_MODE (exp
)));
#if HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_INT
printf ("%d", XWINT (exp
, 0));
printf ("%ld", XWINT (exp
, 0));
/* A random C expression. */
printf ("%s", XSTR (exp
, 0));
/* The address of the branch target. */
printf ("insn_addresses[INSN_UID (JUMP_LABEL (insn))]");
/* The address of the current insn. It would be more consistent with
other usage to make this the address of the NEXT insn, but this gets
too confusing because of the ambiguity regarding the length of the
printf ("insn_current_address");
fatal ("bad RTX code `%s' in attribute calculation\n",
/* Given an attribute value, return the maximum CONST_STRING argument
encountered. It is assumed that they are all numeric. */
if (GET_CODE (exp
) == CONST_STRING
)
return atoi (XSTR (exp
, 0));
else if (GET_CODE (exp
) == COND
)
for (i
= 0; i
< XVECLEN (exp
, 0); i
+= 2)
n
= max_attr_value (XVECEXP (exp
, 0, i
+ 1));
n
= max_attr_value (XEXP (exp
, 1));
else if (GET_CODE (exp
) == IF_THEN_ELSE
)
current_max
= max_attr_value (XEXP (exp
, 1));
n
= max_attr_value (XEXP (exp
, 2));
/* Scan an attribute value, possibly a conditional, and record what actions
will be required to do any conditional tests in it.
`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
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
must_extract
= must_constrain
= 1;
if (XSTR (exp
, 0) == alternative_name
)
must_extract
= must_constrain
= 1;
else if (strcmp (XSTR (exp
, 0), "length") == 0)
for (i
= 0, fmt
= GET_RTX_FORMAT (code
); i
< GET_RTX_LENGTH (code
); i
++)
walk_attr_value (XEXP (exp
, i
));
if (XVEC (exp
, i
) != NULL
)
for (j
= 0; j
< XVECLEN (exp
, i
); j
++)
walk_attr_value (XVECEXP (exp
, i
, j
));
/* Write out a function to obtain the attribute for a given INSN. */
struct attr_value
*av
, *common_av
;
/* Find the most used attribute value. Handle that as the `default' of the
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. */
printf ("enum attr_%s\n", attr
->name
);
else if (attr
->unsigned_p
)
printf ("unsigned 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 if (attr
->is_const
== 0)
printf ("get_attr_%s (insn)\n", attr
->name
);
printf ("get_attr_%s ()\n", attr
->name
);
for (av
= attr
->first_value
; av
; av
= av
->next
)
write_attr_set (attr
, 2, av
->value
, "return", ";",
true_rtx
, av
->first_insn
->insn_code
,
av
->first_insn
->insn_index
);
printf (" switch (recog_memoized (insn))\n");
for (av
= attr
->first_value
; av
; av
= av
->next
)
write_attr_case (attr
, av
, 1, "return", ";", 4, true_rtx
);
write_attr_case (attr
, common_av
, 0, "return", ";", 4, true_rtx
);
/* Given an AND tree of known true terms (because we are inside an `if' with
that as the condition or are in an `else' clause) and an expression,
replace any known true terms with TRUE. Use `simplify_and_tree' to do
eliminate_known_true (known_true
, exp
, insn_code
, insn_index
)
int insn_code
, insn_index
;
known_true
= SIMPLIFY_TEST_EXP (known_true
, insn_code
, insn_index
);
if (GET_CODE (known_true
) == AND
)
exp
= eliminate_known_true (XEXP (known_true
, 0), exp
,
exp
= eliminate_known_true (XEXP (known_true
, 1), exp
,
exp
= simplify_and_tree (exp
, &term
, insn_code
, insn_index
);
/* Write out a series of tests and assignment statements to perform tests and
sets of an attribute value. We are passed an indentation amount and prefix
and suffix strings to write around each attribute value (e.g., "return"
write_attr_set (attr
, indent
, value
, prefix
, suffix
, known_true
,
int insn_code
, insn_index
;
if (GET_CODE (value
) == CONST_STRING
)
write_attr_value (attr
, value
);
else if (GET_CODE (value
) == COND
)
/* Assume the default value will be the default of the COND unless we
find an always true expression. */
rtx default_val
= XEXP (value
, 1);
rtx our_known_true
= known_true
;
for (i
= 0; i
< XVECLEN (value
, 0); i
+= 2)
testexp
= eliminate_known_true (our_known_true
,
newexp
= attr_rtx (NOT
, testexp
);
newexp
= insert_right_side (AND
, our_known_true
, newexp
,
/* If the test expression is always true or if the next `known_true'
expression is always false, this is the last case, so break
out and let this value be the `else' case. */
if (testexp
== true_rtx
|| newexp
== false_rtx
)
default_val
= XVECEXP (value
, 0, i
+ 1);
/* Compute the expression to pass to our recursive call as being
inner_true
= insert_right_side (AND
, our_known_true
,
testexp
, insn_code
, insn_index
);
/* If this is always false, skip it. */
if (inner_true
== false_rtx
)
printf ("%sif ", first_if
? "" : "else ");
write_test_expr (testexp
, 0);
write_indent (indent
+ 2);
write_attr_set (attr
, indent
+ 4,
XVECEXP (value
, 0, i
+ 1), prefix
, suffix
,
inner_true
, insn_code
, insn_index
);
write_indent (indent
+ 2);
write_indent (indent
+ 2);
write_attr_set (attr
, first_if
? indent
: indent
+ 4, default_val
,
prefix
, suffix
, our_known_true
, insn_code
, insn_index
);
write_indent (indent
+ 2);
/* Write out the computation for one attribute value. */
write_attr_case (attr
, av
, write_case_lines
, prefix
, suffix
, indent
, known_true
)
write_indent (indent
+ 2);
printf ("if (GET_CODE (PATTERN (insn)) != ASM_INPUT\n");
write_indent (indent
+ 2);
printf (" && asm_noperands (PATTERN (insn)) < 0)\n");
write_indent (indent
+ 2);
printf (" fatal_insn_not_found (insn);\n");
for (ie
= av
->first_insn
; ie
; ie
= ie
->next
)
printf ("case %d:\n", ie
->insn_code
);
/* See what we have to do to output this value. */
must_extract
= must_constrain
= address_used
= 0;
walk_attr_value (av
->value
);
write_indent (indent
+ 2);
printf ("insn_extract (insn);\n");
#ifdef REGISTER_CONSTRAINTS
write_indent (indent
+ 2);
printf ("if (! constrain_operands (INSN_CODE (insn), reload_completed))\n");
write_indent (indent
+ 2);
printf (" fatal_insn_not_found (insn);\n");
write_attr_set (attr
, indent
+ 2, av
->value
, prefix
, suffix
,
known_true
, av
->first_insn
->insn_code
,
av
->first_insn
->insn_index
);
if (strncmp (prefix
, "return", 6))
write_indent (indent
+ 2);
/* Utilities to write names in various forms. */
write_attr_valueq (attr
, s
)
/* Make the blockage range values easier to read. */
printf (" /* 0x%x */", atoi (s
));
write_upcase (attr
->name
);
write_attr_value (attr
, value
)
if (GET_CODE (value
) != CONST_STRING
)
write_attr_valueq (attr
, XSTR (value
, 0));
if (*str
< 'a' || *str
> 'z')
printf ("%c", *str
++ - 'a' + 'A');
for (; indent
> 8; indent
-= 8)
/* Write a subroutine that is given an insn that requires a delay slot, a
delay slot ordinal, and a candidate insn. It returns non-zero if the
candidate can be placed in the specified delay slot of the insn.
We can write as many as three subroutines. `eligible_for_delay'
handles normal delay slots, `eligible_for_annul_true' indicates that
the specified insn can be annulled if the branch is true, and likewise
for `eligible_for_annul_false'.
KIND is a string distinguishing these three cases ("delay", "annul_true",
write_eligible_delay (kind
)
struct delay_desc
*delay
;
struct attr_value
*av
, *common_av
;
/* Compute the maximum number of delay slots required. We use the delay
ordinal times this number plus one, plus the slot number as an index into
the appropriate predicate to test. */
for (delay
= delays
, max_slots
= 0; delay
; delay
= delay
->next
)
if (XVECLEN (delay
->def
, 1) / 3 > max_slots
)
max_slots
= XVECLEN (delay
->def
, 1) / 3;
/* Write function prelude. */
printf ("eligible_for_%s (delay_insn, slot, candidate_insn)\n", kind
);
printf (" rtx delay_insn;\n");
printf (" rtx candidate_insn;\n");
printf (" if (slot >= %d)\n", max_slots
);
/* If more than one delay type, find out which type the delay insn is. */
attr
= find_attr ("*delay_type", 0);
common_av
= find_most_used (attr
);
printf (" insn = delay_insn;\n");
printf (" switch (recog_memoized (insn))\n");
sprintf (str
, " * %d;\n break;", max_slots
);
for (av
= attr
->first_value
; av
; av
= av
->next
)
write_attr_case (attr
, av
, 1, "slot +=", str
, 4, true_rtx
);
write_attr_case (attr
, common_av
, 0, "slot +=", str
, 4, true_rtx
);
/* Ensure matched. Otherwise, shouldn't have been called. */
printf (" if (slot < %d)\n", max_slots
);
printf (" abort ();\n\n");
/* If just one type of delay slot, write simple switch. */
if (num_delays
== 1 && max_slots
== 1)
printf (" insn = candidate_insn;\n");
printf (" switch (recog_memoized (insn))\n");
attr
= find_attr ("*delay_1_0", 0);
common_av
= find_most_used (attr
);
for (av
= attr
->first_value
; av
; av
= av
->next
)
write_attr_case (attr
, av
, 1, "return", ";", 4, true_rtx
);
write_attr_case (attr
, common_av
, 0, "return", ";", 4, true_rtx
);
/* Write a nested CASE. The first indicates which condition we need to
test, and the inner CASE tests the condition. */
printf (" insn = candidate_insn;\n");
printf (" switch (slot)\n");
for (delay
= delays
; delay
; delay
= delay
->next
)
for (i
= 0; i
< XVECLEN (delay
->def
, 1); i
+= 3)
(i
/ 3) + (num_delays
== 1 ? 0 : delay
->num
* max_slots
));
printf (" switch (recog_memoized (insn))\n");
sprintf (str
, "*%s_%d_%d", kind
, delay
->num
, i
/ 3);
attr
= find_attr (str
, 0);
common_av
= find_most_used (attr
);
for (av
= attr
->first_value
; av
; av
= av
->next
)
write_attr_case (attr
, av
, 1, "return", ";", 8, true_rtx
);
write_attr_case (attr
, common_av
, 0, "return", ";", 8, true_rtx
);
/* Write routines to compute conflict cost for function units. Then write a
table describing the available function units. */
write_function_unit_info ()
struct function_unit
*unit
;
/* Write out conflict routines for function units. Don't bother writing
one if there is only one issue delay value. */
for (unit
= units
; unit
; unit
= unit
->next
)
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
)
unit
->default_cost
= make_numeric_value (unit
->issue_delay
.max
);
/* The function first computes the case from the candidate insn. */
unit
->default_cost
= make_numeric_value (0);
write_complex_function (unit
, "conflict_cost", "cost");
/* Now that all functions have been written, write the table describing
the function units. The name is included for documentation purposes
printf ("struct function_unit_desc function_units[] = {\n");
/* 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
)
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
);
if (unit
->needs_conflict_function
)
printf ("%s_unit_conflict_cost, ", unit
->name
);
printf ("%d, ", unit
->max_blockage
);
if (unit
->needs_range_function
)
printf ("%s_unit_blockage_range, ", unit
->name
);
if (unit
->needs_blockage_function
)
printf ("%s_unit_blockage", unit
->name
);
write_complex_function (unit
, name
, connection
)
struct function_unit
*unit
;
struct attr_desc
*case_attr
, *attr
;
struct attr_value
*av
, *common_av
;
printf ("%s_unit_%s (executing_insn, candidate_insn)\n",
printf (" rtx executing_insn;\n");
printf (" rtx candidate_insn;\n");
printf (" int casenum;\n\n");
printf (" insn = candidate_insn;\n");
printf (" switch (recog_memoized (insn))\n");
/* Write the `switch' statement to get the case value. */
str
= (char *) alloca (strlen (unit
->name
) + strlen (name
) + strlen (connection
) + 10);
sprintf (str
, "*%s_cases", unit
->name
);
case_attr
= find_attr (str
, 0);
if (! case_attr
) abort ();
common_av
= find_most_used (case_attr
);
for (av
= case_attr
->first_value
; av
; av
= av
->next
)
write_attr_case (case_attr
, av
, 1,
"casenum =", ";", 4, unit
->condexp
);
write_attr_case (case_attr
, common_av
, 0,
"casenum =", ";", 4, unit
->condexp
);
/* 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");
for (i
= 0; i
< unit
->num_opclasses
; i
++)
/* Ensure using this case. */
for (av
= case_attr
->first_value
; av
; av
= av
->next
)
&& contained_in_p (make_numeric_value (i
), av
->value
))
printf (" case %d:\n", i
);
sprintf (str
, "*%s_%s_%d", unit
->name
, connection
, i
);
attr
= find_attr (str
, 0);
/* If single value, just write it. */
value
= find_single_value (attr
);
write_attr_set (attr
, 6, value
, "return", ";\n", true_rtx
, -2);
common_av
= find_most_used (attr
);
printf (" switch (recog_memoized (insn))\n");
for (av
= attr
->first_value
; av
; av
= av
->next
)
write_attr_case (attr
, av
, 1,
"return", ";", 8, unit
->condexp
);
write_attr_case (attr
, common_av
, 0,
"return", ";", 8, unit
->condexp
);
/* This page contains miscellaneous utility routines. */
/* Given a string, return the number of comma-separated elements in it.
Return 0 for the null string. */
/* Given a pointer to a (char *), return a malloc'ed string containing the
next comma-separated element. Advance the pointer to after the string
scanned, or the end-of-string. Return NULL if at end of string. */
/* Find end of string to compute length. */
for (p
= *pstr
; *p
!= ',' && *p
!= '\0'; p
++)
out_str
= attr_string (*pstr
, p
- *pstr
);
/* Return a `struct attr_desc' pointer for a given named attribute. If CREATE
is non-zero, build a new attribute, if one does not exist. */
static struct attr_desc
*
/* 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
)
index
= name
[0] & (MAX_ATTRS_INDEX
- 1);
for (attr
= attrs
[index
]; attr
; attr
= attr
->next
)
/* Otherwise, do it the slow way. */
for (attr
= attrs
[index
]; attr
; attr
= attr
->next
)
if (name
[0] == attr
->name
[0] && ! strcmp (name
, attr
->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
->negative_ok
= attr
->is_const
= attr
->is_special
= 0;
attr
->next
= attrs
[index
];
/* Create internal attribute with the given default value. */
make_internal_attr (name
, value
, special
)
attr
= find_attr (name
, 1);
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);
/* Find the most used value of an attribute. */
static struct attr_value
*
struct attr_value
*most_used
;
for (av
= attr
->first_value
; av
; av
= av
->next
)
if (av
->num_insns
> nuses
)
nuses
= av
->num_insns
, most_used
= av
;
/* If an attribute only has a single value used, return it. Otherwise
for (av
= attr
->first_value
; av
; av
= av
->next
)
unique_value
= av
->value
;
/* Return (attr_value "n") */
static rtx int_values
[20];
if (n
< 20 && int_values
[n
])
p
= attr_printf (MAX_DIGITS
, "%d", n
);
exp
= attr_rtx (CONST_STRING
, p
);
extend_range (range
, min
, max
)
if (range
->min
> min
) range
->min
= min
;
if (range
->max
< max
) range
->max
= max
;
char *result
= (char *) realloc (ptr
, size
);
fatal ("virtual memory exhausted");
register char *val
= (char *) malloc (size
);
fatal ("virtual memory exhausted");
copy_rtx_unchanging (orig
)
if (RTX_UNCHANGING_P (orig
) || MEM_IN_STRUCT_P (orig
))
MEM_IN_STRUCT_P (orig
) = 1;
PUT_MODE (copy
, GET_MODE (orig
));
RTX_UNCHANGING_P (copy
) = 1;
bcopy (&XEXP (orig
, 0), &XEXP (copy
, 0),
GET_RTX_LENGTH (GET_CODE (copy
)) * sizeof (rtx
));
fprintf (stderr
, "genattrtab: ");
fprintf (stderr
, s
, a1
, a2
);
/* More 'friendly' abort that prints the line and file.
config.h can #define abort fancy_abort if you like that sort of thing. */
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. */
write_const_num_delay_slots ()
struct attr_desc
*attr
= find_attr ("*num_delay_slots", 0);
printf ("int\nconst_num_delay_slots (insn)\n");
printf (" rtx *insn;\n");
printf (" switch (recog_memoized (insn))\n");
for (av
= attr
->first_value
; av
; av
= av
->next
)
walk_attr_value (av
->value
);
for (ie
= av
->first_insn
; ie
; ie
= ie
->next
)
printf (" case %d:\n", ie
->insn_code
);
/* Get rid of any avoidable limit on stack size. */
/* 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
);
fatal ("No input file name.");
infile
= fopen (argv
[1], "r");
/* Set up true and false rtx's */
true_rtx
= rtx_alloc (CONST_INT
);
false_rtx
= rtx_alloc (CONST_INT
);
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");
/* Read the machine description. */
c
= read_skip_spaces (infile
);
desc
= read_rtx (infile
);
if (GET_CODE (desc
) == DEFINE_INSN
|| GET_CODE (desc
) == DEFINE_PEEPHOLE
|| GET_CODE (desc
) == DEFINE_ASM_ATTRIBUTES
)
else if (GET_CODE (desc
) == DEFINE_EXPAND
)
insn_code_number
++, insn_index_number
++;
else if (GET_CODE (desc
) == DEFINE_SPLIT
)
insn_code_number
++, insn_index_number
++;
else if (GET_CODE (desc
) == DEFINE_ATTR
)
else if (GET_CODE (desc
) == DEFINE_DELAY
)
else if (GET_CODE (desc
) == DEFINE_FUNCTION_UNIT
)
/* If we didn't have a DEFINE_ASM_ATTRIBUTES, make a null one. */
if (! got_define_asm_attributes
)
tem
= rtx_alloc (DEFINE_ASM_ATTRIBUTES
);
XVEC (tem
, 0) = rtvec_alloc (0);
/* Expand DEFINE_DELAY information into new attribute. */
/* Expand DEFINE_FUNCTION_UNIT information into new attributes. */
printf ("#include \"config.h\"\n");
printf ("#include \"rtl.h\"\n");
printf ("#include \"insn-config.h\"\n");
printf ("#include \"recog.h\"\n");
printf ("#include \"regs.h\"\n");
printf ("#include \"real.h\"\n");
printf ("#include \"output.h\"\n");
printf ("#include \"insn-attr.h\"\n");
printf ("#define operands recog_operand\n\n");
/* Make `insn_alternatives'. */
insn_alternatives
= (int *) oballoc (insn_code_number
* sizeof (int));
for (id
= defs
; id
; id
= id
->next
)
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
)
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. */
for (i
= 0; i
< MAX_ATTRS_INDEX
; i
++)
for (attr
= attrs
[i
]; attr
; attr
= attr
->next
)
= check_attr_value (attr
->default_val
->value
, attr
);
/* Construct extra attributes for `length'. */
/* Perform any possible optimizations to speed up compilation. */
/* 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 (i
= 0; i
< MAX_ATTRS_INDEX
; i
++)
for (attr
= attrs
[i
]; attr
; attr
= attr
->next
)
/* Write out delay eligibility information, if DEFINE_DELAY present.
(The function to compute the number of delay slots will be written
write_eligible_delay ("delay");
write_eligible_delay ("annul_true");
write_eligible_delay ("annul_false");
/* Write out information about function units. */
write_function_unit_info ();
/* Write out constant delay slot info */
write_const_num_delay_slots ();
exit (ferror (stdout
) != 0 ? FATAL_EXIT_CODE
: SUCCESS_EXIT_CODE
);