/* Generate code from machine description to compute values of attributes.
|
/* Generate code from machine description to compute values of attributes.
|
Copyright (C) 1991, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
|
Copyright (C) 1991, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
|
2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
|
2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
|
Free Software Foundation, Inc.
|
Free Software Foundation, Inc.
|
Contributed by Richard Kenner (kenner@vlsi1.ultra.nyu.edu)
|
Contributed by Richard Kenner (kenner@vlsi1.ultra.nyu.edu)
|
|
|
This file is part of GCC.
|
This file is part of GCC.
|
|
|
GCC is free software; you can redistribute it and/or modify it under
|
GCC 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
|
the terms of the GNU General Public License as published by the Free
|
Software Foundation; either version 3, or (at your option) any later
|
Software Foundation; either version 3, or (at your option) any later
|
version.
|
version.
|
|
|
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
|
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
|
WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
for more details.
|
for more details.
|
|
|
You should have received a copy of the GNU General Public License
|
You should have received a copy of the GNU General Public License
|
along with GCC; see the file COPYING3. If not see
|
along with GCC; see the file COPYING3. If not see
|
<http://www.gnu.org/licenses/>. */
|
<http://www.gnu.org/licenses/>. */
|
|
|
/* This program handles insn attributes and the DEFINE_DELAY and
|
/* This program handles insn attributes and the DEFINE_DELAY and
|
DEFINE_INSN_RESERVATION definitions.
|
DEFINE_INSN_RESERVATION definitions.
|
|
|
It produces a series of functions named `get_attr_...', one for each insn
|
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
|
attribute. Each of these is given the rtx for an insn and returns a member
|
of the enum for the attribute.
|
of the enum for the attribute.
|
|
|
These subroutines have the form of a `switch' on the INSN_CODE (via
|
These subroutines have the form of a `switch' on the INSN_CODE (via
|
`recog_memoized'). Each case either returns a constant attribute value
|
`recog_memoized'). Each case either returns a constant attribute value
|
or a value that depends on tests on other attributes, the form of
|
or a value that depends on tests on other attributes, the form of
|
operands, or some random C expression (encoded with a SYMBOL_REF
|
operands, or some random C expression (encoded with a SYMBOL_REF
|
expression).
|
expression).
|
|
|
If the attribute `alternative', or a random C expression is present,
|
If the attribute `alternative', or a random C expression is present,
|
`constrain_operands' is called. If either of these cases of a reference to
|
`constrain_operands' is called. If either of these cases of a reference to
|
an operand is found, `extract_insn' is called.
|
an operand is found, `extract_insn' is called.
|
|
|
The special attribute `length' is also recognized. For this operand,
|
The special attribute `length' is also recognized. For this operand,
|
expressions involving the address of an operand or the current insn,
|
expressions involving the address of an operand or the current insn,
|
(address (pc)), are valid. In this case, an initial pass is made to
|
(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
|
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
|
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
|
and possibly has its length changed. The process repeats until no further
|
changed are made. The resulting lengths are saved for use by
|
changed are made. The resulting lengths are saved for use by
|
`get_attr_length'.
|
`get_attr_length'.
|
|
|
A special form of DEFINE_ATTR, where the expression for default value is a
|
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
|
CONST expression, indicates an attribute that is constant for a given run
|
of the compiler. The subroutine generated for these attributes has no
|
of the compiler. The subroutine generated for these attributes has no
|
parameters as it does not depend on any particular insn. Constant
|
parameters as it does not depend on any particular insn. Constant
|
attributes are typically used to specify which variety of processor is
|
attributes are typically used to specify which variety of processor is
|
used.
|
used.
|
|
|
Internal attributes are defined to handle DEFINE_DELAY and
|
Internal attributes are defined to handle DEFINE_DELAY and
|
DEFINE_INSN_RESERVATION. Special routines are output for these cases.
|
DEFINE_INSN_RESERVATION. Special routines are output for these cases.
|
|
|
This program works by keeping a list of possible values for each attribute.
|
This program works by keeping a list of possible values for each attribute.
|
These include the basic attribute choices, default values for attribute, and
|
These include the basic attribute choices, default values for attribute, and
|
all derived quantities.
|
all derived quantities.
|
|
|
As the description file is read, the definition for each insn is saved in a
|
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'
|
`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,
|
is created for each insn and chained to the corresponding attribute value,
|
either that specified, or the default.
|
either that specified, or the default.
|
|
|
An optimization phase is then run. This simplifies expressions for each
|
An optimization phase is then run. This simplifies expressions for each
|
insn. EQ_ATTR tests are resolved, whenever possible, to a test that
|
insn. EQ_ATTR tests are resolved, whenever possible, to a test that
|
indicates when the attribute has the specified value for the insn. This
|
indicates when the attribute has the specified value for the insn. This
|
avoids recursive calls during compilation.
|
avoids recursive calls during compilation.
|
|
|
The strategy used when processing DEFINE_DELAY definitions is to create
|
The strategy used when processing DEFINE_DELAY definitions is to create
|
arbitrarily complex expressions and have the optimization simplify them.
|
arbitrarily complex expressions and have the optimization simplify them.
|
|
|
Once optimization is complete, any required routines and definitions
|
Once optimization is complete, any required routines and definitions
|
will be written.
|
will be written.
|
|
|
An optimization that is not yet implemented is to hoist the constant
|
An optimization that is not yet implemented is to hoist the constant
|
expressions entirely out of the routines and definitions that are written.
|
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
|
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
|
for constant attributes and generate a set of functions for that given
|
combination. An initialization function would be written that evaluates
|
combination. An initialization function would be written that evaluates
|
the attributes and installs the corresponding set of routines and
|
the attributes and installs the corresponding set of routines and
|
definitions (each would be accessed through a pointer).
|
definitions (each would be accessed through a pointer).
|
|
|
We use the flags in an RTX as follows:
|
We use the flags in an RTX as follows:
|
`unchanging' (ATTR_IND_SIMPLIFIED_P): This rtx is fully simplified
|
`unchanging' (ATTR_IND_SIMPLIFIED_P): This rtx is fully simplified
|
independent of the insn code.
|
independent of the insn code.
|
`in_struct' (ATTR_CURR_SIMPLIFIED_P): This rtx is fully simplified
|
`in_struct' (ATTR_CURR_SIMPLIFIED_P): This rtx is fully simplified
|
for the insn code currently being processed (see optimize_attrs).
|
for the insn code currently being processed (see optimize_attrs).
|
`return_val' (ATTR_PERMANENT_P): This rtx is permanent and unique
|
`return_val' (ATTR_PERMANENT_P): This rtx is permanent and unique
|
(see attr_rtx). */
|
(see attr_rtx). */
|
|
|
#define ATTR_IND_SIMPLIFIED_P(RTX) (RTX_FLAG((RTX), unchanging))
|
#define ATTR_IND_SIMPLIFIED_P(RTX) (RTX_FLAG((RTX), unchanging))
|
#define ATTR_CURR_SIMPLIFIED_P(RTX) (RTX_FLAG((RTX), in_struct))
|
#define ATTR_CURR_SIMPLIFIED_P(RTX) (RTX_FLAG((RTX), in_struct))
|
#define ATTR_PERMANENT_P(RTX) (RTX_FLAG((RTX), return_val))
|
#define ATTR_PERMANENT_P(RTX) (RTX_FLAG((RTX), return_val))
|
|
|
#if 0
|
#if 0
|
#define strcmp_check(S1, S2) ((S1) == (S2) \
|
#define strcmp_check(S1, S2) ((S1) == (S2) \
|
? 0 \
|
? 0 \
|
: (gcc_assert (strcmp ((S1), (S2))), 1))
|
: (gcc_assert (strcmp ((S1), (S2))), 1))
|
#else
|
#else
|
#define strcmp_check(S1, S2) ((S1) != (S2))
|
#define strcmp_check(S1, S2) ((S1) != (S2))
|
#endif
|
#endif
|
|
|
#include "bconfig.h"
|
#include "bconfig.h"
|
#include "system.h"
|
#include "system.h"
|
#include "coretypes.h"
|
#include "coretypes.h"
|
#include "tm.h"
|
#include "tm.h"
|
#include "rtl.h"
|
#include "rtl.h"
|
#include "gensupport.h"
|
#include "gensupport.h"
|
#include "obstack.h"
|
#include "obstack.h"
|
#include "errors.h"
|
#include "errors.h"
|
|
|
/* Flags for make_internal_attr's `special' parameter. */
|
/* Flags for make_internal_attr's `special' parameter. */
|
#define ATTR_NONE 0
|
#define ATTR_NONE 0
|
#define ATTR_SPECIAL (1 << 0)
|
#define ATTR_SPECIAL (1 << 0)
|
|
|
static struct obstack obstack1, obstack2;
|
static struct obstack obstack1, obstack2;
|
static struct obstack *hash_obstack = &obstack1;
|
static struct obstack *hash_obstack = &obstack1;
|
static struct obstack *temp_obstack = &obstack2;
|
static struct obstack *temp_obstack = &obstack2;
|
|
|
/* enough space to reserve for printing out ints */
|
/* enough space to reserve for printing out ints */
|
#define MAX_DIGITS (HOST_BITS_PER_INT * 3 / 10 + 3)
|
#define MAX_DIGITS (HOST_BITS_PER_INT * 3 / 10 + 3)
|
|
|
/* Define structures used to record attributes and values. */
|
/* Define structures used to record attributes and values. */
|
|
|
/* As each DEFINE_INSN, DEFINE_PEEPHOLE, or DEFINE_ASM_ATTRIBUTES is
|
/* As each DEFINE_INSN, DEFINE_PEEPHOLE, or DEFINE_ASM_ATTRIBUTES is
|
encountered, we store all the relevant information into a
|
encountered, we store all the relevant information into a
|
`struct insn_def'. This is done to allow attribute definitions to occur
|
`struct insn_def'. This is done to allow attribute definitions to occur
|
anywhere in the file. */
|
anywhere in the file. */
|
|
|
struct insn_def
|
struct insn_def
|
{
|
{
|
struct insn_def *next; /* Next insn in chain. */
|
struct insn_def *next; /* Next insn in chain. */
|
rtx def; /* The DEFINE_... */
|
rtx def; /* The DEFINE_... */
|
int insn_code; /* Instruction number. */
|
int insn_code; /* Instruction number. */
|
int insn_index; /* Expression number in file, for errors. */
|
int insn_index; /* Expression number in file, for errors. */
|
int lineno; /* Line number. */
|
int lineno; /* Line number. */
|
int num_alternatives; /* Number of alternatives. */
|
int num_alternatives; /* Number of alternatives. */
|
int vec_idx; /* Index of attribute vector in `def'. */
|
int vec_idx; /* Index of attribute vector in `def'. */
|
};
|
};
|
|
|
/* Once everything has been read in, we store in each attribute value a list
|
/* 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
|
of insn codes that have that value. Here is the structure used for the
|
list. */
|
list. */
|
|
|
struct insn_ent
|
struct insn_ent
|
{
|
{
|
struct insn_ent *next; /* Next in chain. */
|
struct insn_ent *next; /* Next in chain. */
|
struct insn_def *def; /* Instruction definition. */
|
struct insn_def *def; /* Instruction definition. */
|
};
|
};
|
|
|
/* Each value of an attribute (either constant or computed) is assigned a
|
/* 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
|
structure which is used as the listhead of the insns that have that
|
value. */
|
value. */
|
|
|
struct attr_value
|
struct attr_value
|
{
|
{
|
rtx value; /* Value of attribute. */
|
rtx value; /* Value of attribute. */
|
struct attr_value *next; /* Next attribute value in chain. */
|
struct attr_value *next; /* Next attribute value in chain. */
|
struct insn_ent *first_insn; /* First insn with this value. */
|
struct insn_ent *first_insn; /* First insn with this value. */
|
int num_insns; /* Number of insns with this value. */
|
int num_insns; /* Number of insns with this value. */
|
int has_asm_insn; /* True if this value used for `asm' insns */
|
int has_asm_insn; /* True if this value used for `asm' insns */
|
};
|
};
|
|
|
/* Structure for each attribute. */
|
/* Structure for each attribute. */
|
|
|
struct attr_desc
|
struct attr_desc
|
{
|
{
|
char *name; /* Name of attribute. */
|
char *name; /* Name of attribute. */
|
struct attr_desc *next; /* Next attribute. */
|
struct attr_desc *next; /* Next attribute. */
|
struct attr_value *first_value; /* First value of this attribute. */
|
struct attr_value *first_value; /* First value of this attribute. */
|
struct attr_value *default_val; /* Default value for this attribute. */
|
struct attr_value *default_val; /* Default value for this attribute. */
|
int lineno : 24; /* Line number. */
|
int lineno : 24; /* Line number. */
|
unsigned is_numeric : 1; /* Values of this attribute are numeric. */
|
unsigned is_numeric : 1; /* Values of this attribute are numeric. */
|
unsigned is_const : 1; /* Attribute value constant for each run. */
|
unsigned is_const : 1; /* Attribute value constant for each run. */
|
unsigned is_special : 1; /* Don't call `write_attr_set'. */
|
unsigned is_special : 1; /* Don't call `write_attr_set'. */
|
};
|
};
|
|
|
/* Structure for each DEFINE_DELAY. */
|
/* Structure for each DEFINE_DELAY. */
|
|
|
struct delay_desc
|
struct delay_desc
|
{
|
{
|
rtx def; /* DEFINE_DELAY expression. */
|
rtx def; /* DEFINE_DELAY expression. */
|
struct delay_desc *next; /* Next DEFINE_DELAY. */
|
struct delay_desc *next; /* Next DEFINE_DELAY. */
|
int num; /* Number of DEFINE_DELAY, starting at 1. */
|
int num; /* Number of DEFINE_DELAY, starting at 1. */
|
int lineno; /* Line number. */
|
int lineno; /* Line number. */
|
};
|
};
|
|
|
struct attr_value_list
|
struct attr_value_list
|
{
|
{
|
struct attr_value *av;
|
struct attr_value *av;
|
struct insn_ent *ie;
|
struct insn_ent *ie;
|
struct attr_desc *attr;
|
struct attr_desc *attr;
|
struct attr_value_list *next;
|
struct attr_value_list *next;
|
};
|
};
|
|
|
/* Listheads of above structures. */
|
/* Listheads of above structures. */
|
|
|
/* This one is indexed by the first character of the attribute name. */
|
/* This one is indexed by the first character of the attribute name. */
|
#define MAX_ATTRS_INDEX 256
|
#define MAX_ATTRS_INDEX 256
|
static struct attr_desc *attrs[MAX_ATTRS_INDEX];
|
static struct attr_desc *attrs[MAX_ATTRS_INDEX];
|
static struct insn_def *defs;
|
static struct insn_def *defs;
|
static struct delay_desc *delays;
|
static struct delay_desc *delays;
|
struct attr_value_list **insn_code_values;
|
struct attr_value_list **insn_code_values;
|
|
|
/* Other variables. */
|
/* Other variables. */
|
|
|
static int insn_code_number;
|
static int insn_code_number;
|
static int insn_index_number;
|
static int insn_index_number;
|
static int got_define_asm_attributes;
|
static int got_define_asm_attributes;
|
static int must_extract;
|
static int must_extract;
|
static int must_constrain;
|
static int must_constrain;
|
static int address_used;
|
static int address_used;
|
static int length_used;
|
static int length_used;
|
static int num_delays;
|
static int num_delays;
|
static int have_annul_true, have_annul_false;
|
static int have_annul_true, have_annul_false;
|
static int num_insn_ents;
|
static int num_insn_ents;
|
|
|
/* Stores, for each insn code, the number of constraint alternatives. */
|
/* Stores, for each insn code, the number of constraint alternatives. */
|
|
|
static int *insn_n_alternatives;
|
static int *insn_n_alternatives;
|
|
|
/* Stores, for each insn code, a bitmap that has bits on for each possible
|
/* Stores, for each insn code, a bitmap that has bits on for each possible
|
alternative. */
|
alternative. */
|
|
|
static int *insn_alternatives;
|
static int *insn_alternatives;
|
|
|
/* Used to simplify expressions. */
|
/* Used to simplify expressions. */
|
|
|
static rtx true_rtx, false_rtx;
|
static rtx true_rtx, false_rtx;
|
|
|
/* Used to reduce calls to `strcmp' */
|
/* Used to reduce calls to `strcmp' */
|
|
|
static const char *alternative_name;
|
static const char *alternative_name;
|
static const char *length_str;
|
static const char *length_str;
|
static const char *delay_type_str;
|
static const char *delay_type_str;
|
static const char *delay_1_0_str;
|
static const char *delay_1_0_str;
|
static const char *num_delay_slots_str;
|
static const char *num_delay_slots_str;
|
|
|
/* Simplify an expression. Only call the routine if there is something to
|
/* Simplify an expression. Only call the routine if there is something to
|
simplify. */
|
simplify. */
|
#define SIMPLIFY_TEST_EXP(EXP,INSN_CODE,INSN_INDEX) \
|
#define SIMPLIFY_TEST_EXP(EXP,INSN_CODE,INSN_INDEX) \
|
(ATTR_IND_SIMPLIFIED_P (EXP) || ATTR_CURR_SIMPLIFIED_P (EXP) ? (EXP) \
|
(ATTR_IND_SIMPLIFIED_P (EXP) || ATTR_CURR_SIMPLIFIED_P (EXP) ? (EXP) \
|
: simplify_test_exp (EXP, INSN_CODE, INSN_INDEX))
|
: simplify_test_exp (EXP, INSN_CODE, INSN_INDEX))
|
|
|
#define DEF_ATTR_STRING(S) (attr_string ((S), strlen (S)))
|
#define DEF_ATTR_STRING(S) (attr_string ((S), strlen (S)))
|
|
|
/* Forward declarations of functions used before their definitions, only. */
|
/* Forward declarations of functions used before their definitions, only. */
|
static char *attr_string (const char *, int);
|
static char *attr_string (const char *, int);
|
static char *attr_printf (unsigned int, const char *, ...)
|
static char *attr_printf (unsigned int, const char *, ...)
|
ATTRIBUTE_PRINTF_2;
|
ATTRIBUTE_PRINTF_2;
|
static rtx make_numeric_value (int);
|
static rtx make_numeric_value (int);
|
static struct attr_desc *find_attr (const char **, int);
|
static struct attr_desc *find_attr (const char **, int);
|
static rtx mk_attr_alt (int);
|
static rtx mk_attr_alt (int);
|
static char *next_comma_elt (const char **);
|
static char *next_comma_elt (const char **);
|
static rtx insert_right_side (enum rtx_code, rtx, rtx, int, int);
|
static rtx insert_right_side (enum rtx_code, rtx, rtx, int, int);
|
static rtx copy_boolean (rtx);
|
static rtx copy_boolean (rtx);
|
static int compares_alternatives_p (rtx);
|
static int compares_alternatives_p (rtx);
|
static void make_internal_attr (const char *, rtx, int);
|
static void make_internal_attr (const char *, rtx, int);
|
static void insert_insn_ent (struct attr_value *, struct insn_ent *);
|
static void insert_insn_ent (struct attr_value *, struct insn_ent *);
|
static void walk_attr_value (rtx);
|
static void walk_attr_value (rtx);
|
static int max_attr_value (rtx, int*);
|
static int max_attr_value (rtx, int*);
|
static int min_attr_value (rtx, int*);
|
static int min_attr_value (rtx, int*);
|
static int or_attr_value (rtx, int*);
|
static int or_attr_value (rtx, int*);
|
static rtx simplify_test_exp (rtx, int, int);
|
static rtx simplify_test_exp (rtx, int, int);
|
static rtx simplify_test_exp_in_temp (rtx, int, int);
|
static rtx simplify_test_exp_in_temp (rtx, int, int);
|
static rtx copy_rtx_unchanging (rtx);
|
static rtx copy_rtx_unchanging (rtx);
|
static bool attr_alt_subset_p (rtx, rtx);
|
static bool attr_alt_subset_p (rtx, rtx);
|
static bool attr_alt_subset_of_compl_p (rtx, rtx);
|
static bool attr_alt_subset_of_compl_p (rtx, rtx);
|
static void clear_struct_flag (rtx);
|
static void clear_struct_flag (rtx);
|
static void write_attr_valueq (struct attr_desc *, const char *);
|
static void write_attr_valueq (struct attr_desc *, const char *);
|
static struct attr_value *find_most_used (struct attr_desc *);
|
static struct attr_value *find_most_used (struct attr_desc *);
|
static void write_attr_set (struct attr_desc *, int, rtx,
|
static void write_attr_set (struct attr_desc *, int, rtx,
|
const char *, const char *, rtx,
|
const char *, const char *, rtx,
|
int, int);
|
int, int);
|
static void write_attr_case (struct attr_desc *, struct attr_value *,
|
static void write_attr_case (struct attr_desc *, struct attr_value *,
|
int, const char *, const char *, int, rtx);
|
int, const char *, const char *, int, rtx);
|
static void write_attr_value (struct attr_desc *, rtx);
|
static void write_attr_value (struct attr_desc *, rtx);
|
static void write_upcase (const char *);
|
static void write_upcase (const char *);
|
static void write_indent (int);
|
static void write_indent (int);
|
static rtx identity_fn (rtx);
|
static rtx identity_fn (rtx);
|
static rtx zero_fn (rtx);
|
static rtx zero_fn (rtx);
|
static rtx one_fn (rtx);
|
static rtx one_fn (rtx);
|
static rtx max_fn (rtx);
|
static rtx max_fn (rtx);
|
static rtx min_fn (rtx);
|
static rtx min_fn (rtx);
|
|
|
#define oballoc(T) XOBNEW (hash_obstack, T)
|
#define oballoc(T) XOBNEW (hash_obstack, T)
|
#define oballocvec(T, N) XOBNEWVEC (hash_obstack, T, (N))
|
#define oballocvec(T, N) XOBNEWVEC (hash_obstack, T, (N))
|
|
|
/* Hash table for sharing RTL and strings. */
|
/* Hash table for sharing RTL and strings. */
|
|
|
/* Each hash table slot is a bucket containing a chain of these structures.
|
/* Each hash table slot is a bucket containing a chain of these structures.
|
Strings are given negative hash codes; RTL expressions are given positive
|
Strings are given negative hash codes; RTL expressions are given positive
|
hash codes. */
|
hash codes. */
|
|
|
struct attr_hash
|
struct attr_hash
|
{
|
{
|
struct attr_hash *next; /* Next structure in the bucket. */
|
struct attr_hash *next; /* Next structure in the bucket. */
|
int hashcode; /* Hash code of this rtx or string. */
|
int hashcode; /* Hash code of this rtx or string. */
|
union
|
union
|
{
|
{
|
char *str; /* The string (negative hash codes) */
|
char *str; /* The string (negative hash codes) */
|
rtx rtl; /* or the RTL recorded here. */
|
rtx rtl; /* or the RTL recorded here. */
|
} u;
|
} u;
|
};
|
};
|
|
|
/* Now here is the hash table. When recording an RTL, it is added to
|
/* 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
|
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)
|
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
|
and for strings. While all these live in the same table, they are
|
completely independent, and the hash code is computed differently
|
completely independent, and the hash code is computed differently
|
for each. */
|
for each. */
|
|
|
#define RTL_HASH_SIZE 4093
|
#define RTL_HASH_SIZE 4093
|
static struct attr_hash *attr_hash_table[RTL_HASH_SIZE];
|
static struct attr_hash *attr_hash_table[RTL_HASH_SIZE];
|
|
|
/* Here is how primitive or already-shared RTL's hash
|
/* Here is how primitive or already-shared RTL's hash
|
codes are made. */
|
codes are made. */
|
#define RTL_HASH(RTL) ((intptr_t) (RTL) & 0777777)
|
#define RTL_HASH(RTL) ((intptr_t) (RTL) & 0777777)
|
|
|
/* Add an entry to the hash table for RTL with hash code HASHCODE. */
|
/* Add an entry to the hash table for RTL with hash code HASHCODE. */
|
|
|
static void
|
static void
|
attr_hash_add_rtx (int hashcode, rtx rtl)
|
attr_hash_add_rtx (int hashcode, rtx rtl)
|
{
|
{
|
struct attr_hash *h;
|
struct attr_hash *h;
|
|
|
h = XOBNEW (hash_obstack, struct attr_hash);
|
h = XOBNEW (hash_obstack, struct attr_hash);
|
h->hashcode = hashcode;
|
h->hashcode = hashcode;
|
h->u.rtl = rtl;
|
h->u.rtl = rtl;
|
h->next = attr_hash_table[hashcode % RTL_HASH_SIZE];
|
h->next = attr_hash_table[hashcode % RTL_HASH_SIZE];
|
attr_hash_table[hashcode % RTL_HASH_SIZE] = h;
|
attr_hash_table[hashcode % RTL_HASH_SIZE] = h;
|
}
|
}
|
|
|
/* Add an entry to the hash table for STRING with hash code HASHCODE. */
|
/* Add an entry to the hash table for STRING with hash code HASHCODE. */
|
|
|
static void
|
static void
|
attr_hash_add_string (int hashcode, char *str)
|
attr_hash_add_string (int hashcode, char *str)
|
{
|
{
|
struct attr_hash *h;
|
struct attr_hash *h;
|
|
|
h = XOBNEW (hash_obstack, struct attr_hash);
|
h = XOBNEW (hash_obstack, struct attr_hash);
|
h->hashcode = -hashcode;
|
h->hashcode = -hashcode;
|
h->u.str = str;
|
h->u.str = str;
|
h->next = attr_hash_table[hashcode % RTL_HASH_SIZE];
|
h->next = attr_hash_table[hashcode % RTL_HASH_SIZE];
|
attr_hash_table[hashcode % RTL_HASH_SIZE] = h;
|
attr_hash_table[hashcode % RTL_HASH_SIZE] = h;
|
}
|
}
|
|
|
/* Generate an RTL expression, but avoid duplicates.
|
/* Generate an RTL expression, but avoid duplicates.
|
Set the ATTR_PERMANENT_P flag for these permanent objects.
|
Set the ATTR_PERMANENT_P flag for these permanent objects.
|
|
|
In some cases we cannot uniquify; then we return an ordinary
|
In some cases we cannot uniquify; then we return an ordinary
|
impermanent rtx with ATTR_PERMANENT_P clear.
|
impermanent rtx with ATTR_PERMANENT_P clear.
|
|
|
Args are as follows:
|
Args are as follows:
|
|
|
rtx attr_rtx (code, [element1, ..., elementn]) */
|
rtx attr_rtx (code, [element1, ..., elementn]) */
|
|
|
static rtx
|
static rtx
|
attr_rtx_1 (enum rtx_code code, va_list p)
|
attr_rtx_1 (enum rtx_code code, va_list p)
|
{
|
{
|
rtx rt_val = NULL_RTX;/* RTX to return to caller... */
|
rtx rt_val = NULL_RTX;/* RTX to return to caller... */
|
int hashcode;
|
int hashcode;
|
struct attr_hash *h;
|
struct attr_hash *h;
|
struct obstack *old_obstack = rtl_obstack;
|
struct obstack *old_obstack = rtl_obstack;
|
|
|
/* For each of several cases, search the hash table for an existing entry.
|
/* 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
|
Use that entry if one is found; otherwise create a new RTL and add it
|
to the table. */
|
to the table. */
|
|
|
if (GET_RTX_CLASS (code) == RTX_UNARY)
|
if (GET_RTX_CLASS (code) == RTX_UNARY)
|
{
|
{
|
rtx arg0 = va_arg (p, rtx);
|
rtx arg0 = va_arg (p, rtx);
|
|
|
/* A permanent object cannot point to impermanent ones. */
|
/* A permanent object cannot point to impermanent ones. */
|
if (! ATTR_PERMANENT_P (arg0))
|
if (! ATTR_PERMANENT_P (arg0))
|
{
|
{
|
rt_val = rtx_alloc (code);
|
rt_val = rtx_alloc (code);
|
XEXP (rt_val, 0) = arg0;
|
XEXP (rt_val, 0) = arg0;
|
return rt_val;
|
return rt_val;
|
}
|
}
|
|
|
hashcode = ((HOST_WIDE_INT) code + RTL_HASH (arg0));
|
hashcode = ((HOST_WIDE_INT) code + RTL_HASH (arg0));
|
for (h = attr_hash_table[hashcode % RTL_HASH_SIZE]; h; h = h->next)
|
for (h = attr_hash_table[hashcode % RTL_HASH_SIZE]; h; h = h->next)
|
if (h->hashcode == hashcode
|
if (h->hashcode == hashcode
|
&& GET_CODE (h->u.rtl) == code
|
&& GET_CODE (h->u.rtl) == code
|
&& XEXP (h->u.rtl, 0) == arg0)
|
&& XEXP (h->u.rtl, 0) == arg0)
|
return h->u.rtl;
|
return h->u.rtl;
|
|
|
if (h == 0)
|
if (h == 0)
|
{
|
{
|
rtl_obstack = hash_obstack;
|
rtl_obstack = hash_obstack;
|
rt_val = rtx_alloc (code);
|
rt_val = rtx_alloc (code);
|
XEXP (rt_val, 0) = arg0;
|
XEXP (rt_val, 0) = arg0;
|
}
|
}
|
}
|
}
|
else if (GET_RTX_CLASS (code) == RTX_BIN_ARITH
|
else if (GET_RTX_CLASS (code) == RTX_BIN_ARITH
|
|| GET_RTX_CLASS (code) == RTX_COMM_ARITH
|
|| GET_RTX_CLASS (code) == RTX_COMM_ARITH
|
|| GET_RTX_CLASS (code) == RTX_COMPARE
|
|| GET_RTX_CLASS (code) == RTX_COMPARE
|
|| GET_RTX_CLASS (code) == RTX_COMM_COMPARE)
|
|| GET_RTX_CLASS (code) == RTX_COMM_COMPARE)
|
{
|
{
|
rtx arg0 = va_arg (p, rtx);
|
rtx arg0 = va_arg (p, rtx);
|
rtx arg1 = va_arg (p, rtx);
|
rtx arg1 = va_arg (p, rtx);
|
|
|
/* A permanent object cannot point to impermanent ones. */
|
/* A permanent object cannot point to impermanent ones. */
|
if (! ATTR_PERMANENT_P (arg0) || ! ATTR_PERMANENT_P (arg1))
|
if (! ATTR_PERMANENT_P (arg0) || ! ATTR_PERMANENT_P (arg1))
|
{
|
{
|
rt_val = rtx_alloc (code);
|
rt_val = rtx_alloc (code);
|
XEXP (rt_val, 0) = arg0;
|
XEXP (rt_val, 0) = arg0;
|
XEXP (rt_val, 1) = arg1;
|
XEXP (rt_val, 1) = arg1;
|
return rt_val;
|
return rt_val;
|
}
|
}
|
|
|
hashcode = ((HOST_WIDE_INT) code + RTL_HASH (arg0) + RTL_HASH (arg1));
|
hashcode = ((HOST_WIDE_INT) code + RTL_HASH (arg0) + RTL_HASH (arg1));
|
for (h = attr_hash_table[hashcode % RTL_HASH_SIZE]; h; h = h->next)
|
for (h = attr_hash_table[hashcode % RTL_HASH_SIZE]; h; h = h->next)
|
if (h->hashcode == hashcode
|
if (h->hashcode == hashcode
|
&& GET_CODE (h->u.rtl) == code
|
&& GET_CODE (h->u.rtl) == code
|
&& XEXP (h->u.rtl, 0) == arg0
|
&& XEXP (h->u.rtl, 0) == arg0
|
&& XEXP (h->u.rtl, 1) == arg1)
|
&& XEXP (h->u.rtl, 1) == arg1)
|
return h->u.rtl;
|
return h->u.rtl;
|
|
|
if (h == 0)
|
if (h == 0)
|
{
|
{
|
rtl_obstack = hash_obstack;
|
rtl_obstack = hash_obstack;
|
rt_val = rtx_alloc (code);
|
rt_val = rtx_alloc (code);
|
XEXP (rt_val, 0) = arg0;
|
XEXP (rt_val, 0) = arg0;
|
XEXP (rt_val, 1) = arg1;
|
XEXP (rt_val, 1) = arg1;
|
}
|
}
|
}
|
}
|
else if (GET_RTX_LENGTH (code) == 1
|
else if (GET_RTX_LENGTH (code) == 1
|
&& GET_RTX_FORMAT (code)[0] == 's')
|
&& GET_RTX_FORMAT (code)[0] == 's')
|
{
|
{
|
char *arg0 = va_arg (p, char *);
|
char *arg0 = va_arg (p, char *);
|
|
|
arg0 = DEF_ATTR_STRING (arg0);
|
arg0 = DEF_ATTR_STRING (arg0);
|
|
|
hashcode = ((HOST_WIDE_INT) code + RTL_HASH (arg0));
|
hashcode = ((HOST_WIDE_INT) code + RTL_HASH (arg0));
|
for (h = attr_hash_table[hashcode % RTL_HASH_SIZE]; h; h = h->next)
|
for (h = attr_hash_table[hashcode % RTL_HASH_SIZE]; h; h = h->next)
|
if (h->hashcode == hashcode
|
if (h->hashcode == hashcode
|
&& GET_CODE (h->u.rtl) == code
|
&& GET_CODE (h->u.rtl) == code
|
&& XSTR (h->u.rtl, 0) == arg0)
|
&& XSTR (h->u.rtl, 0) == arg0)
|
return h->u.rtl;
|
return h->u.rtl;
|
|
|
if (h == 0)
|
if (h == 0)
|
{
|
{
|
rtl_obstack = hash_obstack;
|
rtl_obstack = hash_obstack;
|
rt_val = rtx_alloc (code);
|
rt_val = rtx_alloc (code);
|
XSTR (rt_val, 0) = arg0;
|
XSTR (rt_val, 0) = arg0;
|
}
|
}
|
}
|
}
|
else if (GET_RTX_LENGTH (code) == 2
|
else if (GET_RTX_LENGTH (code) == 2
|
&& GET_RTX_FORMAT (code)[0] == 's'
|
&& GET_RTX_FORMAT (code)[0] == 's'
|
&& GET_RTX_FORMAT (code)[1] == 's')
|
&& GET_RTX_FORMAT (code)[1] == 's')
|
{
|
{
|
char *arg0 = va_arg (p, char *);
|
char *arg0 = va_arg (p, char *);
|
char *arg1 = va_arg (p, char *);
|
char *arg1 = va_arg (p, char *);
|
|
|
hashcode = ((HOST_WIDE_INT) code + RTL_HASH (arg0) + RTL_HASH (arg1));
|
hashcode = ((HOST_WIDE_INT) code + RTL_HASH (arg0) + RTL_HASH (arg1));
|
for (h = attr_hash_table[hashcode % RTL_HASH_SIZE]; h; h = h->next)
|
for (h = attr_hash_table[hashcode % RTL_HASH_SIZE]; h; h = h->next)
|
if (h->hashcode == hashcode
|
if (h->hashcode == hashcode
|
&& GET_CODE (h->u.rtl) == code
|
&& GET_CODE (h->u.rtl) == code
|
&& XSTR (h->u.rtl, 0) == arg0
|
&& XSTR (h->u.rtl, 0) == arg0
|
&& XSTR (h->u.rtl, 1) == arg1)
|
&& XSTR (h->u.rtl, 1) == arg1)
|
return h->u.rtl;
|
return h->u.rtl;
|
|
|
if (h == 0)
|
if (h == 0)
|
{
|
{
|
rtl_obstack = hash_obstack;
|
rtl_obstack = hash_obstack;
|
rt_val = rtx_alloc (code);
|
rt_val = rtx_alloc (code);
|
XSTR (rt_val, 0) = arg0;
|
XSTR (rt_val, 0) = arg0;
|
XSTR (rt_val, 1) = arg1;
|
XSTR (rt_val, 1) = arg1;
|
}
|
}
|
}
|
}
|
else if (code == CONST_INT)
|
else if (code == CONST_INT)
|
{
|
{
|
HOST_WIDE_INT arg0 = va_arg (p, HOST_WIDE_INT);
|
HOST_WIDE_INT arg0 = va_arg (p, HOST_WIDE_INT);
|
if (arg0 == 0)
|
if (arg0 == 0)
|
return false_rtx;
|
return false_rtx;
|
else if (arg0 == 1)
|
else if (arg0 == 1)
|
return true_rtx;
|
return true_rtx;
|
else
|
else
|
goto nohash;
|
goto nohash;
|
}
|
}
|
else
|
else
|
{
|
{
|
int i; /* Array indices... */
|
int i; /* Array indices... */
|
const char *fmt; /* Current rtx's format... */
|
const char *fmt; /* Current rtx's format... */
|
nohash:
|
nohash:
|
rt_val = rtx_alloc (code); /* Allocate the storage space. */
|
rt_val = rtx_alloc (code); /* Allocate the storage space. */
|
|
|
fmt = GET_RTX_FORMAT (code); /* Find the right format... */
|
fmt = GET_RTX_FORMAT (code); /* Find the right format... */
|
for (i = 0; i < GET_RTX_LENGTH (code); i++)
|
for (i = 0; i < GET_RTX_LENGTH (code); i++)
|
{
|
{
|
switch (*fmt++)
|
switch (*fmt++)
|
{
|
{
|
case '0': /* Unused field. */
|
case '0': /* Unused field. */
|
break;
|
break;
|
|
|
case 'i': /* An integer? */
|
case 'i': /* An integer? */
|
XINT (rt_val, i) = va_arg (p, int);
|
XINT (rt_val, i) = va_arg (p, int);
|
break;
|
break;
|
|
|
case 'w': /* A wide integer? */
|
case 'w': /* A wide integer? */
|
XWINT (rt_val, i) = va_arg (p, HOST_WIDE_INT);
|
XWINT (rt_val, i) = va_arg (p, HOST_WIDE_INT);
|
break;
|
break;
|
|
|
case 's': /* A string? */
|
case 's': /* A string? */
|
XSTR (rt_val, i) = va_arg (p, char *);
|
XSTR (rt_val, i) = va_arg (p, char *);
|
break;
|
break;
|
|
|
case 'e': /* An expression? */
|
case 'e': /* An expression? */
|
case 'u': /* An insn? Same except when printing. */
|
case 'u': /* An insn? Same except when printing. */
|
XEXP (rt_val, i) = va_arg (p, rtx);
|
XEXP (rt_val, i) = va_arg (p, rtx);
|
break;
|
break;
|
|
|
case 'E': /* An RTX vector? */
|
case 'E': /* An RTX vector? */
|
XVEC (rt_val, i) = va_arg (p, rtvec);
|
XVEC (rt_val, i) = va_arg (p, rtvec);
|
break;
|
break;
|
|
|
default:
|
default:
|
gcc_unreachable ();
|
gcc_unreachable ();
|
}
|
}
|
}
|
}
|
return rt_val;
|
return rt_val;
|
}
|
}
|
|
|
rtl_obstack = old_obstack;
|
rtl_obstack = old_obstack;
|
attr_hash_add_rtx (hashcode, rt_val);
|
attr_hash_add_rtx (hashcode, rt_val);
|
ATTR_PERMANENT_P (rt_val) = 1;
|
ATTR_PERMANENT_P (rt_val) = 1;
|
return rt_val;
|
return rt_val;
|
}
|
}
|
|
|
static rtx
|
static rtx
|
attr_rtx (enum rtx_code code, ...)
|
attr_rtx (enum rtx_code code, ...)
|
{
|
{
|
rtx result;
|
rtx result;
|
va_list p;
|
va_list p;
|
|
|
va_start (p, code);
|
va_start (p, code);
|
result = attr_rtx_1 (code, p);
|
result = attr_rtx_1 (code, p);
|
va_end (p);
|
va_end (p);
|
return result;
|
return result;
|
}
|
}
|
|
|
/* Create a new string printed with the printf line arguments into a space
|
/* Create a new string printed with the printf line arguments into a space
|
of at most LEN bytes:
|
of at most LEN bytes:
|
|
|
rtx attr_printf (len, format, [arg1, ..., argn]) */
|
rtx attr_printf (len, format, [arg1, ..., argn]) */
|
|
|
static char *
|
static char *
|
attr_printf (unsigned int len, const char *fmt, ...)
|
attr_printf (unsigned int len, const char *fmt, ...)
|
{
|
{
|
char str[256];
|
char str[256];
|
va_list p;
|
va_list p;
|
|
|
va_start (p, fmt);
|
va_start (p, fmt);
|
|
|
gcc_assert (len < sizeof str); /* Leave room for \0. */
|
gcc_assert (len < sizeof str); /* Leave room for \0. */
|
|
|
vsprintf (str, fmt, p);
|
vsprintf (str, fmt, p);
|
va_end (p);
|
va_end (p);
|
|
|
return DEF_ATTR_STRING (str);
|
return DEF_ATTR_STRING (str);
|
}
|
}
|
|
|
static rtx
|
static rtx
|
attr_eq (const char *name, const char *value)
|
attr_eq (const char *name, const char *value)
|
{
|
{
|
return attr_rtx (EQ_ATTR, DEF_ATTR_STRING (name), DEF_ATTR_STRING (value));
|
return attr_rtx (EQ_ATTR, DEF_ATTR_STRING (name), DEF_ATTR_STRING (value));
|
}
|
}
|
|
|
static const char *
|
static const char *
|
attr_numeral (int n)
|
attr_numeral (int n)
|
{
|
{
|
return XSTR (make_numeric_value (n), 0);
|
return XSTR (make_numeric_value (n), 0);
|
}
|
}
|
|
|
/* Return a permanent (possibly shared) copy of a string STR (not assumed
|
/* Return a permanent (possibly shared) copy of a string STR (not assumed
|
to be null terminated) with LEN bytes. */
|
to be null terminated) with LEN bytes. */
|
|
|
static char *
|
static char *
|
attr_string (const char *str, int len)
|
attr_string (const char *str, int len)
|
{
|
{
|
struct attr_hash *h;
|
struct attr_hash *h;
|
int hashcode;
|
int hashcode;
|
int i;
|
int i;
|
char *new_str;
|
char *new_str;
|
|
|
/* Compute the hash code. */
|
/* Compute the hash code. */
|
hashcode = (len + 1) * 613 + (unsigned) str[0];
|
hashcode = (len + 1) * 613 + (unsigned) str[0];
|
for (i = 1; i < len; i += 2)
|
for (i = 1; i < len; i += 2)
|
hashcode = ((hashcode * 613) + (unsigned) str[i]);
|
hashcode = ((hashcode * 613) + (unsigned) str[i]);
|
if (hashcode < 0)
|
if (hashcode < 0)
|
hashcode = -hashcode;
|
hashcode = -hashcode;
|
|
|
/* Search the table for the string. */
|
/* Search the table for the string. */
|
for (h = attr_hash_table[hashcode % RTL_HASH_SIZE]; h; h = h->next)
|
for (h = attr_hash_table[hashcode % RTL_HASH_SIZE]; h; h = h->next)
|
if (h->hashcode == -hashcode && h->u.str[0] == str[0]
|
if (h->hashcode == -hashcode && h->u.str[0] == str[0]
|
&& !strncmp (h->u.str, str, len))
|
&& !strncmp (h->u.str, str, len))
|
return h->u.str; /* <-- return if found. */
|
return h->u.str; /* <-- return if found. */
|
|
|
/* Not found; create a permanent copy and add it to the hash table. */
|
/* Not found; create a permanent copy and add it to the hash table. */
|
new_str = XOBNEWVAR (hash_obstack, char, len + 1);
|
new_str = XOBNEWVAR (hash_obstack, char, len + 1);
|
memcpy (new_str, str, len);
|
memcpy (new_str, str, len);
|
new_str[len] = '\0';
|
new_str[len] = '\0';
|
attr_hash_add_string (hashcode, new_str);
|
attr_hash_add_string (hashcode, new_str);
|
|
|
return new_str; /* Return the new string. */
|
return new_str; /* Return the new string. */
|
}
|
}
|
|
|
/* Check two rtx's for equality of contents,
|
/* Check two rtx's for equality of contents,
|
taking advantage of the fact that if both are hashed
|
taking advantage of the fact that if both are hashed
|
then they can't be equal unless they are the same object. */
|
then they can't be equal unless they are the same object. */
|
|
|
static int
|
static int
|
attr_equal_p (rtx x, rtx y)
|
attr_equal_p (rtx x, rtx y)
|
{
|
{
|
return (x == y || (! (ATTR_PERMANENT_P (x) && ATTR_PERMANENT_P (y))
|
return (x == y || (! (ATTR_PERMANENT_P (x) && ATTR_PERMANENT_P (y))
|
&& rtx_equal_p (x, y)));
|
&& rtx_equal_p (x, y)));
|
}
|
}
|
|
|
/* Copy an attribute value expression,
|
/* Copy an attribute value expression,
|
descending to all depths, but not copying any
|
descending to all depths, but not copying any
|
permanent hashed subexpressions. */
|
permanent hashed subexpressions. */
|
|
|
static rtx
|
static rtx
|
attr_copy_rtx (rtx orig)
|
attr_copy_rtx (rtx orig)
|
{
|
{
|
rtx copy;
|
rtx copy;
|
int i, j;
|
int i, j;
|
RTX_CODE code;
|
RTX_CODE code;
|
const char *format_ptr;
|
const char *format_ptr;
|
|
|
/* No need to copy a permanent object. */
|
/* No need to copy a permanent object. */
|
if (ATTR_PERMANENT_P (orig))
|
if (ATTR_PERMANENT_P (orig))
|
return orig;
|
return orig;
|
|
|
code = GET_CODE (orig);
|
code = GET_CODE (orig);
|
|
|
switch (code)
|
switch (code)
|
{
|
{
|
case REG:
|
case REG:
|
case CONST_INT:
|
case CONST_INT:
|
case CONST_DOUBLE:
|
case CONST_DOUBLE:
|
case CONST_VECTOR:
|
case CONST_VECTOR:
|
case SYMBOL_REF:
|
case SYMBOL_REF:
|
case CODE_LABEL:
|
case CODE_LABEL:
|
case PC:
|
case PC:
|
case CC0:
|
case CC0:
|
return orig;
|
return orig;
|
|
|
default:
|
default:
|
break;
|
break;
|
}
|
}
|
|
|
copy = rtx_alloc (code);
|
copy = rtx_alloc (code);
|
PUT_MODE (copy, GET_MODE (orig));
|
PUT_MODE (copy, GET_MODE (orig));
|
ATTR_IND_SIMPLIFIED_P (copy) = ATTR_IND_SIMPLIFIED_P (orig);
|
ATTR_IND_SIMPLIFIED_P (copy) = ATTR_IND_SIMPLIFIED_P (orig);
|
ATTR_CURR_SIMPLIFIED_P (copy) = ATTR_CURR_SIMPLIFIED_P (orig);
|
ATTR_CURR_SIMPLIFIED_P (copy) = ATTR_CURR_SIMPLIFIED_P (orig);
|
ATTR_PERMANENT_P (copy) = ATTR_PERMANENT_P (orig);
|
ATTR_PERMANENT_P (copy) = ATTR_PERMANENT_P (orig);
|
|
|
format_ptr = GET_RTX_FORMAT (GET_CODE (copy));
|
format_ptr = GET_RTX_FORMAT (GET_CODE (copy));
|
|
|
for (i = 0; i < GET_RTX_LENGTH (GET_CODE (copy)); i++)
|
for (i = 0; i < GET_RTX_LENGTH (GET_CODE (copy)); i++)
|
{
|
{
|
switch (*format_ptr++)
|
switch (*format_ptr++)
|
{
|
{
|
case 'e':
|
case 'e':
|
XEXP (copy, i) = XEXP (orig, i);
|
XEXP (copy, i) = XEXP (orig, i);
|
if (XEXP (orig, i) != NULL)
|
if (XEXP (orig, i) != NULL)
|
XEXP (copy, i) = attr_copy_rtx (XEXP (orig, i));
|
XEXP (copy, i) = attr_copy_rtx (XEXP (orig, i));
|
break;
|
break;
|
|
|
case 'E':
|
case 'E':
|
case 'V':
|
case 'V':
|
XVEC (copy, i) = XVEC (orig, i);
|
XVEC (copy, i) = XVEC (orig, i);
|
if (XVEC (orig, i) != NULL)
|
if (XVEC (orig, i) != NULL)
|
{
|
{
|
XVEC (copy, i) = rtvec_alloc (XVECLEN (orig, i));
|
XVEC (copy, i) = rtvec_alloc (XVECLEN (orig, i));
|
for (j = 0; j < XVECLEN (copy, i); j++)
|
for (j = 0; j < XVECLEN (copy, i); j++)
|
XVECEXP (copy, i, j) = attr_copy_rtx (XVECEXP (orig, i, j));
|
XVECEXP (copy, i, j) = attr_copy_rtx (XVECEXP (orig, i, j));
|
}
|
}
|
break;
|
break;
|
|
|
case 'n':
|
case 'n':
|
case 'i':
|
case 'i':
|
XINT (copy, i) = XINT (orig, i);
|
XINT (copy, i) = XINT (orig, i);
|
break;
|
break;
|
|
|
case 'w':
|
case 'w':
|
XWINT (copy, i) = XWINT (orig, i);
|
XWINT (copy, i) = XWINT (orig, i);
|
break;
|
break;
|
|
|
case 's':
|
case 's':
|
case 'S':
|
case 'S':
|
XSTR (copy, i) = XSTR (orig, i);
|
XSTR (copy, i) = XSTR (orig, i);
|
break;
|
break;
|
|
|
default:
|
default:
|
gcc_unreachable ();
|
gcc_unreachable ();
|
}
|
}
|
}
|
}
|
return copy;
|
return copy;
|
}
|
}
|
|
|
/* Given a test expression for an attribute, ensure it is validly formed.
|
/* Given a test expression for an attribute, ensure it is validly formed.
|
IS_CONST indicates whether the expression is constant for each compiler
|
IS_CONST indicates whether the expression is constant for each compiler
|
run (a constant expression may not test any particular insn).
|
run (a constant expression may not test any particular insn).
|
|
|
Convert (eq_attr "att" "a1,a2") to (ior (eq_attr ... ) (eq_attrq ..))
|
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
|
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.
|
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
|
Update the string address in EQ_ATTR expression to be the same used
|
in the attribute (or `alternative_name') to speed up subsequent
|
in the attribute (or `alternative_name') to speed up subsequent
|
`find_attr' calls and eliminate most `strcmp' calls.
|
`find_attr' calls and eliminate most `strcmp' calls.
|
|
|
Return the new expression, if any. */
|
Return the new expression, if any. */
|
|
|
static rtx
|
static rtx
|
check_attr_test (rtx exp, int is_const, int lineno)
|
check_attr_test (rtx exp, int is_const, int lineno)
|
{
|
{
|
struct attr_desc *attr;
|
struct attr_desc *attr;
|
struct attr_value *av;
|
struct attr_value *av;
|
const char *name_ptr, *p;
|
const char *name_ptr, *p;
|
rtx orexp, newexp;
|
rtx orexp, newexp;
|
|
|
switch (GET_CODE (exp))
|
switch (GET_CODE (exp))
|
{
|
{
|
case EQ_ATTR:
|
case EQ_ATTR:
|
/* Handle negation test. */
|
/* Handle negation test. */
|
if (XSTR (exp, 1)[0] == '!')
|
if (XSTR (exp, 1)[0] == '!')
|
return check_attr_test (attr_rtx (NOT,
|
return check_attr_test (attr_rtx (NOT,
|
attr_eq (XSTR (exp, 0),
|
attr_eq (XSTR (exp, 0),
|
&XSTR (exp, 1)[1])),
|
&XSTR (exp, 1)[1])),
|
is_const, lineno);
|
is_const, lineno);
|
|
|
else if (n_comma_elts (XSTR (exp, 1)) == 1)
|
else if (n_comma_elts (XSTR (exp, 1)) == 1)
|
{
|
{
|
attr = find_attr (&XSTR (exp, 0), 0);
|
attr = find_attr (&XSTR (exp, 0), 0);
|
if (attr == NULL)
|
if (attr == NULL)
|
{
|
{
|
if (! strcmp (XSTR (exp, 0), "alternative"))
|
if (! strcmp (XSTR (exp, 0), "alternative"))
|
return mk_attr_alt (1 << atoi (XSTR (exp, 1)));
|
return mk_attr_alt (1 << atoi (XSTR (exp, 1)));
|
else
|
else
|
fatal ("unknown attribute `%s' in EQ_ATTR", XSTR (exp, 0));
|
fatal ("unknown attribute `%s' in EQ_ATTR", XSTR (exp, 0));
|
}
|
}
|
|
|
if (is_const && ! attr->is_const)
|
if (is_const && ! attr->is_const)
|
fatal ("constant expression uses insn attribute `%s' in EQ_ATTR",
|
fatal ("constant expression uses insn attribute `%s' in EQ_ATTR",
|
XSTR (exp, 0));
|
XSTR (exp, 0));
|
|
|
/* Copy this just to make it permanent,
|
/* Copy this just to make it permanent,
|
so expressions using it can be permanent too. */
|
so expressions using it can be permanent too. */
|
exp = attr_eq (XSTR (exp, 0), XSTR (exp, 1));
|
exp = attr_eq (XSTR (exp, 0), XSTR (exp, 1));
|
|
|
/* It shouldn't be possible to simplify the value given to a
|
/* It shouldn't be possible to simplify the value given to a
|
constant attribute, so don't expand this until it's time to
|
constant attribute, so don't expand this until it's time to
|
write the test expression. */
|
write the test expression. */
|
if (attr->is_const)
|
if (attr->is_const)
|
ATTR_IND_SIMPLIFIED_P (exp) = 1;
|
ATTR_IND_SIMPLIFIED_P (exp) = 1;
|
|
|
if (attr->is_numeric)
|
if (attr->is_numeric)
|
{
|
{
|
for (p = XSTR (exp, 1); *p; p++)
|
for (p = XSTR (exp, 1); *p; p++)
|
if (! ISDIGIT (*p))
|
if (! ISDIGIT (*p))
|
fatal ("attribute `%s' takes only numeric values",
|
fatal ("attribute `%s' takes only numeric values",
|
XSTR (exp, 0));
|
XSTR (exp, 0));
|
}
|
}
|
else
|
else
|
{
|
{
|
for (av = attr->first_value; av; av = av->next)
|
for (av = attr->first_value; av; av = av->next)
|
if (GET_CODE (av->value) == CONST_STRING
|
if (GET_CODE (av->value) == CONST_STRING
|
&& ! strcmp (XSTR (exp, 1), XSTR (av->value, 0)))
|
&& ! strcmp (XSTR (exp, 1), XSTR (av->value, 0)))
|
break;
|
break;
|
|
|
if (av == NULL)
|
if (av == NULL)
|
fatal ("unknown value `%s' for `%s' attribute",
|
fatal ("unknown value `%s' for `%s' attribute",
|
XSTR (exp, 1), XSTR (exp, 0));
|
XSTR (exp, 1), XSTR (exp, 0));
|
}
|
}
|
}
|
}
|
else
|
else
|
{
|
{
|
if (! strcmp (XSTR (exp, 0), "alternative"))
|
if (! strcmp (XSTR (exp, 0), "alternative"))
|
{
|
{
|
int set = 0;
|
int set = 0;
|
|
|
name_ptr = XSTR (exp, 1);
|
name_ptr = XSTR (exp, 1);
|
while ((p = next_comma_elt (&name_ptr)) != NULL)
|
while ((p = next_comma_elt (&name_ptr)) != NULL)
|
set |= 1 << atoi (p);
|
set |= 1 << atoi (p);
|
|
|
return mk_attr_alt (set);
|
return mk_attr_alt (set);
|
}
|
}
|
else
|
else
|
{
|
{
|
/* Make an IOR tree of the possible values. */
|
/* Make an IOR tree of the possible values. */
|
orexp = false_rtx;
|
orexp = false_rtx;
|
name_ptr = XSTR (exp, 1);
|
name_ptr = XSTR (exp, 1);
|
while ((p = next_comma_elt (&name_ptr)) != NULL)
|
while ((p = next_comma_elt (&name_ptr)) != NULL)
|
{
|
{
|
newexp = attr_eq (XSTR (exp, 0), p);
|
newexp = attr_eq (XSTR (exp, 0), p);
|
orexp = insert_right_side (IOR, orexp, newexp, -2, -2);
|
orexp = insert_right_side (IOR, orexp, newexp, -2, -2);
|
}
|
}
|
|
|
return check_attr_test (orexp, is_const, lineno);
|
return check_attr_test (orexp, is_const, lineno);
|
}
|
}
|
}
|
}
|
break;
|
break;
|
|
|
case ATTR_FLAG:
|
case ATTR_FLAG:
|
break;
|
break;
|
|
|
case CONST_INT:
|
case CONST_INT:
|
/* Either TRUE or FALSE. */
|
/* Either TRUE or FALSE. */
|
if (XWINT (exp, 0))
|
if (XWINT (exp, 0))
|
return true_rtx;
|
return true_rtx;
|
else
|
else
|
return false_rtx;
|
return false_rtx;
|
|
|
case IOR:
|
case IOR:
|
case AND:
|
case AND:
|
XEXP (exp, 0) = check_attr_test (XEXP (exp, 0), is_const, lineno);
|
XEXP (exp, 0) = check_attr_test (XEXP (exp, 0), is_const, lineno);
|
XEXP (exp, 1) = check_attr_test (XEXP (exp, 1), is_const, lineno);
|
XEXP (exp, 1) = check_attr_test (XEXP (exp, 1), is_const, lineno);
|
break;
|
break;
|
|
|
case NOT:
|
case NOT:
|
XEXP (exp, 0) = check_attr_test (XEXP (exp, 0), is_const, lineno);
|
XEXP (exp, 0) = check_attr_test (XEXP (exp, 0), is_const, lineno);
|
break;
|
break;
|
|
|
case MATCH_OPERAND:
|
case MATCH_OPERAND:
|
if (is_const)
|
if (is_const)
|
fatal ("RTL operator \"%s\" not valid in constant attribute test",
|
fatal ("RTL operator \"%s\" not valid in constant attribute test",
|
GET_RTX_NAME (GET_CODE (exp)));
|
GET_RTX_NAME (GET_CODE (exp)));
|
/* These cases can't be simplified. */
|
/* These cases can't be simplified. */
|
ATTR_IND_SIMPLIFIED_P (exp) = 1;
|
ATTR_IND_SIMPLIFIED_P (exp) = 1;
|
break;
|
break;
|
|
|
case LE: case LT: case GT: case GE:
|
case LE: case LT: case GT: case GE:
|
case LEU: case LTU: case GTU: case GEU:
|
case LEU: case LTU: case GTU: case GEU:
|
case NE: case EQ:
|
case NE: case EQ:
|
if (GET_CODE (XEXP (exp, 0)) == SYMBOL_REF
|
if (GET_CODE (XEXP (exp, 0)) == SYMBOL_REF
|
&& GET_CODE (XEXP (exp, 1)) == SYMBOL_REF)
|
&& GET_CODE (XEXP (exp, 1)) == SYMBOL_REF)
|
exp = attr_rtx (GET_CODE (exp),
|
exp = attr_rtx (GET_CODE (exp),
|
attr_rtx (SYMBOL_REF, XSTR (XEXP (exp, 0), 0)),
|
attr_rtx (SYMBOL_REF, XSTR (XEXP (exp, 0), 0)),
|
attr_rtx (SYMBOL_REF, XSTR (XEXP (exp, 1), 0)));
|
attr_rtx (SYMBOL_REF, XSTR (XEXP (exp, 1), 0)));
|
/* These cases can't be simplified. */
|
/* These cases can't be simplified. */
|
ATTR_IND_SIMPLIFIED_P (exp) = 1;
|
ATTR_IND_SIMPLIFIED_P (exp) = 1;
|
break;
|
break;
|
|
|
case SYMBOL_REF:
|
case SYMBOL_REF:
|
if (is_const)
|
if (is_const)
|
{
|
{
|
/* These cases are valid for constant attributes, but can't be
|
/* These cases are valid for constant attributes, but can't be
|
simplified. */
|
simplified. */
|
exp = attr_rtx (SYMBOL_REF, XSTR (exp, 0));
|
exp = attr_rtx (SYMBOL_REF, XSTR (exp, 0));
|
ATTR_IND_SIMPLIFIED_P (exp) = 1;
|
ATTR_IND_SIMPLIFIED_P (exp) = 1;
|
break;
|
break;
|
}
|
}
|
default:
|
default:
|
fatal ("RTL operator \"%s\" not valid in attribute test",
|
fatal ("RTL operator \"%s\" not valid in attribute test",
|
GET_RTX_NAME (GET_CODE (exp)));
|
GET_RTX_NAME (GET_CODE (exp)));
|
}
|
}
|
|
|
return exp;
|
return exp;
|
}
|
}
|
|
|
/* Given an expression, ensure that it is validly formed and that all named
|
/* 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
|
attribute values are valid for the given attribute. Issue a fatal error
|
if not. If no attribute is specified, assume a numeric attribute.
|
if not. If no attribute is specified, assume a numeric attribute.
|
|
|
Return a perhaps modified replacement expression for the value. */
|
Return a perhaps modified replacement expression for the value. */
|
|
|
static rtx
|
static rtx
|
check_attr_value (rtx exp, struct attr_desc *attr)
|
check_attr_value (rtx exp, struct attr_desc *attr)
|
{
|
{
|
struct attr_value *av;
|
struct attr_value *av;
|
const char *p;
|
const char *p;
|
int i;
|
int i;
|
|
|
switch (GET_CODE (exp))
|
switch (GET_CODE (exp))
|
{
|
{
|
case CONST_INT:
|
case CONST_INT:
|
if (attr && ! attr->is_numeric)
|
if (attr && ! attr->is_numeric)
|
{
|
{
|
message_with_line (attr->lineno,
|
message_with_line (attr->lineno,
|
"CONST_INT not valid for non-numeric attribute %s",
|
"CONST_INT not valid for non-numeric attribute %s",
|
attr->name);
|
attr->name);
|
have_error = 1;
|
have_error = 1;
|
break;
|
break;
|
}
|
}
|
|
|
if (INTVAL (exp) < 0)
|
if (INTVAL (exp) < 0)
|
{
|
{
|
message_with_line (attr->lineno,
|
message_with_line (attr->lineno,
|
"negative numeric value specified for attribute %s",
|
"negative numeric value specified for attribute %s",
|
attr->name);
|
attr->name);
|
have_error = 1;
|
have_error = 1;
|
break;
|
break;
|
}
|
}
|
break;
|
break;
|
|
|
case CONST_STRING:
|
case CONST_STRING:
|
if (! strcmp (XSTR (exp, 0), "*"))
|
if (! strcmp (XSTR (exp, 0), "*"))
|
break;
|
break;
|
|
|
if (attr == 0 || attr->is_numeric)
|
if (attr == 0 || attr->is_numeric)
|
{
|
{
|
p = XSTR (exp, 0);
|
p = XSTR (exp, 0);
|
for (; *p; p++)
|
for (; *p; p++)
|
if (! ISDIGIT (*p))
|
if (! ISDIGIT (*p))
|
{
|
{
|
message_with_line (attr ? attr->lineno : 0,
|
message_with_line (attr ? attr->lineno : 0,
|
"non-numeric value for numeric attribute %s",
|
"non-numeric value for numeric attribute %s",
|
attr ? attr->name : "internal");
|
attr ? attr->name : "internal");
|
have_error = 1;
|
have_error = 1;
|
break;
|
break;
|
}
|
}
|
break;
|
break;
|
}
|
}
|
|
|
for (av = attr->first_value; av; av = av->next)
|
for (av = attr->first_value; av; av = av->next)
|
if (GET_CODE (av->value) == CONST_STRING
|
if (GET_CODE (av->value) == CONST_STRING
|
&& ! strcmp (XSTR (av->value, 0), XSTR (exp, 0)))
|
&& ! strcmp (XSTR (av->value, 0), XSTR (exp, 0)))
|
break;
|
break;
|
|
|
if (av == NULL)
|
if (av == NULL)
|
{
|
{
|
message_with_line (attr->lineno,
|
message_with_line (attr->lineno,
|
"unknown value `%s' for `%s' attribute",
|
"unknown value `%s' for `%s' attribute",
|
XSTR (exp, 0), attr ? attr->name : "internal");
|
XSTR (exp, 0), attr ? attr->name : "internal");
|
have_error = 1;
|
have_error = 1;
|
}
|
}
|
break;
|
break;
|
|
|
case IF_THEN_ELSE:
|
case IF_THEN_ELSE:
|
XEXP (exp, 0) = check_attr_test (XEXP (exp, 0),
|
XEXP (exp, 0) = check_attr_test (XEXP (exp, 0),
|
attr ? attr->is_const : 0,
|
attr ? attr->is_const : 0,
|
attr ? attr->lineno : 0);
|
attr ? attr->lineno : 0);
|
XEXP (exp, 1) = check_attr_value (XEXP (exp, 1), attr);
|
XEXP (exp, 1) = check_attr_value (XEXP (exp, 1), attr);
|
XEXP (exp, 2) = check_attr_value (XEXP (exp, 2), attr);
|
XEXP (exp, 2) = check_attr_value (XEXP (exp, 2), attr);
|
break;
|
break;
|
|
|
case PLUS:
|
case PLUS:
|
case MINUS:
|
case MINUS:
|
case MULT:
|
case MULT:
|
case DIV:
|
case DIV:
|
case MOD:
|
case MOD:
|
if (attr && !attr->is_numeric)
|
if (attr && !attr->is_numeric)
|
{
|
{
|
message_with_line (attr->lineno,
|
message_with_line (attr->lineno,
|
"invalid operation `%s' for non-numeric attribute value",
|
"invalid operation `%s' for non-numeric attribute value",
|
GET_RTX_NAME (GET_CODE (exp)));
|
GET_RTX_NAME (GET_CODE (exp)));
|
have_error = 1;
|
have_error = 1;
|
break;
|
break;
|
}
|
}
|
/* Fall through. */
|
/* Fall through. */
|
|
|
case IOR:
|
case IOR:
|
case AND:
|
case AND:
|
XEXP (exp, 0) = check_attr_value (XEXP (exp, 0), attr);
|
XEXP (exp, 0) = check_attr_value (XEXP (exp, 0), attr);
|
XEXP (exp, 1) = check_attr_value (XEXP (exp, 1), attr);
|
XEXP (exp, 1) = check_attr_value (XEXP (exp, 1), attr);
|
break;
|
break;
|
|
|
case FFS:
|
case FFS:
|
case CLZ:
|
case CLZ:
|
case CTZ:
|
case CTZ:
|
case POPCOUNT:
|
case POPCOUNT:
|
case PARITY:
|
case PARITY:
|
case BSWAP:
|
case BSWAP:
|
XEXP (exp, 0) = check_attr_value (XEXP (exp, 0), attr);
|
XEXP (exp, 0) = check_attr_value (XEXP (exp, 0), attr);
|
break;
|
break;
|
|
|
case COND:
|
case COND:
|
if (XVECLEN (exp, 0) % 2 != 0)
|
if (XVECLEN (exp, 0) % 2 != 0)
|
{
|
{
|
message_with_line (attr->lineno,
|
message_with_line (attr->lineno,
|
"first operand of COND must have even length");
|
"first operand of COND must have even length");
|
have_error = 1;
|
have_error = 1;
|
break;
|
break;
|
}
|
}
|
|
|
for (i = 0; i < XVECLEN (exp, 0); i += 2)
|
for (i = 0; i < XVECLEN (exp, 0); i += 2)
|
{
|
{
|
XVECEXP (exp, 0, i) = check_attr_test (XVECEXP (exp, 0, i),
|
XVECEXP (exp, 0, i) = check_attr_test (XVECEXP (exp, 0, i),
|
attr ? attr->is_const : 0,
|
attr ? attr->is_const : 0,
|
attr ? attr->lineno : 0);
|
attr ? attr->lineno : 0);
|
XVECEXP (exp, 0, i + 1)
|
XVECEXP (exp, 0, i + 1)
|
= check_attr_value (XVECEXP (exp, 0, i + 1), attr);
|
= check_attr_value (XVECEXP (exp, 0, i + 1), attr);
|
}
|
}
|
|
|
XEXP (exp, 1) = check_attr_value (XEXP (exp, 1), attr);
|
XEXP (exp, 1) = check_attr_value (XEXP (exp, 1), attr);
|
break;
|
break;
|
|
|
case ATTR:
|
case ATTR:
|
{
|
{
|
struct attr_desc *attr2 = find_attr (&XSTR (exp, 0), 0);
|
struct attr_desc *attr2 = find_attr (&XSTR (exp, 0), 0);
|
if (attr2 == NULL)
|
if (attr2 == NULL)
|
{
|
{
|
message_with_line (attr ? attr->lineno : 0,
|
message_with_line (attr ? attr->lineno : 0,
|
"unknown attribute `%s' in ATTR",
|
"unknown attribute `%s' in ATTR",
|
XSTR (exp, 0));
|
XSTR (exp, 0));
|
have_error = 1;
|
have_error = 1;
|
}
|
}
|
else if (attr && attr->is_const && ! attr2->is_const)
|
else if (attr && attr->is_const && ! attr2->is_const)
|
{
|
{
|
message_with_line (attr->lineno,
|
message_with_line (attr->lineno,
|
"non-constant attribute `%s' referenced from `%s'",
|
"non-constant attribute `%s' referenced from `%s'",
|
XSTR (exp, 0), attr->name);
|
XSTR (exp, 0), attr->name);
|
have_error = 1;
|
have_error = 1;
|
}
|
}
|
else if (attr
|
else if (attr
|
&& attr->is_numeric != attr2->is_numeric)
|
&& attr->is_numeric != attr2->is_numeric)
|
{
|
{
|
message_with_line (attr->lineno,
|
message_with_line (attr->lineno,
|
"numeric attribute mismatch calling `%s' from `%s'",
|
"numeric attribute mismatch calling `%s' from `%s'",
|
XSTR (exp, 0), attr->name);
|
XSTR (exp, 0), attr->name);
|
have_error = 1;
|
have_error = 1;
|
}
|
}
|
}
|
}
|
break;
|
break;
|
|
|
case SYMBOL_REF:
|
case SYMBOL_REF:
|
/* A constant SYMBOL_REF is valid as a constant attribute test and
|
/* A constant SYMBOL_REF is valid as a constant attribute test and
|
is expanded later by make_canonical into a COND. In a non-constant
|
is expanded later by make_canonical into a COND. In a non-constant
|
attribute test, it is left be. */
|
attribute test, it is left be. */
|
return attr_rtx (SYMBOL_REF, XSTR (exp, 0));
|
return attr_rtx (SYMBOL_REF, XSTR (exp, 0));
|
|
|
default:
|
default:
|
message_with_line (attr ? attr->lineno : 0,
|
message_with_line (attr ? attr->lineno : 0,
|
"invalid operation `%s' for attribute value",
|
"invalid operation `%s' for attribute value",
|
GET_RTX_NAME (GET_CODE (exp)));
|
GET_RTX_NAME (GET_CODE (exp)));
|
have_error = 1;
|
have_error = 1;
|
break;
|
break;
|
}
|
}
|
|
|
return exp;
|
return exp;
|
}
|
}
|
|
|
/* Given an SET_ATTR_ALTERNATIVE expression, convert to the canonical SET.
|
/* Given an SET_ATTR_ALTERNATIVE expression, convert to the canonical SET.
|
It becomes a COND with each test being (eq_attr "alternative" "n") */
|
It becomes a COND with each test being (eq_attr "alternative" "n") */
|
|
|
static rtx
|
static rtx
|
convert_set_attr_alternative (rtx exp, struct insn_def *id)
|
convert_set_attr_alternative (rtx exp, struct insn_def *id)
|
{
|
{
|
int num_alt = id->num_alternatives;
|
int num_alt = id->num_alternatives;
|
rtx condexp;
|
rtx condexp;
|
int i;
|
int i;
|
|
|
if (XVECLEN (exp, 1) != num_alt)
|
if (XVECLEN (exp, 1) != num_alt)
|
{
|
{
|
message_with_line (id->lineno,
|
message_with_line (id->lineno,
|
"bad number of entries in SET_ATTR_ALTERNATIVE");
|
"bad number of entries in SET_ATTR_ALTERNATIVE");
|
have_error = 1;
|
have_error = 1;
|
return NULL_RTX;
|
return NULL_RTX;
|
}
|
}
|
|
|
/* Make a COND with all tests but the last. Select the last value via the
|
/* Make a COND with all tests but the last. Select the last value via the
|
default. */
|
default. */
|
condexp = rtx_alloc (COND);
|
condexp = rtx_alloc (COND);
|
XVEC (condexp, 0) = rtvec_alloc ((num_alt - 1) * 2);
|
XVEC (condexp, 0) = rtvec_alloc ((num_alt - 1) * 2);
|
|
|
for (i = 0; i < num_alt - 1; i++)
|
for (i = 0; i < num_alt - 1; i++)
|
{
|
{
|
const char *p;
|
const char *p;
|
p = attr_numeral (i);
|
p = attr_numeral (i);
|
|
|
XVECEXP (condexp, 0, 2 * i) = attr_eq (alternative_name, p);
|
XVECEXP (condexp, 0, 2 * i) = attr_eq (alternative_name, p);
|
XVECEXP (condexp, 0, 2 * i + 1) = XVECEXP (exp, 1, i);
|
XVECEXP (condexp, 0, 2 * i + 1) = XVECEXP (exp, 1, i);
|
}
|
}
|
|
|
XEXP (condexp, 1) = XVECEXP (exp, 1, i);
|
XEXP (condexp, 1) = XVECEXP (exp, 1, i);
|
|
|
return attr_rtx (SET, attr_rtx (ATTR, XSTR (exp, 0)), condexp);
|
return attr_rtx (SET, attr_rtx (ATTR, XSTR (exp, 0)), condexp);
|
}
|
}
|
|
|
/* Given a SET_ATTR, convert to the appropriate SET. If a comma-separated
|
/* Given a SET_ATTR, convert to the appropriate SET. If a comma-separated
|
list of values is given, convert to SET_ATTR_ALTERNATIVE first. */
|
list of values is given, convert to SET_ATTR_ALTERNATIVE first. */
|
|
|
static rtx
|
static rtx
|
convert_set_attr (rtx exp, struct insn_def *id)
|
convert_set_attr (rtx exp, struct insn_def *id)
|
{
|
{
|
rtx newexp;
|
rtx newexp;
|
const char *name_ptr;
|
const char *name_ptr;
|
char *p;
|
char *p;
|
int n;
|
int n;
|
|
|
/* See how many alternative specified. */
|
/* See how many alternative specified. */
|
n = n_comma_elts (XSTR (exp, 1));
|
n = n_comma_elts (XSTR (exp, 1));
|
if (n == 1)
|
if (n == 1)
|
return attr_rtx (SET,
|
return attr_rtx (SET,
|
attr_rtx (ATTR, XSTR (exp, 0)),
|
attr_rtx (ATTR, XSTR (exp, 0)),
|
attr_rtx (CONST_STRING, XSTR (exp, 1)));
|
attr_rtx (CONST_STRING, XSTR (exp, 1)));
|
|
|
newexp = rtx_alloc (SET_ATTR_ALTERNATIVE);
|
newexp = rtx_alloc (SET_ATTR_ALTERNATIVE);
|
XSTR (newexp, 0) = XSTR (exp, 0);
|
XSTR (newexp, 0) = XSTR (exp, 0);
|
XVEC (newexp, 1) = rtvec_alloc (n);
|
XVEC (newexp, 1) = rtvec_alloc (n);
|
|
|
/* Process each comma-separated name. */
|
/* Process each comma-separated name. */
|
name_ptr = XSTR (exp, 1);
|
name_ptr = XSTR (exp, 1);
|
n = 0;
|
n = 0;
|
while ((p = next_comma_elt (&name_ptr)) != NULL)
|
while ((p = next_comma_elt (&name_ptr)) != NULL)
|
XVECEXP (newexp, 1, n++) = attr_rtx (CONST_STRING, p);
|
XVECEXP (newexp, 1, n++) = attr_rtx (CONST_STRING, p);
|
|
|
return convert_set_attr_alternative (newexp, id);
|
return convert_set_attr_alternative (newexp, id);
|
}
|
}
|
|
|
/* Scan all definitions, checking for validity. Also, convert any SET_ATTR
|
/* Scan all definitions, checking for validity. Also, convert any SET_ATTR
|
and SET_ATTR_ALTERNATIVE expressions to the corresponding SET
|
and SET_ATTR_ALTERNATIVE expressions to the corresponding SET
|
expressions. */
|
expressions. */
|
|
|
static void
|
static void
|
check_defs (void)
|
check_defs (void)
|
{
|
{
|
struct insn_def *id;
|
struct insn_def *id;
|
struct attr_desc *attr;
|
struct attr_desc *attr;
|
int i;
|
int i;
|
rtx value;
|
rtx value;
|
|
|
for (id = defs; id; id = id->next)
|
for (id = defs; id; id = id->next)
|
{
|
{
|
if (XVEC (id->def, id->vec_idx) == NULL)
|
if (XVEC (id->def, id->vec_idx) == NULL)
|
continue;
|
continue;
|
|
|
for (i = 0; i < XVECLEN (id->def, id->vec_idx); i++)
|
for (i = 0; i < XVECLEN (id->def, id->vec_idx); i++)
|
{
|
{
|
value = XVECEXP (id->def, id->vec_idx, i);
|
value = XVECEXP (id->def, id->vec_idx, i);
|
switch (GET_CODE (value))
|
switch (GET_CODE (value))
|
{
|
{
|
case SET:
|
case SET:
|
if (GET_CODE (XEXP (value, 0)) != ATTR)
|
if (GET_CODE (XEXP (value, 0)) != ATTR)
|
{
|
{
|
message_with_line (id->lineno, "bad attribute set");
|
message_with_line (id->lineno, "bad attribute set");
|
have_error = 1;
|
have_error = 1;
|
value = NULL_RTX;
|
value = NULL_RTX;
|
}
|
}
|
break;
|
break;
|
|
|
case SET_ATTR_ALTERNATIVE:
|
case SET_ATTR_ALTERNATIVE:
|
value = convert_set_attr_alternative (value, id);
|
value = convert_set_attr_alternative (value, id);
|
break;
|
break;
|
|
|
case SET_ATTR:
|
case SET_ATTR:
|
value = convert_set_attr (value, id);
|
value = convert_set_attr (value, id);
|
break;
|
break;
|
|
|
default:
|
default:
|
message_with_line (id->lineno, "invalid attribute code %s",
|
message_with_line (id->lineno, "invalid attribute code %s",
|
GET_RTX_NAME (GET_CODE (value)));
|
GET_RTX_NAME (GET_CODE (value)));
|
have_error = 1;
|
have_error = 1;
|
value = NULL_RTX;
|
value = NULL_RTX;
|
}
|
}
|
if (value == NULL_RTX)
|
if (value == NULL_RTX)
|
continue;
|
continue;
|
|
|
if ((attr = find_attr (&XSTR (XEXP (value, 0), 0), 0)) == NULL)
|
if ((attr = find_attr (&XSTR (XEXP (value, 0), 0), 0)) == NULL)
|
{
|
{
|
message_with_line (id->lineno, "unknown attribute %s",
|
message_with_line (id->lineno, "unknown attribute %s",
|
XSTR (XEXP (value, 0), 0));
|
XSTR (XEXP (value, 0), 0));
|
have_error = 1;
|
have_error = 1;
|
continue;
|
continue;
|
}
|
}
|
|
|
XVECEXP (id->def, id->vec_idx, i) = value;
|
XVECEXP (id->def, id->vec_idx, i) = value;
|
XEXP (value, 1) = check_attr_value (XEXP (value, 1), attr);
|
XEXP (value, 1) = check_attr_value (XEXP (value, 1), attr);
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
/* Given a valid expression for an attribute value, remove any IF_THEN_ELSE
|
/* 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
|
expressions by converting them into a COND. This removes cases from this
|
program. Also, replace an attribute value of "*" with the default attribute
|
program. Also, replace an attribute value of "*" with the default attribute
|
value. */
|
value. */
|
|
|
static rtx
|
static rtx
|
make_canonical (struct attr_desc *attr, rtx exp)
|
make_canonical (struct attr_desc *attr, rtx exp)
|
{
|
{
|
int i;
|
int i;
|
rtx newexp;
|
rtx newexp;
|
|
|
switch (GET_CODE (exp))
|
switch (GET_CODE (exp))
|
{
|
{
|
case CONST_INT:
|
case CONST_INT:
|
exp = make_numeric_value (INTVAL (exp));
|
exp = make_numeric_value (INTVAL (exp));
|
break;
|
break;
|
|
|
case CONST_STRING:
|
case CONST_STRING:
|
if (! strcmp (XSTR (exp, 0), "*"))
|
if (! strcmp (XSTR (exp, 0), "*"))
|
{
|
{
|
if (attr == 0 || attr->default_val == 0)
|
if (attr == 0 || attr->default_val == 0)
|
fatal ("(attr_value \"*\") used in invalid context");
|
fatal ("(attr_value \"*\") used in invalid context");
|
exp = attr->default_val->value;
|
exp = attr->default_val->value;
|
}
|
}
|
else
|
else
|
XSTR (exp, 0) = DEF_ATTR_STRING (XSTR (exp, 0));
|
XSTR (exp, 0) = DEF_ATTR_STRING (XSTR (exp, 0));
|
|
|
break;
|
break;
|
|
|
case SYMBOL_REF:
|
case SYMBOL_REF:
|
if (!attr->is_const || ATTR_IND_SIMPLIFIED_P (exp))
|
if (!attr->is_const || ATTR_IND_SIMPLIFIED_P (exp))
|
break;
|
break;
|
/* The SYMBOL_REF is constant for a given run, so mark it as unchanging.
|
/* 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
|
This makes the COND something that won't be considered an arbitrary
|
expression by walk_attr_value. */
|
expression by walk_attr_value. */
|
ATTR_IND_SIMPLIFIED_P (exp) = 1;
|
ATTR_IND_SIMPLIFIED_P (exp) = 1;
|
exp = check_attr_value (exp, attr);
|
exp = check_attr_value (exp, attr);
|
break;
|
break;
|
|
|
case IF_THEN_ELSE:
|
case IF_THEN_ELSE:
|
newexp = rtx_alloc (COND);
|
newexp = rtx_alloc (COND);
|
XVEC (newexp, 0) = rtvec_alloc (2);
|
XVEC (newexp, 0) = rtvec_alloc (2);
|
XVECEXP (newexp, 0, 0) = XEXP (exp, 0);
|
XVECEXP (newexp, 0, 0) = XEXP (exp, 0);
|
XVECEXP (newexp, 0, 1) = XEXP (exp, 1);
|
XVECEXP (newexp, 0, 1) = XEXP (exp, 1);
|
|
|
XEXP (newexp, 1) = XEXP (exp, 2);
|
XEXP (newexp, 1) = XEXP (exp, 2);
|
|
|
exp = newexp;
|
exp = newexp;
|
/* Fall through to COND case since this is now a COND. */
|
/* Fall through to COND case since this is now a COND. */
|
|
|
case COND:
|
case COND:
|
{
|
{
|
int allsame = 1;
|
int allsame = 1;
|
rtx defval;
|
rtx defval;
|
|
|
/* First, check for degenerate COND. */
|
/* First, check for degenerate COND. */
|
if (XVECLEN (exp, 0) == 0)
|
if (XVECLEN (exp, 0) == 0)
|
return make_canonical (attr, XEXP (exp, 1));
|
return make_canonical (attr, XEXP (exp, 1));
|
defval = XEXP (exp, 1) = 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)
|
for (i = 0; i < XVECLEN (exp, 0); i += 2)
|
{
|
{
|
XVECEXP (exp, 0, i) = copy_boolean (XVECEXP (exp, 0, i));
|
XVECEXP (exp, 0, i) = copy_boolean (XVECEXP (exp, 0, i));
|
XVECEXP (exp, 0, i + 1)
|
XVECEXP (exp, 0, i + 1)
|
= make_canonical (attr, XVECEXP (exp, 0, i + 1));
|
= make_canonical (attr, XVECEXP (exp, 0, i + 1));
|
if (! rtx_equal_p (XVECEXP (exp, 0, i + 1), defval))
|
if (! rtx_equal_p (XVECEXP (exp, 0, i + 1), defval))
|
allsame = 0;
|
allsame = 0;
|
}
|
}
|
if (allsame)
|
if (allsame)
|
return defval;
|
return defval;
|
}
|
}
|
break;
|
break;
|
|
|
default:
|
default:
|
break;
|
break;
|
}
|
}
|
|
|
return exp;
|
return exp;
|
}
|
}
|
|
|
static rtx
|
static rtx
|
copy_boolean (rtx exp)
|
copy_boolean (rtx exp)
|
{
|
{
|
if (GET_CODE (exp) == AND || GET_CODE (exp) == IOR)
|
if (GET_CODE (exp) == AND || GET_CODE (exp) == IOR)
|
return attr_rtx (GET_CODE (exp), copy_boolean (XEXP (exp, 0)),
|
return attr_rtx (GET_CODE (exp), copy_boolean (XEXP (exp, 0)),
|
copy_boolean (XEXP (exp, 1)));
|
copy_boolean (XEXP (exp, 1)));
|
if (GET_CODE (exp) == MATCH_OPERAND)
|
if (GET_CODE (exp) == MATCH_OPERAND)
|
{
|
{
|
XSTR (exp, 1) = DEF_ATTR_STRING (XSTR (exp, 1));
|
XSTR (exp, 1) = DEF_ATTR_STRING (XSTR (exp, 1));
|
XSTR (exp, 2) = DEF_ATTR_STRING (XSTR (exp, 2));
|
XSTR (exp, 2) = DEF_ATTR_STRING (XSTR (exp, 2));
|
}
|
}
|
else if (GET_CODE (exp) == EQ_ATTR)
|
else if (GET_CODE (exp) == EQ_ATTR)
|
{
|
{
|
XSTR (exp, 0) = DEF_ATTR_STRING (XSTR (exp, 0));
|
XSTR (exp, 0) = DEF_ATTR_STRING (XSTR (exp, 0));
|
XSTR (exp, 1) = DEF_ATTR_STRING (XSTR (exp, 1));
|
XSTR (exp, 1) = DEF_ATTR_STRING (XSTR (exp, 1));
|
}
|
}
|
|
|
return exp;
|
return exp;
|
}
|
}
|
|
|
/* Given a value and an attribute description, return a `struct attr_value *'
|
/* Given a value and an attribute description, return a `struct attr_value *'
|
that represents that value. This is either an existing structure, if the
|
that represents that value. This is either an existing structure, if the
|
value has been previously encountered, or a newly-created structure.
|
value has been previously encountered, or a newly-created structure.
|
|
|
`insn_code' is the code of an insn whose attribute has the specified
|
`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
|
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
|
a given value have the same number of alternatives if the value checks
|
alternatives. */
|
alternatives. */
|
|
|
static struct attr_value *
|
static struct attr_value *
|
get_attr_value (rtx value, struct attr_desc *attr, int insn_code)
|
get_attr_value (rtx value, struct attr_desc *attr, int insn_code)
|
{
|
{
|
struct attr_value *av;
|
struct attr_value *av;
|
int num_alt = 0;
|
int num_alt = 0;
|
|
|
value = make_canonical (attr, value);
|
value = make_canonical (attr, value);
|
if (compares_alternatives_p (value))
|
if (compares_alternatives_p (value))
|
{
|
{
|
if (insn_code < 0 || insn_alternatives == NULL)
|
if (insn_code < 0 || insn_alternatives == NULL)
|
fatal ("(eq_attr \"alternatives\" ...) used in non-insn context");
|
fatal ("(eq_attr \"alternatives\" ...) used in non-insn context");
|
else
|
else
|
num_alt = insn_alternatives[insn_code];
|
num_alt = insn_alternatives[insn_code];
|
}
|
}
|
|
|
for (av = attr->first_value; av; av = av->next)
|
for (av = attr->first_value; av; av = av->next)
|
if (rtx_equal_p (value, av->value)
|
if (rtx_equal_p (value, av->value)
|
&& (num_alt == 0 || av->first_insn == NULL
|
&& (num_alt == 0 || av->first_insn == NULL
|
|| insn_alternatives[av->first_insn->def->insn_code]))
|
|| insn_alternatives[av->first_insn->def->insn_code]))
|
return av;
|
return av;
|
|
|
av = oballoc (struct attr_value);
|
av = oballoc (struct attr_value);
|
av->value = value;
|
av->value = value;
|
av->next = attr->first_value;
|
av->next = attr->first_value;
|
attr->first_value = av;
|
attr->first_value = av;
|
av->first_insn = NULL;
|
av->first_insn = NULL;
|
av->num_insns = 0;
|
av->num_insns = 0;
|
av->has_asm_insn = 0;
|
av->has_asm_insn = 0;
|
|
|
return av;
|
return av;
|
}
|
}
|
|
|
/* After all DEFINE_DELAYs have been read in, create internal attributes
|
/* After all DEFINE_DELAYs have been read in, create internal attributes
|
to generate the required routines.
|
to generate the required routines.
|
|
|
First, we compute the number of delay slots for each insn (as a COND of
|
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
|
each of the test expressions in DEFINE_DELAYs). Then, if more than one
|
delay type is specified, we compute a similar function giving the
|
delay type is specified, we compute a similar function giving the
|
DEFINE_DELAY ordinal for each insn.
|
DEFINE_DELAY ordinal for each insn.
|
|
|
Finally, for each [DEFINE_DELAY, slot #] pair, we compute an attribute that
|
Finally, for each [DEFINE_DELAY, slot #] pair, we compute an attribute that
|
tells whether a given insn can be in that delay slot.
|
tells whether a given insn can be in that delay slot.
|
|
|
Normal attribute filling and optimization expands these to contain the
|
Normal attribute filling and optimization expands these to contain the
|
information needed to handle delay slots. */
|
information needed to handle delay slots. */
|
|
|
static void
|
static void
|
expand_delays (void)
|
expand_delays (void)
|
{
|
{
|
struct delay_desc *delay;
|
struct delay_desc *delay;
|
rtx condexp;
|
rtx condexp;
|
rtx newexp;
|
rtx newexp;
|
int i;
|
int i;
|
char *p;
|
char *p;
|
|
|
/* First, generate data for `num_delay_slots' function. */
|
/* First, generate data for `num_delay_slots' function. */
|
|
|
condexp = rtx_alloc (COND);
|
condexp = rtx_alloc (COND);
|
XVEC (condexp, 0) = rtvec_alloc (num_delays * 2);
|
XVEC (condexp, 0) = rtvec_alloc (num_delays * 2);
|
XEXP (condexp, 1) = make_numeric_value (0);
|
XEXP (condexp, 1) = make_numeric_value (0);
|
|
|
for (i = 0, delay = delays; delay; i += 2, delay = delay->next)
|
for (i = 0, delay = delays; delay; i += 2, delay = delay->next)
|
{
|
{
|
XVECEXP (condexp, 0, i) = XEXP (delay->def, 0);
|
XVECEXP (condexp, 0, i) = XEXP (delay->def, 0);
|
XVECEXP (condexp, 0, i + 1)
|
XVECEXP (condexp, 0, i + 1)
|
= make_numeric_value (XVECLEN (delay->def, 1) / 3);
|
= make_numeric_value (XVECLEN (delay->def, 1) / 3);
|
}
|
}
|
|
|
make_internal_attr (num_delay_slots_str, condexp, ATTR_NONE);
|
make_internal_attr (num_delay_slots_str, condexp, ATTR_NONE);
|
|
|
/* If more than one delay type, do the same for computing the delay type. */
|
/* If more than one delay type, do the same for computing the delay type. */
|
if (num_delays > 1)
|
if (num_delays > 1)
|
{
|
{
|
condexp = rtx_alloc (COND);
|
condexp = rtx_alloc (COND);
|
XVEC (condexp, 0) = rtvec_alloc (num_delays * 2);
|
XVEC (condexp, 0) = rtvec_alloc (num_delays * 2);
|
XEXP (condexp, 1) = make_numeric_value (0);
|
XEXP (condexp, 1) = make_numeric_value (0);
|
|
|
for (i = 0, delay = delays; delay; i += 2, delay = delay->next)
|
for (i = 0, delay = delays; delay; i += 2, delay = delay->next)
|
{
|
{
|
XVECEXP (condexp, 0, i) = XEXP (delay->def, 0);
|
XVECEXP (condexp, 0, i) = XEXP (delay->def, 0);
|
XVECEXP (condexp, 0, i + 1) = make_numeric_value (delay->num);
|
XVECEXP (condexp, 0, i + 1) = make_numeric_value (delay->num);
|
}
|
}
|
|
|
make_internal_attr (delay_type_str, condexp, ATTR_SPECIAL);
|
make_internal_attr (delay_type_str, condexp, ATTR_SPECIAL);
|
}
|
}
|
|
|
/* For each delay possibility and delay slot, compute an eligibility
|
/* For each delay possibility and delay slot, compute an eligibility
|
attribute for non-annulled insns and for each type of annulled (annul
|
attribute for non-annulled insns and for each type of annulled (annul
|
if true and annul if false). */
|
if true and annul if false). */
|
for (delay = delays; delay; delay = delay->next)
|
for (delay = delays; delay; delay = delay->next)
|
{
|
{
|
for (i = 0; i < XVECLEN (delay->def, 1); i += 3)
|
for (i = 0; i < XVECLEN (delay->def, 1); i += 3)
|
{
|
{
|
condexp = XVECEXP (delay->def, 1, i);
|
condexp = XVECEXP (delay->def, 1, i);
|
if (condexp == 0)
|
if (condexp == 0)
|
condexp = false_rtx;
|
condexp = false_rtx;
|
newexp = attr_rtx (IF_THEN_ELSE, condexp,
|
newexp = attr_rtx (IF_THEN_ELSE, condexp,
|
make_numeric_value (1), make_numeric_value (0));
|
make_numeric_value (1), make_numeric_value (0));
|
|
|
p = attr_printf (sizeof "*delay__" + MAX_DIGITS * 2,
|
p = attr_printf (sizeof "*delay__" + MAX_DIGITS * 2,
|
"*delay_%d_%d", delay->num, i / 3);
|
"*delay_%d_%d", delay->num, i / 3);
|
make_internal_attr (p, newexp, ATTR_SPECIAL);
|
make_internal_attr (p, newexp, ATTR_SPECIAL);
|
|
|
if (have_annul_true)
|
if (have_annul_true)
|
{
|
{
|
condexp = XVECEXP (delay->def, 1, i + 1);
|
condexp = XVECEXP (delay->def, 1, i + 1);
|
if (condexp == 0) condexp = false_rtx;
|
if (condexp == 0) condexp = false_rtx;
|
newexp = attr_rtx (IF_THEN_ELSE, condexp,
|
newexp = attr_rtx (IF_THEN_ELSE, condexp,
|
make_numeric_value (1),
|
make_numeric_value (1),
|
make_numeric_value (0));
|
make_numeric_value (0));
|
p = attr_printf (sizeof "*annul_true__" + MAX_DIGITS * 2,
|
p = attr_printf (sizeof "*annul_true__" + MAX_DIGITS * 2,
|
"*annul_true_%d_%d", delay->num, i / 3);
|
"*annul_true_%d_%d", delay->num, i / 3);
|
make_internal_attr (p, newexp, ATTR_SPECIAL);
|
make_internal_attr (p, newexp, ATTR_SPECIAL);
|
}
|
}
|
|
|
if (have_annul_false)
|
if (have_annul_false)
|
{
|
{
|
condexp = XVECEXP (delay->def, 1, i + 2);
|
condexp = XVECEXP (delay->def, 1, i + 2);
|
if (condexp == 0) condexp = false_rtx;
|
if (condexp == 0) condexp = false_rtx;
|
newexp = attr_rtx (IF_THEN_ELSE, condexp,
|
newexp = attr_rtx (IF_THEN_ELSE, condexp,
|
make_numeric_value (1),
|
make_numeric_value (1),
|
make_numeric_value (0));
|
make_numeric_value (0));
|
p = attr_printf (sizeof "*annul_false__" + MAX_DIGITS * 2,
|
p = attr_printf (sizeof "*annul_false__" + MAX_DIGITS * 2,
|
"*annul_false_%d_%d", delay->num, i / 3);
|
"*annul_false_%d_%d", delay->num, i / 3);
|
make_internal_attr (p, newexp, ATTR_SPECIAL);
|
make_internal_attr (p, newexp, ATTR_SPECIAL);
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
/* Once all attributes and insns have been read and checked, we construct for
|
/* 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
|
each attribute value a list of all the insns that have that value for
|
the attribute. */
|
the attribute. */
|
|
|
static void
|
static void
|
fill_attr (struct attr_desc *attr)
|
fill_attr (struct attr_desc *attr)
|
{
|
{
|
struct attr_value *av;
|
struct attr_value *av;
|
struct insn_ent *ie;
|
struct insn_ent *ie;
|
struct insn_def *id;
|
struct insn_def *id;
|
int i;
|
int i;
|
rtx value;
|
rtx value;
|
|
|
/* Don't fill constant attributes. The value is independent of
|
/* Don't fill constant attributes. The value is independent of
|
any particular insn. */
|
any particular insn. */
|
if (attr->is_const)
|
if (attr->is_const)
|
return;
|
return;
|
|
|
for (id = defs; id; id = id->next)
|
for (id = defs; id; id = id->next)
|
{
|
{
|
/* If no value is specified for this insn for this attribute, use the
|
/* If no value is specified for this insn for this attribute, use the
|
default. */
|
default. */
|
value = NULL;
|
value = NULL;
|
if (XVEC (id->def, id->vec_idx))
|
if (XVEC (id->def, id->vec_idx))
|
for (i = 0; i < XVECLEN (id->def, id->vec_idx); i++)
|
for (i = 0; i < XVECLEN (id->def, id->vec_idx); i++)
|
if (! strcmp_check (XSTR (XEXP (XVECEXP (id->def, id->vec_idx, i), 0), 0),
|
if (! strcmp_check (XSTR (XEXP (XVECEXP (id->def, id->vec_idx, i), 0), 0),
|
attr->name))
|
attr->name))
|
value = XEXP (XVECEXP (id->def, id->vec_idx, i), 1);
|
value = XEXP (XVECEXP (id->def, id->vec_idx, i), 1);
|
|
|
if (value == NULL)
|
if (value == NULL)
|
av = attr->default_val;
|
av = attr->default_val;
|
else
|
else
|
av = get_attr_value (value, attr, id->insn_code);
|
av = get_attr_value (value, attr, id->insn_code);
|
|
|
ie = oballoc (struct insn_ent);
|
ie = oballoc (struct insn_ent);
|
ie->def = id;
|
ie->def = id;
|
insert_insn_ent (av, ie);
|
insert_insn_ent (av, ie);
|
}
|
}
|
}
|
}
|
|
|
/* Given an expression EXP, see if it is a COND or IF_THEN_ELSE that has a
|
/* 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).
|
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
|
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
|
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,
|
recursively on each value (including the default value). Otherwise,
|
return the value returned by NO_ADDRESS_FN applied to EXP. */
|
return the value returned by NO_ADDRESS_FN applied to EXP. */
|
|
|
static rtx
|
static rtx
|
substitute_address (rtx exp, rtx (*no_address_fn) (rtx),
|
substitute_address (rtx exp, rtx (*no_address_fn) (rtx),
|
rtx (*address_fn) (rtx))
|
rtx (*address_fn) (rtx))
|
{
|
{
|
int i;
|
int i;
|
rtx newexp;
|
rtx newexp;
|
|
|
if (GET_CODE (exp) == COND)
|
if (GET_CODE (exp) == COND)
|
{
|
{
|
/* See if any tests use addresses. */
|
/* See if any tests use addresses. */
|
address_used = 0;
|
address_used = 0;
|
for (i = 0; i < XVECLEN (exp, 0); i += 2)
|
for (i = 0; i < XVECLEN (exp, 0); i += 2)
|
walk_attr_value (XVECEXP (exp, 0, i));
|
walk_attr_value (XVECEXP (exp, 0, i));
|
|
|
if (address_used)
|
if (address_used)
|
return (*address_fn) (exp);
|
return (*address_fn) (exp);
|
|
|
/* Make a new copy of this COND, replacing each element. */
|
/* Make a new copy of this COND, replacing each element. */
|
newexp = rtx_alloc (COND);
|
newexp = rtx_alloc (COND);
|
XVEC (newexp, 0) = rtvec_alloc (XVECLEN (exp, 0));
|
XVEC (newexp, 0) = rtvec_alloc (XVECLEN (exp, 0));
|
for (i = 0; i < XVECLEN (exp, 0); i += 2)
|
for (i = 0; i < XVECLEN (exp, 0); i += 2)
|
{
|
{
|
XVECEXP (newexp, 0, i) = XVECEXP (exp, 0, i);
|
XVECEXP (newexp, 0, i) = XVECEXP (exp, 0, i);
|
XVECEXP (newexp, 0, i + 1)
|
XVECEXP (newexp, 0, i + 1)
|
= substitute_address (XVECEXP (exp, 0, i + 1),
|
= substitute_address (XVECEXP (exp, 0, i + 1),
|
no_address_fn, address_fn);
|
no_address_fn, address_fn);
|
}
|
}
|
|
|
XEXP (newexp, 1) = substitute_address (XEXP (exp, 1),
|
XEXP (newexp, 1) = substitute_address (XEXP (exp, 1),
|
no_address_fn, address_fn);
|
no_address_fn, address_fn);
|
|
|
return newexp;
|
return newexp;
|
}
|
}
|
|
|
else if (GET_CODE (exp) == IF_THEN_ELSE)
|
else if (GET_CODE (exp) == IF_THEN_ELSE)
|
{
|
{
|
address_used = 0;
|
address_used = 0;
|
walk_attr_value (XEXP (exp, 0));
|
walk_attr_value (XEXP (exp, 0));
|
if (address_used)
|
if (address_used)
|
return (*address_fn) (exp);
|
return (*address_fn) (exp);
|
|
|
return attr_rtx (IF_THEN_ELSE,
|
return attr_rtx (IF_THEN_ELSE,
|
substitute_address (XEXP (exp, 0),
|
substitute_address (XEXP (exp, 0),
|
no_address_fn, address_fn),
|
no_address_fn, address_fn),
|
substitute_address (XEXP (exp, 1),
|
substitute_address (XEXP (exp, 1),
|
no_address_fn, address_fn),
|
no_address_fn, address_fn),
|
substitute_address (XEXP (exp, 2),
|
substitute_address (XEXP (exp, 2),
|
no_address_fn, address_fn));
|
no_address_fn, address_fn));
|
}
|
}
|
|
|
return (*no_address_fn) (exp);
|
return (*no_address_fn) (exp);
|
}
|
}
|
|
|
/* Make new attributes from the `length' attribute. The following are made,
|
/* Make new attributes from the `length' attribute. The following are made,
|
each corresponding to a function called from `shorten_branches' or
|
each corresponding to a function called from `shorten_branches' or
|
`get_attr_length':
|
`get_attr_length':
|
|
|
*insn_default_length This is the length of the insn to be returned
|
*insn_default_length This is the length of the insn to be returned
|
by `get_attr_length' before `shorten_branches'
|
by `get_attr_length' before `shorten_branches'
|
has been called. In each case where the length
|
has been called. In each case where the length
|
depends on relative addresses, the largest
|
depends on relative addresses, the largest
|
possible is used. This routine is also used
|
possible is used. This routine is also used
|
to compute the initial size of the insn.
|
to compute the initial size of the insn.
|
|
|
*insn_variable_length_p This returns 1 if the insn's length depends
|
*insn_variable_length_p This returns 1 if the insn's length depends
|
on relative addresses, zero otherwise.
|
on relative addresses, zero otherwise.
|
|
|
*insn_current_length This is only called when it is known that the
|
*insn_current_length This is only called when it is known that the
|
insn has a variable length and returns the
|
insn has a variable length and returns the
|
current length, based on relative addresses.
|
current length, based on relative addresses.
|
*/
|
*/
|
|
|
static void
|
static void
|
make_length_attrs (void)
|
make_length_attrs (void)
|
{
|
{
|
static const char *new_names[] =
|
static const char *new_names[] =
|
{
|
{
|
"*insn_default_length",
|
"*insn_default_length",
|
"*insn_min_length",
|
"*insn_min_length",
|
"*insn_variable_length_p",
|
"*insn_variable_length_p",
|
"*insn_current_length"
|
"*insn_current_length"
|
};
|
};
|
static rtx (*const no_address_fn[]) (rtx)
|
static rtx (*const no_address_fn[]) (rtx)
|
= {identity_fn,identity_fn, zero_fn, zero_fn};
|
= {identity_fn,identity_fn, zero_fn, zero_fn};
|
static rtx (*const address_fn[]) (rtx)
|
static rtx (*const address_fn[]) (rtx)
|
= {max_fn, min_fn, one_fn, identity_fn};
|
= {max_fn, min_fn, one_fn, identity_fn};
|
size_t i;
|
size_t i;
|
struct attr_desc *length_attr, *new_attr;
|
struct attr_desc *length_attr, *new_attr;
|
struct attr_value *av, *new_av;
|
struct attr_value *av, *new_av;
|
struct insn_ent *ie, *new_ie;
|
struct insn_ent *ie, *new_ie;
|
|
|
/* See if length attribute is defined. If so, it must be numeric. Make
|
/* See if length attribute is defined. If so, it must be numeric. Make
|
it special so we don't output anything for it. */
|
it special so we don't output anything for it. */
|
length_attr = find_attr (&length_str, 0);
|
length_attr = find_attr (&length_str, 0);
|
if (length_attr == 0)
|
if (length_attr == 0)
|
return;
|
return;
|
|
|
if (! length_attr->is_numeric)
|
if (! length_attr->is_numeric)
|
fatal ("length attribute must be numeric");
|
fatal ("length attribute must be numeric");
|
|
|
length_attr->is_const = 0;
|
length_attr->is_const = 0;
|
length_attr->is_special = 1;
|
length_attr->is_special = 1;
|
|
|
/* Make each new attribute, in turn. */
|
/* Make each new attribute, in turn. */
|
for (i = 0; i < ARRAY_SIZE (new_names); i++)
|
for (i = 0; i < ARRAY_SIZE (new_names); i++)
|
{
|
{
|
make_internal_attr (new_names[i],
|
make_internal_attr (new_names[i],
|
substitute_address (length_attr->default_val->value,
|
substitute_address (length_attr->default_val->value,
|
no_address_fn[i], address_fn[i]),
|
no_address_fn[i], address_fn[i]),
|
ATTR_NONE);
|
ATTR_NONE);
|
new_attr = find_attr (&new_names[i], 0);
|
new_attr = find_attr (&new_names[i], 0);
|
for (av = length_attr->first_value; av; av = av->next)
|
for (av = length_attr->first_value; av; av = av->next)
|
for (ie = av->first_insn; ie; ie = ie->next)
|
for (ie = av->first_insn; ie; ie = ie->next)
|
{
|
{
|
new_av = get_attr_value (substitute_address (av->value,
|
new_av = get_attr_value (substitute_address (av->value,
|
no_address_fn[i],
|
no_address_fn[i],
|
address_fn[i]),
|
address_fn[i]),
|
new_attr, ie->def->insn_code);
|
new_attr, ie->def->insn_code);
|
new_ie = oballoc (struct insn_ent);
|
new_ie = oballoc (struct insn_ent);
|
new_ie->def = ie->def;
|
new_ie->def = ie->def;
|
insert_insn_ent (new_av, new_ie);
|
insert_insn_ent (new_av, new_ie);
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
/* Utility functions called from above routine. */
|
/* Utility functions called from above routine. */
|
|
|
static rtx
|
static rtx
|
identity_fn (rtx exp)
|
identity_fn (rtx exp)
|
{
|
{
|
return exp;
|
return exp;
|
}
|
}
|
|
|
static rtx
|
static rtx
|
zero_fn (rtx exp ATTRIBUTE_UNUSED)
|
zero_fn (rtx exp ATTRIBUTE_UNUSED)
|
{
|
{
|
return make_numeric_value (0);
|
return make_numeric_value (0);
|
}
|
}
|
|
|
static rtx
|
static rtx
|
one_fn (rtx exp ATTRIBUTE_UNUSED)
|
one_fn (rtx exp ATTRIBUTE_UNUSED)
|
{
|
{
|
return make_numeric_value (1);
|
return make_numeric_value (1);
|
}
|
}
|
|
|
static rtx
|
static rtx
|
max_fn (rtx exp)
|
max_fn (rtx exp)
|
{
|
{
|
int unknown;
|
int unknown;
|
return make_numeric_value (max_attr_value (exp, &unknown));
|
return make_numeric_value (max_attr_value (exp, &unknown));
|
}
|
}
|
|
|
static rtx
|
static rtx
|
min_fn (rtx exp)
|
min_fn (rtx exp)
|
{
|
{
|
int unknown;
|
int unknown;
|
return make_numeric_value (min_attr_value (exp, &unknown));
|
return make_numeric_value (min_attr_value (exp, &unknown));
|
}
|
}
|
|
|
static void
|
static void
|
write_length_unit_log (void)
|
write_length_unit_log (void)
|
{
|
{
|
struct attr_desc *length_attr = find_attr (&length_str, 0);
|
struct attr_desc *length_attr = find_attr (&length_str, 0);
|
struct attr_value *av;
|
struct attr_value *av;
|
struct insn_ent *ie;
|
struct insn_ent *ie;
|
unsigned int length_unit_log, length_or;
|
unsigned int length_unit_log, length_or;
|
int unknown = 0;
|
int unknown = 0;
|
|
|
if (length_attr == 0)
|
if (length_attr == 0)
|
return;
|
return;
|
length_or = or_attr_value (length_attr->default_val->value, &unknown);
|
length_or = or_attr_value (length_attr->default_val->value, &unknown);
|
for (av = length_attr->first_value; av; av = av->next)
|
for (av = length_attr->first_value; av; av = av->next)
|
for (ie = av->first_insn; ie; ie = ie->next)
|
for (ie = av->first_insn; ie; ie = ie->next)
|
length_or |= or_attr_value (av->value, &unknown);
|
length_or |= or_attr_value (av->value, &unknown);
|
|
|
if (unknown)
|
if (unknown)
|
length_unit_log = 0;
|
length_unit_log = 0;
|
else
|
else
|
{
|
{
|
length_or = ~length_or;
|
length_or = ~length_or;
|
for (length_unit_log = 0; length_or & 1; length_or >>= 1)
|
for (length_unit_log = 0; length_or & 1; length_or >>= 1)
|
length_unit_log++;
|
length_unit_log++;
|
}
|
}
|
printf ("EXPORTED_CONST int length_unit_log = %u;\n", length_unit_log);
|
printf ("EXPORTED_CONST int length_unit_log = %u;\n", length_unit_log);
|
}
|
}
|
|
|
/* Take a COND expression and see if any of the conditions in it can be
|
/* 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
|
simplified. If any are known true or known false for the particular insn
|
code, the COND can be further simplified.
|
code, the COND can be further simplified.
|
|
|
Also call ourselves on any COND operations that are values of this COND.
|
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. */
|
We do not modify EXP; rather, we make and return a new rtx. */
|
|
|
static rtx
|
static rtx
|
simplify_cond (rtx exp, int insn_code, int insn_index)
|
simplify_cond (rtx exp, int insn_code, int insn_index)
|
{
|
{
|
int i, j;
|
int i, j;
|
/* We store the desired contents here,
|
/* We store the desired contents here,
|
then build a new expression if they don't match EXP. */
|
then build a new expression if they don't match EXP. */
|
rtx defval = XEXP (exp, 1);
|
rtx defval = XEXP (exp, 1);
|
rtx new_defval = XEXP (exp, 1);
|
rtx new_defval = XEXP (exp, 1);
|
int len = XVECLEN (exp, 0);
|
int len = XVECLEN (exp, 0);
|
rtx *tests = XNEWVEC (rtx, len);
|
rtx *tests = XNEWVEC (rtx, len);
|
int allsame = 1;
|
int allsame = 1;
|
rtx ret;
|
rtx ret;
|
|
|
/* This lets us free all storage allocated below, if appropriate. */
|
/* This lets us free all storage allocated below, if appropriate. */
|
obstack_finish (rtl_obstack);
|
obstack_finish (rtl_obstack);
|
|
|
memcpy (tests, XVEC (exp, 0)->elem, len * sizeof (rtx));
|
memcpy (tests, XVEC (exp, 0)->elem, len * sizeof (rtx));
|
|
|
/* See if default value needs simplification. */
|
/* See if default value needs simplification. */
|
if (GET_CODE (defval) == COND)
|
if (GET_CODE (defval) == COND)
|
new_defval = simplify_cond (defval, insn_code, insn_index);
|
new_defval = simplify_cond (defval, insn_code, insn_index);
|
|
|
/* Simplify the subexpressions, and see what tests we can get rid of. */
|
/* Simplify the subexpressions, and see what tests we can get rid of. */
|
|
|
for (i = 0; i < len; i += 2)
|
for (i = 0; i < len; i += 2)
|
{
|
{
|
rtx newtest, newval;
|
rtx newtest, newval;
|
|
|
/* Simplify this test. */
|
/* Simplify this test. */
|
newtest = simplify_test_exp_in_temp (tests[i], insn_code, insn_index);
|
newtest = simplify_test_exp_in_temp (tests[i], insn_code, insn_index);
|
tests[i] = newtest;
|
tests[i] = newtest;
|
|
|
newval = tests[i + 1];
|
newval = tests[i + 1];
|
/* See if this value may need simplification. */
|
/* See if this value may need simplification. */
|
if (GET_CODE (newval) == COND)
|
if (GET_CODE (newval) == COND)
|
newval = simplify_cond (newval, insn_code, insn_index);
|
newval = simplify_cond (newval, insn_code, insn_index);
|
|
|
/* Look for ways to delete or combine this test. */
|
/* Look for ways to delete or combine this test. */
|
if (newtest == true_rtx)
|
if (newtest == true_rtx)
|
{
|
{
|
/* If test is true, make this value the default
|
/* If test is true, make this value the default
|
and discard this + any following tests. */
|
and discard this + any following tests. */
|
len = i;
|
len = i;
|
defval = tests[i + 1];
|
defval = tests[i + 1];
|
new_defval = newval;
|
new_defval = newval;
|
}
|
}
|
|
|
else if (newtest == false_rtx)
|
else if (newtest == false_rtx)
|
{
|
{
|
/* If test is false, discard it and its value. */
|
/* If test is false, discard it and its value. */
|
for (j = i; j < len - 2; j++)
|
for (j = i; j < len - 2; j++)
|
tests[j] = tests[j + 2];
|
tests[j] = tests[j + 2];
|
i -= 2;
|
i -= 2;
|
len -= 2;
|
len -= 2;
|
}
|
}
|
|
|
else if (i > 0 && attr_equal_p (newval, tests[i - 1]))
|
else if (i > 0 && attr_equal_p (newval, tests[i - 1]))
|
{
|
{
|
/* If this value and the value for the prev test are the same,
|
/* If this value and the value for the prev test are the same,
|
merge the tests. */
|
merge the tests. */
|
|
|
tests[i - 2]
|
tests[i - 2]
|
= insert_right_side (IOR, tests[i - 2], newtest,
|
= insert_right_side (IOR, tests[i - 2], newtest,
|
insn_code, insn_index);
|
insn_code, insn_index);
|
|
|
/* Delete this test/value. */
|
/* Delete this test/value. */
|
for (j = i; j < len - 2; j++)
|
for (j = i; j < len - 2; j++)
|
tests[j] = tests[j + 2];
|
tests[j] = tests[j + 2];
|
len -= 2;
|
len -= 2;
|
i -= 2;
|
i -= 2;
|
}
|
}
|
|
|
else
|
else
|
tests[i + 1] = newval;
|
tests[i + 1] = newval;
|
}
|
}
|
|
|
/* If the last test in a COND has the same value
|
/* If the last test in a COND has the same value
|
as the default value, that test isn't needed. */
|
as the default value, that test isn't needed. */
|
|
|
while (len > 0 && attr_equal_p (tests[len - 1], new_defval))
|
while (len > 0 && attr_equal_p (tests[len - 1], new_defval))
|
len -= 2;
|
len -= 2;
|
|
|
/* See if we changed anything. */
|
/* See if we changed anything. */
|
if (len != XVECLEN (exp, 0) || new_defval != XEXP (exp, 1))
|
if (len != XVECLEN (exp, 0) || new_defval != XEXP (exp, 1))
|
allsame = 0;
|
allsame = 0;
|
else
|
else
|
for (i = 0; i < len; i++)
|
for (i = 0; i < len; i++)
|
if (! attr_equal_p (tests[i], XVECEXP (exp, 0, i)))
|
if (! attr_equal_p (tests[i], XVECEXP (exp, 0, i)))
|
{
|
{
|
allsame = 0;
|
allsame = 0;
|
break;
|
break;
|
}
|
}
|
|
|
if (len == 0)
|
if (len == 0)
|
{
|
{
|
if (GET_CODE (defval) == COND)
|
if (GET_CODE (defval) == COND)
|
ret = simplify_cond (defval, insn_code, insn_index);
|
ret = simplify_cond (defval, insn_code, insn_index);
|
else
|
else
|
ret = defval;
|
ret = defval;
|
}
|
}
|
else if (allsame)
|
else if (allsame)
|
ret = exp;
|
ret = exp;
|
else
|
else
|
{
|
{
|
rtx newexp = rtx_alloc (COND);
|
rtx newexp = rtx_alloc (COND);
|
|
|
XVEC (newexp, 0) = rtvec_alloc (len);
|
XVEC (newexp, 0) = rtvec_alloc (len);
|
memcpy (XVEC (newexp, 0)->elem, tests, len * sizeof (rtx));
|
memcpy (XVEC (newexp, 0)->elem, tests, len * sizeof (rtx));
|
XEXP (newexp, 1) = new_defval;
|
XEXP (newexp, 1) = new_defval;
|
ret = newexp;
|
ret = newexp;
|
}
|
}
|
free (tests);
|
free (tests);
|
return ret;
|
return ret;
|
}
|
}
|
|
|
/* Remove an insn entry from an attribute value. */
|
/* Remove an insn entry from an attribute value. */
|
|
|
static void
|
static void
|
remove_insn_ent (struct attr_value *av, struct insn_ent *ie)
|
remove_insn_ent (struct attr_value *av, struct insn_ent *ie)
|
{
|
{
|
struct insn_ent *previe;
|
struct insn_ent *previe;
|
|
|
if (av->first_insn == ie)
|
if (av->first_insn == ie)
|
av->first_insn = ie->next;
|
av->first_insn = ie->next;
|
else
|
else
|
{
|
{
|
for (previe = av->first_insn; previe->next != ie; previe = previe->next)
|
for (previe = av->first_insn; previe->next != ie; previe = previe->next)
|
;
|
;
|
previe->next = ie->next;
|
previe->next = ie->next;
|
}
|
}
|
|
|
av->num_insns--;
|
av->num_insns--;
|
if (ie->def->insn_code == -1)
|
if (ie->def->insn_code == -1)
|
av->has_asm_insn = 0;
|
av->has_asm_insn = 0;
|
|
|
num_insn_ents--;
|
num_insn_ents--;
|
}
|
}
|
|
|
/* Insert an insn entry in an attribute value list. */
|
/* Insert an insn entry in an attribute value list. */
|
|
|
static void
|
static void
|
insert_insn_ent (struct attr_value *av, struct insn_ent *ie)
|
insert_insn_ent (struct attr_value *av, struct insn_ent *ie)
|
{
|
{
|
ie->next = av->first_insn;
|
ie->next = av->first_insn;
|
av->first_insn = ie;
|
av->first_insn = ie;
|
av->num_insns++;
|
av->num_insns++;
|
if (ie->def->insn_code == -1)
|
if (ie->def->insn_code == -1)
|
av->has_asm_insn = 1;
|
av->has_asm_insn = 1;
|
|
|
num_insn_ents++;
|
num_insn_ents++;
|
}
|
}
|
|
|
/* This is a utility routine to take an expression that is a tree of either
|
/* 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
|
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
|
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
|
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
|
side will be the old right side and its right side will be the new
|
term.
|
term.
|
|
|
If the `term' is itself a tree, all its leaves will be inserted. */
|
If the `term' is itself a tree, all its leaves will be inserted. */
|
|
|
static rtx
|
static rtx
|
insert_right_side (enum rtx_code code, rtx exp, rtx term, int insn_code, int insn_index)
|
insert_right_side (enum rtx_code code, rtx exp, rtx term, int insn_code, int insn_index)
|
{
|
{
|
rtx newexp;
|
rtx newexp;
|
|
|
/* Avoid consing in some special cases. */
|
/* Avoid consing in some special cases. */
|
if (code == AND && term == true_rtx)
|
if (code == AND && term == true_rtx)
|
return exp;
|
return exp;
|
if (code == AND && term == false_rtx)
|
if (code == AND && term == false_rtx)
|
return false_rtx;
|
return false_rtx;
|
if (code == AND && exp == true_rtx)
|
if (code == AND && exp == true_rtx)
|
return term;
|
return term;
|
if (code == AND && exp == false_rtx)
|
if (code == AND && exp == false_rtx)
|
return false_rtx;
|
return false_rtx;
|
if (code == IOR && term == true_rtx)
|
if (code == IOR && term == true_rtx)
|
return true_rtx;
|
return true_rtx;
|
if (code == IOR && term == false_rtx)
|
if (code == IOR && term == false_rtx)
|
return exp;
|
return exp;
|
if (code == IOR && exp == true_rtx)
|
if (code == IOR && exp == true_rtx)
|
return true_rtx;
|
return true_rtx;
|
if (code == IOR && exp == false_rtx)
|
if (code == IOR && exp == false_rtx)
|
return term;
|
return term;
|
if (attr_equal_p (exp, term))
|
if (attr_equal_p (exp, term))
|
return exp;
|
return exp;
|
|
|
if (GET_CODE (term) == code)
|
if (GET_CODE (term) == code)
|
{
|
{
|
exp = insert_right_side (code, exp, XEXP (term, 0),
|
exp = insert_right_side (code, exp, XEXP (term, 0),
|
insn_code, insn_index);
|
insn_code, insn_index);
|
exp = insert_right_side (code, exp, XEXP (term, 1),
|
exp = insert_right_side (code, exp, XEXP (term, 1),
|
insn_code, insn_index);
|
insn_code, insn_index);
|
|
|
return exp;
|
return exp;
|
}
|
}
|
|
|
if (GET_CODE (exp) == code)
|
if (GET_CODE (exp) == code)
|
{
|
{
|
rtx new_rtx = insert_right_side (code, XEXP (exp, 1),
|
rtx new_rtx = insert_right_side (code, XEXP (exp, 1),
|
term, insn_code, insn_index);
|
term, insn_code, insn_index);
|
if (new_rtx != XEXP (exp, 1))
|
if (new_rtx != XEXP (exp, 1))
|
/* Make a copy of this expression and call recursively. */
|
/* Make a copy of this expression and call recursively. */
|
newexp = attr_rtx (code, XEXP (exp, 0), new_rtx);
|
newexp = attr_rtx (code, XEXP (exp, 0), new_rtx);
|
else
|
else
|
newexp = exp;
|
newexp = exp;
|
}
|
}
|
else
|
else
|
{
|
{
|
/* Insert the new term. */
|
/* Insert the new term. */
|
newexp = attr_rtx (code, exp, term);
|
newexp = attr_rtx (code, exp, term);
|
}
|
}
|
|
|
return simplify_test_exp_in_temp (newexp, insn_code, insn_index);
|
return simplify_test_exp_in_temp (newexp, insn_code, insn_index);
|
}
|
}
|
|
|
/* If we have an expression which AND's a bunch of
|
/* If we have an expression which AND's a bunch of
|
(not (eq_attrq "alternative" "n"))
|
(not (eq_attrq "alternative" "n"))
|
terms, we may have covered all or all but one of the possible alternatives.
|
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.
|
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
|
This routine is passed an expression and either AND or IOR. It returns a
|
bitmask indicating which alternatives are mentioned within EXP. */
|
bitmask indicating which alternatives are mentioned within EXP. */
|
|
|
static int
|
static int
|
compute_alternative_mask (rtx exp, enum rtx_code code)
|
compute_alternative_mask (rtx exp, enum rtx_code code)
|
{
|
{
|
const char *string;
|
const char *string;
|
if (GET_CODE (exp) == code)
|
if (GET_CODE (exp) == code)
|
return compute_alternative_mask (XEXP (exp, 0), code)
|
return compute_alternative_mask (XEXP (exp, 0), code)
|
| compute_alternative_mask (XEXP (exp, 1), code);
|
| compute_alternative_mask (XEXP (exp, 1), code);
|
|
|
else if (code == AND && GET_CODE (exp) == NOT
|
else if (code == AND && GET_CODE (exp) == NOT
|
&& GET_CODE (XEXP (exp, 0)) == EQ_ATTR
|
&& GET_CODE (XEXP (exp, 0)) == EQ_ATTR
|
&& XSTR (XEXP (exp, 0), 0) == alternative_name)
|
&& XSTR (XEXP (exp, 0), 0) == alternative_name)
|
string = XSTR (XEXP (exp, 0), 1);
|
string = XSTR (XEXP (exp, 0), 1);
|
|
|
else if (code == IOR && GET_CODE (exp) == EQ_ATTR
|
else if (code == IOR && GET_CODE (exp) == EQ_ATTR
|
&& XSTR (exp, 0) == alternative_name)
|
&& XSTR (exp, 0) == alternative_name)
|
string = XSTR (exp, 1);
|
string = XSTR (exp, 1);
|
|
|
else if (GET_CODE (exp) == EQ_ATTR_ALT)
|
else if (GET_CODE (exp) == EQ_ATTR_ALT)
|
{
|
{
|
if (code == AND && XINT (exp, 1))
|
if (code == AND && XINT (exp, 1))
|
return XINT (exp, 0);
|
return XINT (exp, 0);
|
|
|
if (code == IOR && !XINT (exp, 1))
|
if (code == IOR && !XINT (exp, 1))
|
return XINT (exp, 0);
|
return XINT (exp, 0);
|
|
|
return 0;
|
return 0;
|
}
|
}
|
else
|
else
|
return 0;
|
return 0;
|
|
|
if (string[1] == 0)
|
if (string[1] == 0)
|
return 1 << (string[0] - '0');
|
return 1 << (string[0] - '0');
|
return 1 << atoi (string);
|
return 1 << atoi (string);
|
}
|
}
|
|
|
/* Given I, a single-bit mask, return RTX to compare the `alternative'
|
/* Given I, a single-bit mask, return RTX to compare the `alternative'
|
attribute with the value represented by that bit. */
|
attribute with the value represented by that bit. */
|
|
|
static rtx
|
static rtx
|
make_alternative_compare (int mask)
|
make_alternative_compare (int mask)
|
{
|
{
|
return mk_attr_alt (mask);
|
return mk_attr_alt (mask);
|
}
|
}
|
|
|
/* If we are processing an (eq_attr "attr" "value") test, we find the value
|
/* 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
|
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
|
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
|
computation. If a test condition involves an address, we leave the EQ_ATTR
|
intact because addresses are only valid for the `length' attribute.
|
intact because addresses are only valid for the `length' attribute.
|
|
|
EXP is the EQ_ATTR expression and VALUE is the value of that attribute
|
EXP is the EQ_ATTR expression and VALUE is the value of that attribute
|
for the insn corresponding to INSN_CODE and INSN_INDEX. */
|
for the insn corresponding to INSN_CODE and INSN_INDEX. */
|
|
|
static rtx
|
static rtx
|
evaluate_eq_attr (rtx exp, rtx value, int insn_code, int insn_index)
|
evaluate_eq_attr (rtx exp, rtx value, int insn_code, int insn_index)
|
{
|
{
|
rtx orexp, andexp;
|
rtx orexp, andexp;
|
rtx right;
|
rtx right;
|
rtx newexp;
|
rtx newexp;
|
int i;
|
int i;
|
|
|
switch (GET_CODE (value))
|
switch (GET_CODE (value))
|
{
|
{
|
case CONST_STRING:
|
case CONST_STRING:
|
if (! strcmp_check (XSTR (value, 0), XSTR (exp, 1)))
|
if (! strcmp_check (XSTR (value, 0), XSTR (exp, 1)))
|
newexp = true_rtx;
|
newexp = true_rtx;
|
else
|
else
|
newexp = false_rtx;
|
newexp = false_rtx;
|
break;
|
break;
|
|
|
case SYMBOL_REF:
|
case SYMBOL_REF:
|
{
|
{
|
char *p;
|
char *p;
|
char string[256];
|
char string[256];
|
|
|
gcc_assert (GET_CODE (exp) == EQ_ATTR);
|
gcc_assert (GET_CODE (exp) == EQ_ATTR);
|
gcc_assert (strlen (XSTR (exp, 0)) + strlen (XSTR (exp, 1)) + 2
|
gcc_assert (strlen (XSTR (exp, 0)) + strlen (XSTR (exp, 1)) + 2
|
<= 256);
|
<= 256);
|
|
|
strcpy (string, XSTR (exp, 0));
|
strcpy (string, XSTR (exp, 0));
|
strcat (string, "_");
|
strcat (string, "_");
|
strcat (string, XSTR (exp, 1));
|
strcat (string, XSTR (exp, 1));
|
for (p = string; *p; p++)
|
for (p = string; *p; p++)
|
*p = TOUPPER (*p);
|
*p = TOUPPER (*p);
|
|
|
newexp = attr_rtx (EQ, value,
|
newexp = attr_rtx (EQ, value,
|
attr_rtx (SYMBOL_REF,
|
attr_rtx (SYMBOL_REF,
|
DEF_ATTR_STRING (string)));
|
DEF_ATTR_STRING (string)));
|
break;
|
break;
|
}
|
}
|
|
|
case COND:
|
case COND:
|
/* We construct an IOR of all the cases for which the
|
/* We construct an IOR of all the cases for which the
|
requested attribute value is present. Since we start with
|
requested attribute value is present. Since we start with
|
FALSE, if it is not present, FALSE will be returned.
|
FALSE, if it is not present, FALSE will be returned.
|
|
|
Each case is the AND of the NOT's of the previous conditions with the
|
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.
|
current condition; in the default case the current condition is TRUE.
|
|
|
For each possible COND value, call ourselves recursively.
|
For each possible COND value, call ourselves recursively.
|
|
|
The extra TRUE and FALSE expressions will be eliminated by another
|
The extra TRUE and FALSE expressions will be eliminated by another
|
call to the simplification routine. */
|
call to the simplification routine. */
|
|
|
orexp = false_rtx;
|
orexp = false_rtx;
|
andexp = true_rtx;
|
andexp = true_rtx;
|
|
|
for (i = 0; i < XVECLEN (value, 0); i += 2)
|
for (i = 0; i < XVECLEN (value, 0); i += 2)
|
{
|
{
|
rtx this_cond = simplify_test_exp_in_temp (XVECEXP (value, 0, i),
|
rtx this_cond = simplify_test_exp_in_temp (XVECEXP (value, 0, i),
|
insn_code, insn_index);
|
insn_code, insn_index);
|
|
|
right = insert_right_side (AND, andexp, this_cond,
|
right = insert_right_side (AND, andexp, this_cond,
|
insn_code, insn_index);
|
insn_code, insn_index);
|
right = insert_right_side (AND, right,
|
right = insert_right_side (AND, right,
|
evaluate_eq_attr (exp,
|
evaluate_eq_attr (exp,
|
XVECEXP (value, 0,
|
XVECEXP (value, 0,
|
i + 1),
|
i + 1),
|
insn_code, insn_index),
|
insn_code, insn_index),
|
insn_code, insn_index);
|
insn_code, insn_index);
|
orexp = insert_right_side (IOR, orexp, right,
|
orexp = insert_right_side (IOR, orexp, right,
|
insn_code, insn_index);
|
insn_code, insn_index);
|
|
|
/* Add this condition into the AND expression. */
|
/* Add this condition into the AND expression. */
|
newexp = attr_rtx (NOT, this_cond);
|
newexp = attr_rtx (NOT, this_cond);
|
andexp = insert_right_side (AND, andexp, newexp,
|
andexp = insert_right_side (AND, andexp, newexp,
|
insn_code, insn_index);
|
insn_code, insn_index);
|
}
|
}
|
|
|
/* Handle the default case. */
|
/* Handle the default case. */
|
right = insert_right_side (AND, andexp,
|
right = insert_right_side (AND, andexp,
|
evaluate_eq_attr (exp, XEXP (value, 1),
|
evaluate_eq_attr (exp, XEXP (value, 1),
|
insn_code, insn_index),
|
insn_code, insn_index),
|
insn_code, insn_index);
|
insn_code, insn_index);
|
newexp = insert_right_side (IOR, orexp, right, insn_code, insn_index);
|
newexp = insert_right_side (IOR, orexp, right, insn_code, insn_index);
|
break;
|
break;
|
|
|
default:
|
default:
|
gcc_unreachable ();
|
gcc_unreachable ();
|
}
|
}
|
|
|
/* If uses an address, must return original expression. But set the
|
/* If uses an address, must return original expression. But set the
|
ATTR_IND_SIMPLIFIED_P bit so we don't try to simplify it again. */
|
ATTR_IND_SIMPLIFIED_P bit so we don't try to simplify it again. */
|
|
|
address_used = 0;
|
address_used = 0;
|
walk_attr_value (newexp);
|
walk_attr_value (newexp);
|
|
|
if (address_used)
|
if (address_used)
|
{
|
{
|
if (! ATTR_IND_SIMPLIFIED_P (exp))
|
if (! ATTR_IND_SIMPLIFIED_P (exp))
|
return copy_rtx_unchanging (exp);
|
return copy_rtx_unchanging (exp);
|
return exp;
|
return exp;
|
}
|
}
|
else
|
else
|
return newexp;
|
return newexp;
|
}
|
}
|
|
|
/* This routine is called when an AND of a term with a tree of AND's is
|
/* 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
|
encountered. If the term or its complement is present in the tree, it
|
can be replaced with TRUE or FALSE, respectively.
|
can be replaced with TRUE or FALSE, respectively.
|
|
|
Note that (eq_attr "att" "v1") and (eq_attr "att" "v2") cannot both
|
Note that (eq_attr "att" "v1") and (eq_attr "att" "v2") cannot both
|
be true and hence are complementary.
|
be true and hence are complementary.
|
|
|
There is one special case: If we see
|
There is one special case: If we see
|
(and (not (eq_attr "att" "v1"))
|
(and (not (eq_attr "att" "v1"))
|
(eq_attr "att" "v2"))
|
(eq_attr "att" "v2"))
|
this can be replaced by (eq_attr "att" "v2"). To do this we need to
|
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
|
replace the term, not anything in the AND tree. So we pass a pointer to
|
the term. */
|
the term. */
|
|
|
static rtx
|
static rtx
|
simplify_and_tree (rtx exp, rtx *pterm, int insn_code, int insn_index)
|
simplify_and_tree (rtx exp, rtx *pterm, int insn_code, int insn_index)
|
{
|
{
|
rtx left, right;
|
rtx left, right;
|
rtx newexp;
|
rtx newexp;
|
rtx temp;
|
rtx temp;
|
int left_eliminates_term, right_eliminates_term;
|
int left_eliminates_term, right_eliminates_term;
|
|
|
if (GET_CODE (exp) == AND)
|
if (GET_CODE (exp) == AND)
|
{
|
{
|
left = simplify_and_tree (XEXP (exp, 0), pterm, insn_code, insn_index);
|
left = simplify_and_tree (XEXP (exp, 0), pterm, insn_code, insn_index);
|
right = simplify_and_tree (XEXP (exp, 1), 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))
|
if (left != XEXP (exp, 0) || right != XEXP (exp, 1))
|
{
|
{
|
newexp = attr_rtx (AND, left, right);
|
newexp = attr_rtx (AND, left, right);
|
|
|
exp = simplify_test_exp_in_temp (newexp, insn_code, insn_index);
|
exp = simplify_test_exp_in_temp (newexp, insn_code, insn_index);
|
}
|
}
|
}
|
}
|
|
|
else if (GET_CODE (exp) == IOR)
|
else if (GET_CODE (exp) == IOR)
|
{
|
{
|
/* For the IOR case, we do the same as above, except that we can
|
/* 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. */
|
only eliminate `term' if both sides of the IOR would do so. */
|
temp = *pterm;
|
temp = *pterm;
|
left = simplify_and_tree (XEXP (exp, 0), &temp, insn_code, insn_index);
|
left = simplify_and_tree (XEXP (exp, 0), &temp, insn_code, insn_index);
|
left_eliminates_term = (temp == true_rtx);
|
left_eliminates_term = (temp == true_rtx);
|
|
|
temp = *pterm;
|
temp = *pterm;
|
right = simplify_and_tree (XEXP (exp, 1), &temp, insn_code, insn_index);
|
right = simplify_and_tree (XEXP (exp, 1), &temp, insn_code, insn_index);
|
right_eliminates_term = (temp == true_rtx);
|
right_eliminates_term = (temp == true_rtx);
|
|
|
if (left_eliminates_term && right_eliminates_term)
|
if (left_eliminates_term && right_eliminates_term)
|
*pterm = true_rtx;
|
*pterm = true_rtx;
|
|
|
if (left != XEXP (exp, 0) || right != XEXP (exp, 1))
|
if (left != XEXP (exp, 0) || right != XEXP (exp, 1))
|
{
|
{
|
newexp = attr_rtx (IOR, left, right);
|
newexp = attr_rtx (IOR, left, right);
|
|
|
exp = simplify_test_exp_in_temp (newexp, insn_code, insn_index);
|
exp = simplify_test_exp_in_temp (newexp, insn_code, insn_index);
|
}
|
}
|
}
|
}
|
|
|
/* Check for simplifications. Do some extra checking here since this
|
/* Check for simplifications. Do some extra checking here since this
|
routine is called so many times. */
|
routine is called so many times. */
|
|
|
if (exp == *pterm)
|
if (exp == *pterm)
|
return true_rtx;
|
return true_rtx;
|
|
|
else if (GET_CODE (exp) == NOT && XEXP (exp, 0) == *pterm)
|
else if (GET_CODE (exp) == NOT && XEXP (exp, 0) == *pterm)
|
return false_rtx;
|
return false_rtx;
|
|
|
else if (GET_CODE (*pterm) == NOT && exp == XEXP (*pterm, 0))
|
else if (GET_CODE (*pterm) == NOT && exp == XEXP (*pterm, 0))
|
return false_rtx;
|
return false_rtx;
|
|
|
else if (GET_CODE (exp) == EQ_ATTR_ALT && GET_CODE (*pterm) == EQ_ATTR_ALT)
|
else if (GET_CODE (exp) == EQ_ATTR_ALT && GET_CODE (*pterm) == EQ_ATTR_ALT)
|
{
|
{
|
if (attr_alt_subset_p (*pterm, exp))
|
if (attr_alt_subset_p (*pterm, exp))
|
return true_rtx;
|
return true_rtx;
|
|
|
if (attr_alt_subset_of_compl_p (*pterm, exp))
|
if (attr_alt_subset_of_compl_p (*pterm, exp))
|
return false_rtx;
|
return false_rtx;
|
|
|
if (attr_alt_subset_p (exp, *pterm))
|
if (attr_alt_subset_p (exp, *pterm))
|
*pterm = true_rtx;
|
*pterm = true_rtx;
|
|
|
return exp;
|
return exp;
|
}
|
}
|
|
|
else if (GET_CODE (exp) == EQ_ATTR && GET_CODE (*pterm) == EQ_ATTR)
|
else if (GET_CODE (exp) == EQ_ATTR && GET_CODE (*pterm) == EQ_ATTR)
|
{
|
{
|
if (XSTR (exp, 0) != XSTR (*pterm, 0))
|
if (XSTR (exp, 0) != XSTR (*pterm, 0))
|
return exp;
|
return exp;
|
|
|
if (! strcmp_check (XSTR (exp, 1), XSTR (*pterm, 1)))
|
if (! strcmp_check (XSTR (exp, 1), XSTR (*pterm, 1)))
|
return true_rtx;
|
return true_rtx;
|
else
|
else
|
return false_rtx;
|
return false_rtx;
|
}
|
}
|
|
|
else if (GET_CODE (*pterm) == EQ_ATTR && GET_CODE (exp) == NOT
|
else if (GET_CODE (*pterm) == EQ_ATTR && GET_CODE (exp) == NOT
|
&& GET_CODE (XEXP (exp, 0)) == EQ_ATTR)
|
&& GET_CODE (XEXP (exp, 0)) == EQ_ATTR)
|
{
|
{
|
if (XSTR (*pterm, 0) != XSTR (XEXP (exp, 0), 0))
|
if (XSTR (*pterm, 0) != XSTR (XEXP (exp, 0), 0))
|
return exp;
|
return exp;
|
|
|
if (! strcmp_check (XSTR (*pterm, 1), XSTR (XEXP (exp, 0), 1)))
|
if (! strcmp_check (XSTR (*pterm, 1), XSTR (XEXP (exp, 0), 1)))
|
return false_rtx;
|
return false_rtx;
|
else
|
else
|
return true_rtx;
|
return true_rtx;
|
}
|
}
|
|
|
else if (GET_CODE (exp) == EQ_ATTR && GET_CODE (*pterm) == NOT
|
else if (GET_CODE (exp) == EQ_ATTR && GET_CODE (*pterm) == NOT
|
&& GET_CODE (XEXP (*pterm, 0)) == EQ_ATTR)
|
&& GET_CODE (XEXP (*pterm, 0)) == EQ_ATTR)
|
{
|
{
|
if (XSTR (exp, 0) != XSTR (XEXP (*pterm, 0), 0))
|
if (XSTR (exp, 0) != XSTR (XEXP (*pterm, 0), 0))
|
return exp;
|
return exp;
|
|
|
if (! strcmp_check (XSTR (exp, 1), XSTR (XEXP (*pterm, 0), 1)))
|
if (! strcmp_check (XSTR (exp, 1), XSTR (XEXP (*pterm, 0), 1)))
|
return false_rtx;
|
return false_rtx;
|
else
|
else
|
*pterm = true_rtx;
|
*pterm = true_rtx;
|
}
|
}
|
|
|
else if (GET_CODE (exp) == NOT && GET_CODE (*pterm) == NOT)
|
else if (GET_CODE (exp) == NOT && GET_CODE (*pterm) == NOT)
|
{
|
{
|
if (attr_equal_p (XEXP (exp, 0), XEXP (*pterm, 0)))
|
if (attr_equal_p (XEXP (exp, 0), XEXP (*pterm, 0)))
|
return true_rtx;
|
return true_rtx;
|
}
|
}
|
|
|
else if (GET_CODE (exp) == NOT)
|
else if (GET_CODE (exp) == NOT)
|
{
|
{
|
if (attr_equal_p (XEXP (exp, 0), *pterm))
|
if (attr_equal_p (XEXP (exp, 0), *pterm))
|
return false_rtx;
|
return false_rtx;
|
}
|
}
|
|
|
else if (GET_CODE (*pterm) == NOT)
|
else if (GET_CODE (*pterm) == NOT)
|
{
|
{
|
if (attr_equal_p (XEXP (*pterm, 0), exp))
|
if (attr_equal_p (XEXP (*pterm, 0), exp))
|
return false_rtx;
|
return false_rtx;
|
}
|
}
|
|
|
else if (attr_equal_p (exp, *pterm))
|
else if (attr_equal_p (exp, *pterm))
|
return true_rtx;
|
return true_rtx;
|
|
|
return exp;
|
return exp;
|
}
|
}
|
|
|
/* Similar to `simplify_and_tree', but for IOR trees. */
|
/* Similar to `simplify_and_tree', but for IOR trees. */
|
|
|
static rtx
|
static rtx
|
simplify_or_tree (rtx exp, rtx *pterm, int insn_code, int insn_index)
|
simplify_or_tree (rtx exp, rtx *pterm, int insn_code, int insn_index)
|
{
|
{
|
rtx left, right;
|
rtx left, right;
|
rtx newexp;
|
rtx newexp;
|
rtx temp;
|
rtx temp;
|
int left_eliminates_term, right_eliminates_term;
|
int left_eliminates_term, right_eliminates_term;
|
|
|
if (GET_CODE (exp) == IOR)
|
if (GET_CODE (exp) == IOR)
|
{
|
{
|
left = simplify_or_tree (XEXP (exp, 0), pterm, insn_code, insn_index);
|
left = simplify_or_tree (XEXP (exp, 0), pterm, insn_code, insn_index);
|
right = simplify_or_tree (XEXP (exp, 1), 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))
|
if (left != XEXP (exp, 0) || right != XEXP (exp, 1))
|
{
|
{
|
newexp = attr_rtx (GET_CODE (exp), left, right);
|
newexp = attr_rtx (GET_CODE (exp), left, right);
|
|
|
exp = simplify_test_exp_in_temp (newexp, insn_code, insn_index);
|
exp = simplify_test_exp_in_temp (newexp, insn_code, insn_index);
|
}
|
}
|
}
|
}
|
|
|
else if (GET_CODE (exp) == AND)
|
else if (GET_CODE (exp) == AND)
|
{
|
{
|
/* For the AND case, we do the same as above, except that we can
|
/* 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. */
|
only eliminate `term' if both sides of the AND would do so. */
|
temp = *pterm;
|
temp = *pterm;
|
left = simplify_or_tree (XEXP (exp, 0), &temp, insn_code, insn_index);
|
left = simplify_or_tree (XEXP (exp, 0), &temp, insn_code, insn_index);
|
left_eliminates_term = (temp == false_rtx);
|
left_eliminates_term = (temp == false_rtx);
|
|
|
temp = *pterm;
|
temp = *pterm;
|
right = simplify_or_tree (XEXP (exp, 1), &temp, insn_code, insn_index);
|
right = simplify_or_tree (XEXP (exp, 1), &temp, insn_code, insn_index);
|
right_eliminates_term = (temp == false_rtx);
|
right_eliminates_term = (temp == false_rtx);
|
|
|
if (left_eliminates_term && right_eliminates_term)
|
if (left_eliminates_term && right_eliminates_term)
|
*pterm = false_rtx;
|
*pterm = false_rtx;
|
|
|
if (left != XEXP (exp, 0) || right != XEXP (exp, 1))
|
if (left != XEXP (exp, 0) || right != XEXP (exp, 1))
|
{
|
{
|
newexp = attr_rtx (GET_CODE (exp), left, right);
|
newexp = attr_rtx (GET_CODE (exp), left, right);
|
|
|
exp = simplify_test_exp_in_temp (newexp, insn_code, insn_index);
|
exp = simplify_test_exp_in_temp (newexp, insn_code, insn_index);
|
}
|
}
|
}
|
}
|
|
|
if (attr_equal_p (exp, *pterm))
|
if (attr_equal_p (exp, *pterm))
|
return false_rtx;
|
return false_rtx;
|
|
|
else if (GET_CODE (exp) == NOT && attr_equal_p (XEXP (exp, 0), *pterm))
|
else if (GET_CODE (exp) == NOT && attr_equal_p (XEXP (exp, 0), *pterm))
|
return true_rtx;
|
return true_rtx;
|
|
|
else if (GET_CODE (*pterm) == NOT && attr_equal_p (XEXP (*pterm, 0), exp))
|
else if (GET_CODE (*pterm) == NOT && attr_equal_p (XEXP (*pterm, 0), exp))
|
return true_rtx;
|
return true_rtx;
|
|
|
else if (GET_CODE (*pterm) == EQ_ATTR && GET_CODE (exp) == NOT
|
else if (GET_CODE (*pterm) == EQ_ATTR && GET_CODE (exp) == NOT
|
&& GET_CODE (XEXP (exp, 0)) == EQ_ATTR
|
&& GET_CODE (XEXP (exp, 0)) == EQ_ATTR
|
&& XSTR (*pterm, 0) == XSTR (XEXP (exp, 0), 0))
|
&& XSTR (*pterm, 0) == XSTR (XEXP (exp, 0), 0))
|
*pterm = false_rtx;
|
*pterm = false_rtx;
|
|
|
else if (GET_CODE (exp) == EQ_ATTR && GET_CODE (*pterm) == NOT
|
else if (GET_CODE (exp) == EQ_ATTR && GET_CODE (*pterm) == NOT
|
&& GET_CODE (XEXP (*pterm, 0)) == EQ_ATTR
|
&& GET_CODE (XEXP (*pterm, 0)) == EQ_ATTR
|
&& XSTR (exp, 0) == XSTR (XEXP (*pterm, 0), 0))
|
&& XSTR (exp, 0) == XSTR (XEXP (*pterm, 0), 0))
|
return false_rtx;
|
return false_rtx;
|
|
|
return exp;
|
return exp;
|
}
|
}
|
|
|
/* Compute approximate cost of the expression. Used to decide whether
|
/* Compute approximate cost of the expression. Used to decide whether
|
expression is cheap enough for inline. */
|
expression is cheap enough for inline. */
|
static int
|
static int
|
attr_rtx_cost (rtx x)
|
attr_rtx_cost (rtx x)
|
{
|
{
|
int cost = 0;
|
int cost = 0;
|
enum rtx_code code;
|
enum rtx_code code;
|
if (!x)
|
if (!x)
|
return 0;
|
return 0;
|
code = GET_CODE (x);
|
code = GET_CODE (x);
|
switch (code)
|
switch (code)
|
{
|
{
|
case MATCH_OPERAND:
|
case MATCH_OPERAND:
|
if (XSTR (x, 1)[0])
|
if (XSTR (x, 1)[0])
|
return 10;
|
return 10;
|
else
|
else
|
return 0;
|
return 0;
|
|
|
case EQ_ATTR_ALT:
|
case EQ_ATTR_ALT:
|
return 0;
|
return 0;
|
|
|
case EQ_ATTR:
|
case EQ_ATTR:
|
/* Alternatives don't result into function call. */
|
/* Alternatives don't result into function call. */
|
if (!strcmp_check (XSTR (x, 0), alternative_name))
|
if (!strcmp_check (XSTR (x, 0), alternative_name))
|
return 0;
|
return 0;
|
else
|
else
|
return 5;
|
return 5;
|
default:
|
default:
|
{
|
{
|
int i, j;
|
int i, j;
|
const char *fmt = GET_RTX_FORMAT (code);
|
const char *fmt = GET_RTX_FORMAT (code);
|
for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
|
for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
|
{
|
{
|
switch (fmt[i])
|
switch (fmt[i])
|
{
|
{
|
case 'V':
|
case 'V':
|
case 'E':
|
case 'E':
|
for (j = 0; j < XVECLEN (x, i); j++)
|
for (j = 0; j < XVECLEN (x, i); j++)
|
cost += attr_rtx_cost (XVECEXP (x, i, j));
|
cost += attr_rtx_cost (XVECEXP (x, i, j));
|
break;
|
break;
|
case 'e':
|
case 'e':
|
cost += attr_rtx_cost (XEXP (x, i));
|
cost += attr_rtx_cost (XEXP (x, i));
|
break;
|
break;
|
}
|
}
|
}
|
}
|
}
|
}
|
break;
|
break;
|
}
|
}
|
return cost;
|
return cost;
|
}
|
}
|
|
|
/* Simplify test expression and use temporary obstack in order to avoid
|
/* Simplify test expression and use temporary obstack in order to avoid
|
memory bloat. Use ATTR_IND_SIMPLIFIED to avoid unnecessary simplifications
|
memory bloat. Use ATTR_IND_SIMPLIFIED to avoid unnecessary simplifications
|
and avoid unnecessary copying if possible. */
|
and avoid unnecessary copying if possible. */
|
|
|
static rtx
|
static rtx
|
simplify_test_exp_in_temp (rtx exp, int insn_code, int insn_index)
|
simplify_test_exp_in_temp (rtx exp, int insn_code, int insn_index)
|
{
|
{
|
rtx x;
|
rtx x;
|
struct obstack *old;
|
struct obstack *old;
|
if (ATTR_IND_SIMPLIFIED_P (exp))
|
if (ATTR_IND_SIMPLIFIED_P (exp))
|
return exp;
|
return exp;
|
old = rtl_obstack;
|
old = rtl_obstack;
|
rtl_obstack = temp_obstack;
|
rtl_obstack = temp_obstack;
|
x = simplify_test_exp (exp, insn_code, insn_index);
|
x = simplify_test_exp (exp, insn_code, insn_index);
|
rtl_obstack = old;
|
rtl_obstack = old;
|
if (x == exp || rtl_obstack == temp_obstack)
|
if (x == exp || rtl_obstack == temp_obstack)
|
return x;
|
return x;
|
return attr_copy_rtx (x);
|
return attr_copy_rtx (x);
|
}
|
}
|
|
|
/* Returns true if S1 is a subset of S2. */
|
/* Returns true if S1 is a subset of S2. */
|
|
|
static bool
|
static bool
|
attr_alt_subset_p (rtx s1, rtx s2)
|
attr_alt_subset_p (rtx s1, rtx s2)
|
{
|
{
|
switch ((XINT (s1, 1) << 1) | XINT (s2, 1))
|
switch ((XINT (s1, 1) << 1) | XINT (s2, 1))
|
{
|
{
|
case (0 << 1) | 0:
|
case (0 << 1) | 0:
|
return !(XINT (s1, 0) &~ XINT (s2, 0));
|
return !(XINT (s1, 0) &~ XINT (s2, 0));
|
|
|
case (0 << 1) | 1:
|
case (0 << 1) | 1:
|
return !(XINT (s1, 0) & XINT (s2, 0));
|
return !(XINT (s1, 0) & XINT (s2, 0));
|
|
|
case (1 << 1) | 0:
|
case (1 << 1) | 0:
|
return false;
|
return false;
|
|
|
case (1 << 1) | 1:
|
case (1 << 1) | 1:
|
return !(XINT (s2, 0) &~ XINT (s1, 0));
|
return !(XINT (s2, 0) &~ XINT (s1, 0));
|
|
|
default:
|
default:
|
gcc_unreachable ();
|
gcc_unreachable ();
|
}
|
}
|
}
|
}
|
|
|
/* Returns true if S1 is a subset of complement of S2. */
|
/* Returns true if S1 is a subset of complement of S2. */
|
|
|
static bool
|
static bool
|
attr_alt_subset_of_compl_p (rtx s1, rtx s2)
|
attr_alt_subset_of_compl_p (rtx s1, rtx s2)
|
{
|
{
|
switch ((XINT (s1, 1) << 1) | XINT (s2, 1))
|
switch ((XINT (s1, 1) << 1) | XINT (s2, 1))
|
{
|
{
|
case (0 << 1) | 0:
|
case (0 << 1) | 0:
|
return !(XINT (s1, 0) & XINT (s2, 0));
|
return !(XINT (s1, 0) & XINT (s2, 0));
|
|
|
case (0 << 1) | 1:
|
case (0 << 1) | 1:
|
return !(XINT (s1, 0) & ~XINT (s2, 0));
|
return !(XINT (s1, 0) & ~XINT (s2, 0));
|
|
|
case (1 << 1) | 0:
|
case (1 << 1) | 0:
|
return !(XINT (s2, 0) &~ XINT (s1, 0));
|
return !(XINT (s2, 0) &~ XINT (s1, 0));
|
|
|
case (1 << 1) | 1:
|
case (1 << 1) | 1:
|
return false;
|
return false;
|
|
|
default:
|
default:
|
gcc_unreachable ();
|
gcc_unreachable ();
|
}
|
}
|
}
|
}
|
|
|
/* Return EQ_ATTR_ALT expression representing intersection of S1 and S2. */
|
/* Return EQ_ATTR_ALT expression representing intersection of S1 and S2. */
|
|
|
static rtx
|
static rtx
|
attr_alt_intersection (rtx s1, rtx s2)
|
attr_alt_intersection (rtx s1, rtx s2)
|
{
|
{
|
rtx result = rtx_alloc (EQ_ATTR_ALT);
|
rtx result = rtx_alloc (EQ_ATTR_ALT);
|
|
|
switch ((XINT (s1, 1) << 1) | XINT (s2, 1))
|
switch ((XINT (s1, 1) << 1) | XINT (s2, 1))
|
{
|
{
|
case (0 << 1) | 0:
|
case (0 << 1) | 0:
|
XINT (result, 0) = XINT (s1, 0) & XINT (s2, 0);
|
XINT (result, 0) = XINT (s1, 0) & XINT (s2, 0);
|
break;
|
break;
|
case (0 << 1) | 1:
|
case (0 << 1) | 1:
|
XINT (result, 0) = XINT (s1, 0) & ~XINT (s2, 0);
|
XINT (result, 0) = XINT (s1, 0) & ~XINT (s2, 0);
|
break;
|
break;
|
case (1 << 1) | 0:
|
case (1 << 1) | 0:
|
XINT (result, 0) = XINT (s2, 0) & ~XINT (s1, 0);
|
XINT (result, 0) = XINT (s2, 0) & ~XINT (s1, 0);
|
break;
|
break;
|
case (1 << 1) | 1:
|
case (1 << 1) | 1:
|
XINT (result, 0) = XINT (s1, 0) | XINT (s2, 0);
|
XINT (result, 0) = XINT (s1, 0) | XINT (s2, 0);
|
break;
|
break;
|
default:
|
default:
|
gcc_unreachable ();
|
gcc_unreachable ();
|
}
|
}
|
XINT (result, 1) = XINT (s1, 1) & XINT (s2, 1);
|
XINT (result, 1) = XINT (s1, 1) & XINT (s2, 1);
|
|
|
return result;
|
return result;
|
}
|
}
|
|
|
/* Return EQ_ATTR_ALT expression representing union of S1 and S2. */
|
/* Return EQ_ATTR_ALT expression representing union of S1 and S2. */
|
|
|
static rtx
|
static rtx
|
attr_alt_union (rtx s1, rtx s2)
|
attr_alt_union (rtx s1, rtx s2)
|
{
|
{
|
rtx result = rtx_alloc (EQ_ATTR_ALT);
|
rtx result = rtx_alloc (EQ_ATTR_ALT);
|
|
|
switch ((XINT (s1, 1) << 1) | XINT (s2, 1))
|
switch ((XINT (s1, 1) << 1) | XINT (s2, 1))
|
{
|
{
|
case (0 << 1) | 0:
|
case (0 << 1) | 0:
|
XINT (result, 0) = XINT (s1, 0) | XINT (s2, 0);
|
XINT (result, 0) = XINT (s1, 0) | XINT (s2, 0);
|
break;
|
break;
|
case (0 << 1) | 1:
|
case (0 << 1) | 1:
|
XINT (result, 0) = XINT (s2, 0) & ~XINT (s1, 0);
|
XINT (result, 0) = XINT (s2, 0) & ~XINT (s1, 0);
|
break;
|
break;
|
case (1 << 1) | 0:
|
case (1 << 1) | 0:
|
XINT (result, 0) = XINT (s1, 0) & ~XINT (s2, 0);
|
XINT (result, 0) = XINT (s1, 0) & ~XINT (s2, 0);
|
break;
|
break;
|
case (1 << 1) | 1:
|
case (1 << 1) | 1:
|
XINT (result, 0) = XINT (s1, 0) & XINT (s2, 0);
|
XINT (result, 0) = XINT (s1, 0) & XINT (s2, 0);
|
break;
|
break;
|
default:
|
default:
|
gcc_unreachable ();
|
gcc_unreachable ();
|
}
|
}
|
|
|
XINT (result, 1) = XINT (s1, 1) | XINT (s2, 1);
|
XINT (result, 1) = XINT (s1, 1) | XINT (s2, 1);
|
return result;
|
return result;
|
}
|
}
|
|
|
/* Return EQ_ATTR_ALT expression representing complement of S. */
|
/* Return EQ_ATTR_ALT expression representing complement of S. */
|
|
|
static rtx
|
static rtx
|
attr_alt_complement (rtx s)
|
attr_alt_complement (rtx s)
|
{
|
{
|
rtx result = rtx_alloc (EQ_ATTR_ALT);
|
rtx result = rtx_alloc (EQ_ATTR_ALT);
|
|
|
XINT (result, 0) = XINT (s, 0);
|
XINT (result, 0) = XINT (s, 0);
|
XINT (result, 1) = 1 - XINT (s, 1);
|
XINT (result, 1) = 1 - XINT (s, 1);
|
|
|
return result;
|
return result;
|
}
|
}
|
|
|
/* Return EQ_ATTR_ALT expression representing set containing elements set
|
/* Return EQ_ATTR_ALT expression representing set containing elements set
|
in E. */
|
in E. */
|
|
|
static rtx
|
static rtx
|
mk_attr_alt (int e)
|
mk_attr_alt (int e)
|
{
|
{
|
rtx result = rtx_alloc (EQ_ATTR_ALT);
|
rtx result = rtx_alloc (EQ_ATTR_ALT);
|
|
|
XINT (result, 0) = e;
|
XINT (result, 0) = e;
|
XINT (result, 1) = 0;
|
XINT (result, 1) = 0;
|
|
|
return result;
|
return result;
|
}
|
}
|
|
|
/* Given an expression, see if it can be simplified for a particular insn
|
/* 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
|
code based on the values of other attributes being tested. This can
|
eliminate nested get_attr_... calls.
|
eliminate nested get_attr_... calls.
|
|
|
Note that if an endless recursion is specified in the patterns, the
|
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
|
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
|
an infinite recursion loop could occur during compilation. It's better that
|
it occurs here! */
|
it occurs here! */
|
|
|
static rtx
|
static rtx
|
simplify_test_exp (rtx exp, int insn_code, int insn_index)
|
simplify_test_exp (rtx exp, int insn_code, int insn_index)
|
{
|
{
|
rtx left, right;
|
rtx left, right;
|
struct attr_desc *attr;
|
struct attr_desc *attr;
|
struct attr_value *av;
|
struct attr_value *av;
|
struct insn_ent *ie;
|
struct insn_ent *ie;
|
struct attr_value_list *iv;
|
struct attr_value_list *iv;
|
int i;
|
int i;
|
rtx newexp = exp;
|
rtx newexp = exp;
|
bool left_alt, right_alt;
|
bool left_alt, right_alt;
|
|
|
/* Don't re-simplify something we already simplified. */
|
/* Don't re-simplify something we already simplified. */
|
if (ATTR_IND_SIMPLIFIED_P (exp) || ATTR_CURR_SIMPLIFIED_P (exp))
|
if (ATTR_IND_SIMPLIFIED_P (exp) || ATTR_CURR_SIMPLIFIED_P (exp))
|
return exp;
|
return exp;
|
|
|
switch (GET_CODE (exp))
|
switch (GET_CODE (exp))
|
{
|
{
|
case AND:
|
case AND:
|
left = SIMPLIFY_TEST_EXP (XEXP (exp, 0), insn_code, insn_index);
|
left = SIMPLIFY_TEST_EXP (XEXP (exp, 0), insn_code, insn_index);
|
if (left == false_rtx)
|
if (left == false_rtx)
|
return false_rtx;
|
return false_rtx;
|
right = SIMPLIFY_TEST_EXP (XEXP (exp, 1), insn_code, insn_index);
|
right = SIMPLIFY_TEST_EXP (XEXP (exp, 1), insn_code, insn_index);
|
if (right == false_rtx)
|
if (right == false_rtx)
|
return false_rtx;
|
return false_rtx;
|
|
|
if (GET_CODE (left) == EQ_ATTR_ALT
|
if (GET_CODE (left) == EQ_ATTR_ALT
|
&& GET_CODE (right) == EQ_ATTR_ALT)
|
&& GET_CODE (right) == EQ_ATTR_ALT)
|
{
|
{
|
exp = attr_alt_intersection (left, right);
|
exp = attr_alt_intersection (left, right);
|
return simplify_test_exp (exp, insn_code, insn_index);
|
return simplify_test_exp (exp, insn_code, insn_index);
|
}
|
}
|
|
|
/* If either side is an IOR and we have (eq_attr "alternative" ..")
|
/* If either side is an IOR and we have (eq_attr "alternative" ..")
|
present on both sides, apply the distributive law since this will
|
present on both sides, apply the distributive law since this will
|
yield simplifications. */
|
yield simplifications. */
|
if ((GET_CODE (left) == IOR || GET_CODE (right) == IOR)
|
if ((GET_CODE (left) == IOR || GET_CODE (right) == IOR)
|
&& compute_alternative_mask (left, IOR)
|
&& compute_alternative_mask (left, IOR)
|
&& compute_alternative_mask (right, IOR))
|
&& compute_alternative_mask (right, IOR))
|
{
|
{
|
if (GET_CODE (left) == IOR)
|
if (GET_CODE (left) == IOR)
|
{
|
{
|
rtx tem = left;
|
rtx tem = left;
|
left = right;
|
left = right;
|
right = tem;
|
right = tem;
|
}
|
}
|
|
|
newexp = attr_rtx (IOR,
|
newexp = attr_rtx (IOR,
|
attr_rtx (AND, left, XEXP (right, 0)),
|
attr_rtx (AND, left, XEXP (right, 0)),
|
attr_rtx (AND, left, XEXP (right, 1)));
|
attr_rtx (AND, left, XEXP (right, 1)));
|
|
|
return SIMPLIFY_TEST_EXP (newexp, insn_code, insn_index);
|
return SIMPLIFY_TEST_EXP (newexp, insn_code, insn_index);
|
}
|
}
|
|
|
/* Try with the term on both sides. */
|
/* Try with the term on both sides. */
|
right = simplify_and_tree (right, &left, insn_code, insn_index);
|
right = simplify_and_tree (right, &left, insn_code, insn_index);
|
if (left == XEXP (exp, 0) && right == XEXP (exp, 1))
|
if (left == XEXP (exp, 0) && right == XEXP (exp, 1))
|
left = simplify_and_tree (left, &right, insn_code, insn_index);
|
left = simplify_and_tree (left, &right, insn_code, insn_index);
|
|
|
if (left == false_rtx || right == false_rtx)
|
if (left == false_rtx || right == false_rtx)
|
return false_rtx;
|
return false_rtx;
|
else if (left == true_rtx)
|
else if (left == true_rtx)
|
{
|
{
|
return right;
|
return right;
|
}
|
}
|
else if (right == true_rtx)
|
else if (right == true_rtx)
|
{
|
{
|
return left;
|
return left;
|
}
|
}
|
/* See if all or all but one of the insn's alternatives are specified
|
/* See if all or all but one of the insn's alternatives are specified
|
in this tree. Optimize if so. */
|
in this tree. Optimize if so. */
|
|
|
if (GET_CODE (left) == NOT)
|
if (GET_CODE (left) == NOT)
|
left_alt = (GET_CODE (XEXP (left, 0)) == EQ_ATTR
|
left_alt = (GET_CODE (XEXP (left, 0)) == EQ_ATTR
|
&& XSTR (XEXP (left, 0), 0) == alternative_name);
|
&& XSTR (XEXP (left, 0), 0) == alternative_name);
|
else
|
else
|
left_alt = (GET_CODE (left) == EQ_ATTR_ALT
|
left_alt = (GET_CODE (left) == EQ_ATTR_ALT
|
&& XINT (left, 1));
|
&& XINT (left, 1));
|
|
|
if (GET_CODE (right) == NOT)
|
if (GET_CODE (right) == NOT)
|
right_alt = (GET_CODE (XEXP (right, 0)) == EQ_ATTR
|
right_alt = (GET_CODE (XEXP (right, 0)) == EQ_ATTR
|
&& XSTR (XEXP (right, 0), 0) == alternative_name);
|
&& XSTR (XEXP (right, 0), 0) == alternative_name);
|
else
|
else
|
right_alt = (GET_CODE (right) == EQ_ATTR_ALT
|
right_alt = (GET_CODE (right) == EQ_ATTR_ALT
|
&& XINT (right, 1));
|
&& XINT (right, 1));
|
|
|
if (insn_code >= 0
|
if (insn_code >= 0
|
&& (GET_CODE (left) == AND
|
&& (GET_CODE (left) == AND
|
|| left_alt
|
|| left_alt
|
|| GET_CODE (right) == AND
|
|| GET_CODE (right) == AND
|
|| right_alt))
|
|| right_alt))
|
{
|
{
|
i = compute_alternative_mask (exp, AND);
|
i = compute_alternative_mask (exp, AND);
|
if (i & ~insn_alternatives[insn_code])
|
if (i & ~insn_alternatives[insn_code])
|
fatal ("invalid alternative specified for pattern number %d",
|
fatal ("invalid alternative specified for pattern number %d",
|
insn_index);
|
insn_index);
|
|
|
/* If all alternatives are excluded, this is false. */
|
/* If all alternatives are excluded, this is false. */
|
i ^= insn_alternatives[insn_code];
|
i ^= insn_alternatives[insn_code];
|
if (i == 0)
|
if (i == 0)
|
return false_rtx;
|
return false_rtx;
|
else if ((i & (i - 1)) == 0 && insn_alternatives[insn_code] > 1)
|
else if ((i & (i - 1)) == 0 && insn_alternatives[insn_code] > 1)
|
{
|
{
|
/* If just one excluded, AND a comparison with that one to the
|
/* If just one excluded, AND a comparison with that one to the
|
front of the tree. The others will be eliminated by
|
front of the tree. The others will be eliminated by
|
optimization. We do not want to do this if the insn has one
|
optimization. We do not want to do this if the insn has one
|
alternative and we have tested none of them! */
|
alternative and we have tested none of them! */
|
left = make_alternative_compare (i);
|
left = make_alternative_compare (i);
|
right = simplify_and_tree (exp, &left, insn_code, insn_index);
|
right = simplify_and_tree (exp, &left, insn_code, insn_index);
|
newexp = attr_rtx (AND, left, right);
|
newexp = attr_rtx (AND, left, right);
|
|
|
return SIMPLIFY_TEST_EXP (newexp, insn_code, insn_index);
|
return SIMPLIFY_TEST_EXP (newexp, insn_code, insn_index);
|
}
|
}
|
}
|
}
|
|
|
if (left != XEXP (exp, 0) || right != XEXP (exp, 1))
|
if (left != XEXP (exp, 0) || right != XEXP (exp, 1))
|
{
|
{
|
newexp = attr_rtx (AND, left, right);
|
newexp = attr_rtx (AND, left, right);
|
return SIMPLIFY_TEST_EXP (newexp, insn_code, insn_index);
|
return SIMPLIFY_TEST_EXP (newexp, insn_code, insn_index);
|
}
|
}
|
break;
|
break;
|
|
|
case IOR:
|
case IOR:
|
left = SIMPLIFY_TEST_EXP (XEXP (exp, 0), insn_code, insn_index);
|
left = SIMPLIFY_TEST_EXP (XEXP (exp, 0), insn_code, insn_index);
|
if (left == true_rtx)
|
if (left == true_rtx)
|
return true_rtx;
|
return true_rtx;
|
right = SIMPLIFY_TEST_EXP (XEXP (exp, 1), insn_code, insn_index);
|
right = SIMPLIFY_TEST_EXP (XEXP (exp, 1), insn_code, insn_index);
|
if (right == true_rtx)
|
if (right == true_rtx)
|
return true_rtx;
|
return true_rtx;
|
|
|
if (GET_CODE (left) == EQ_ATTR_ALT
|
if (GET_CODE (left) == EQ_ATTR_ALT
|
&& GET_CODE (right) == EQ_ATTR_ALT)
|
&& GET_CODE (right) == EQ_ATTR_ALT)
|
{
|
{
|
exp = attr_alt_union (left, right);
|
exp = attr_alt_union (left, right);
|
return simplify_test_exp (exp, insn_code, insn_index);
|
return simplify_test_exp (exp, insn_code, insn_index);
|
}
|
}
|
|
|
right = simplify_or_tree (right, &left, insn_code, insn_index);
|
right = simplify_or_tree (right, &left, insn_code, insn_index);
|
if (left == XEXP (exp, 0) && right == XEXP (exp, 1))
|
if (left == XEXP (exp, 0) && right == XEXP (exp, 1))
|
left = simplify_or_tree (left, &right, insn_code, insn_index);
|
left = simplify_or_tree (left, &right, insn_code, insn_index);
|
|
|
if (right == true_rtx || left == true_rtx)
|
if (right == true_rtx || left == true_rtx)
|
return true_rtx;
|
return true_rtx;
|
else if (left == false_rtx)
|
else if (left == false_rtx)
|
{
|
{
|
return right;
|
return right;
|
}
|
}
|
else if (right == false_rtx)
|
else if (right == false_rtx)
|
{
|
{
|
return left;
|
return left;
|
}
|
}
|
|
|
/* Test for simple cases where the distributive law is useful. I.e.,
|
/* Test for simple cases where the distributive law is useful. I.e.,
|
convert (ior (and (x) (y))
|
convert (ior (and (x) (y))
|
(and (x) (z)))
|
(and (x) (z)))
|
to (and (x)
|
to (and (x)
|
(ior (y) (z)))
|
(ior (y) (z)))
|
*/
|
*/
|
|
|
else if (GET_CODE (left) == AND && GET_CODE (right) == AND
|
else if (GET_CODE (left) == AND && GET_CODE (right) == AND
|
&& attr_equal_p (XEXP (left, 0), XEXP (right, 0)))
|
&& attr_equal_p (XEXP (left, 0), XEXP (right, 0)))
|
{
|
{
|
newexp = attr_rtx (IOR, XEXP (left, 1), XEXP (right, 1));
|
newexp = attr_rtx (IOR, XEXP (left, 1), XEXP (right, 1));
|
|
|
left = XEXP (left, 0);
|
left = XEXP (left, 0);
|
right = newexp;
|
right = newexp;
|
newexp = attr_rtx (AND, left, right);
|
newexp = attr_rtx (AND, left, right);
|
return SIMPLIFY_TEST_EXP (newexp, insn_code, insn_index);
|
return SIMPLIFY_TEST_EXP (newexp, insn_code, insn_index);
|
}
|
}
|
|
|
/* See if all or all but one of the insn's alternatives are specified
|
/* See if all or all but one of the insn's alternatives are specified
|
in this tree. Optimize if so. */
|
in this tree. Optimize if so. */
|
|
|
else if (insn_code >= 0
|
else if (insn_code >= 0
|
&& (GET_CODE (left) == IOR
|
&& (GET_CODE (left) == IOR
|
|| (GET_CODE (left) == EQ_ATTR_ALT
|
|| (GET_CODE (left) == EQ_ATTR_ALT
|
&& !XINT (left, 1))
|
&& !XINT (left, 1))
|
|| (GET_CODE (left) == EQ_ATTR
|
|| (GET_CODE (left) == EQ_ATTR
|
&& XSTR (left, 0) == alternative_name)
|
&& XSTR (left, 0) == alternative_name)
|
|| GET_CODE (right) == IOR
|
|| GET_CODE (right) == IOR
|
|| (GET_CODE (right) == EQ_ATTR_ALT
|
|| (GET_CODE (right) == EQ_ATTR_ALT
|
&& !XINT (right, 1))
|
&& !XINT (right, 1))
|
|| (GET_CODE (right) == EQ_ATTR
|
|| (GET_CODE (right) == EQ_ATTR
|
&& XSTR (right, 0) == alternative_name)))
|
&& XSTR (right, 0) == alternative_name)))
|
{
|
{
|
i = compute_alternative_mask (exp, IOR);
|
i = compute_alternative_mask (exp, IOR);
|
if (i & ~insn_alternatives[insn_code])
|
if (i & ~insn_alternatives[insn_code])
|
fatal ("invalid alternative specified for pattern number %d",
|
fatal ("invalid alternative specified for pattern number %d",
|
insn_index);
|
insn_index);
|
|
|
/* If all alternatives are included, this is true. */
|
/* If all alternatives are included, this is true. */
|
i ^= insn_alternatives[insn_code];
|
i ^= insn_alternatives[insn_code];
|
if (i == 0)
|
if (i == 0)
|
return true_rtx;
|
return true_rtx;
|
else if ((i & (i - 1)) == 0 && insn_alternatives[insn_code] > 1)
|
else if ((i & (i - 1)) == 0 && insn_alternatives[insn_code] > 1)
|
{
|
{
|
/* If just one excluded, IOR a comparison with that one to the
|
/* If just one excluded, IOR a comparison with that one to the
|
front of the tree. The others will be eliminated by
|
front of the tree. The others will be eliminated by
|
optimization. We do not want to do this if the insn has one
|
optimization. We do not want to do this if the insn has one
|
alternative and we have tested none of them! */
|
alternative and we have tested none of them! */
|
left = make_alternative_compare (i);
|
left = make_alternative_compare (i);
|
right = simplify_and_tree (exp, &left, insn_code, insn_index);
|
right = simplify_and_tree (exp, &left, insn_code, insn_index);
|
newexp = attr_rtx (IOR, attr_rtx (NOT, left), right);
|
newexp = attr_rtx (IOR, attr_rtx (NOT, left), right);
|
|
|
return SIMPLIFY_TEST_EXP (newexp, insn_code, insn_index);
|
return SIMPLIFY_TEST_EXP (newexp, insn_code, insn_index);
|
}
|
}
|
}
|
}
|
|
|
if (left != XEXP (exp, 0) || right != XEXP (exp, 1))
|
if (left != XEXP (exp, 0) || right != XEXP (exp, 1))
|
{
|
{
|
newexp = attr_rtx (IOR, left, right);
|
newexp = attr_rtx (IOR, left, right);
|
return SIMPLIFY_TEST_EXP (newexp, insn_code, insn_index);
|
return SIMPLIFY_TEST_EXP (newexp, insn_code, insn_index);
|
}
|
}
|
break;
|
break;
|
|
|
case NOT:
|
case NOT:
|
if (GET_CODE (XEXP (exp, 0)) == NOT)
|
if (GET_CODE (XEXP (exp, 0)) == NOT)
|
{
|
{
|
left = SIMPLIFY_TEST_EXP (XEXP (XEXP (exp, 0), 0),
|
left = SIMPLIFY_TEST_EXP (XEXP (XEXP (exp, 0), 0),
|
insn_code, insn_index);
|
insn_code, insn_index);
|
return left;
|
return left;
|
}
|
}
|
|
|
left = SIMPLIFY_TEST_EXP (XEXP (exp, 0), insn_code, insn_index);
|
left = SIMPLIFY_TEST_EXP (XEXP (exp, 0), insn_code, insn_index);
|
if (GET_CODE (left) == NOT)
|
if (GET_CODE (left) == NOT)
|
return XEXP (left, 0);
|
return XEXP (left, 0);
|
|
|
if (left == false_rtx)
|
if (left == false_rtx)
|
return true_rtx;
|
return true_rtx;
|
if (left == true_rtx)
|
if (left == true_rtx)
|
return false_rtx;
|
return false_rtx;
|
|
|
if (GET_CODE (left) == EQ_ATTR_ALT)
|
if (GET_CODE (left) == EQ_ATTR_ALT)
|
{
|
{
|
exp = attr_alt_complement (left);
|
exp = attr_alt_complement (left);
|
return simplify_test_exp (exp, insn_code, insn_index);
|
return simplify_test_exp (exp, insn_code, insn_index);
|
}
|
}
|
|
|
/* Try to apply De`Morgan's laws. */
|
/* Try to apply De`Morgan's laws. */
|
if (GET_CODE (left) == IOR)
|
if (GET_CODE (left) == IOR)
|
{
|
{
|
newexp = attr_rtx (AND,
|
newexp = attr_rtx (AND,
|
attr_rtx (NOT, XEXP (left, 0)),
|
attr_rtx (NOT, XEXP (left, 0)),
|
attr_rtx (NOT, XEXP (left, 1)));
|
attr_rtx (NOT, XEXP (left, 1)));
|
|
|
newexp = SIMPLIFY_TEST_EXP (newexp, insn_code, insn_index);
|
newexp = SIMPLIFY_TEST_EXP (newexp, insn_code, insn_index);
|
}
|
}
|
else if (GET_CODE (left) == AND)
|
else if (GET_CODE (left) == AND)
|
{
|
{
|
newexp = attr_rtx (IOR,
|
newexp = attr_rtx (IOR,
|
attr_rtx (NOT, XEXP (left, 0)),
|
attr_rtx (NOT, XEXP (left, 0)),
|
attr_rtx (NOT, XEXP (left, 1)));
|
attr_rtx (NOT, XEXP (left, 1)));
|
|
|
newexp = SIMPLIFY_TEST_EXP (newexp, insn_code, insn_index);
|
newexp = SIMPLIFY_TEST_EXP (newexp, insn_code, insn_index);
|
}
|
}
|
else if (left != XEXP (exp, 0))
|
else if (left != XEXP (exp, 0))
|
{
|
{
|
newexp = attr_rtx (NOT, left);
|
newexp = attr_rtx (NOT, left);
|
}
|
}
|
break;
|
break;
|
|
|
case EQ_ATTR_ALT:
|
case EQ_ATTR_ALT:
|
if (!XINT (exp, 0))
|
if (!XINT (exp, 0))
|
return XINT (exp, 1) ? true_rtx : false_rtx;
|
return XINT (exp, 1) ? true_rtx : false_rtx;
|
break;
|
break;
|
|
|
case EQ_ATTR:
|
case EQ_ATTR:
|
if (XSTR (exp, 0) == alternative_name)
|
if (XSTR (exp, 0) == alternative_name)
|
{
|
{
|
newexp = mk_attr_alt (1 << atoi (XSTR (exp, 1)));
|
newexp = mk_attr_alt (1 << atoi (XSTR (exp, 1)));
|
break;
|
break;
|
}
|
}
|
|
|
/* Look at the value for this insn code in the specified attribute.
|
/* Look at the value for this insn code in the specified attribute.
|
We normally can replace this comparison with the condition that
|
We normally can replace this comparison with the condition that
|
would give this insn the values being tested for. */
|
would give this insn the values being tested for. */
|
if (insn_code >= 0
|
if (insn_code >= 0
|
&& (attr = find_attr (&XSTR (exp, 0), 0)) != NULL)
|
&& (attr = find_attr (&XSTR (exp, 0), 0)) != NULL)
|
{
|
{
|
rtx x;
|
rtx x;
|
|
|
av = NULL;
|
av = NULL;
|
if (insn_code_values)
|
if (insn_code_values)
|
{
|
{
|
for (iv = insn_code_values[insn_code]; iv; iv = iv->next)
|
for (iv = insn_code_values[insn_code]; iv; iv = iv->next)
|
if (iv->attr == attr)
|
if (iv->attr == attr)
|
{
|
{
|
av = iv->av;
|
av = iv->av;
|
break;
|
break;
|
}
|
}
|
}
|
}
|
else
|
else
|
{
|
{
|
for (av = attr->first_value; av; av = av->next)
|
for (av = attr->first_value; av; av = av->next)
|
for (ie = av->first_insn; ie; ie = ie->next)
|
for (ie = av->first_insn; ie; ie = ie->next)
|
if (ie->def->insn_code == insn_code)
|
if (ie->def->insn_code == insn_code)
|
goto got_av;
|
goto got_av;
|
}
|
}
|
|
|
if (av)
|
if (av)
|
{
|
{
|
got_av:
|
got_av:
|
x = evaluate_eq_attr (exp, av->value, insn_code, insn_index);
|
x = evaluate_eq_attr (exp, av->value, insn_code, insn_index);
|
x = SIMPLIFY_TEST_EXP (x, insn_code, insn_index);
|
x = SIMPLIFY_TEST_EXP (x, insn_code, insn_index);
|
if (attr_rtx_cost(x) < 20)
|
if (attr_rtx_cost(x) < 20)
|
return x;
|
return x;
|
}
|
}
|
}
|
}
|
break;
|
break;
|
|
|
default:
|
default:
|
break;
|
break;
|
}
|
}
|
|
|
/* We have already simplified this expression. Simplifying it again
|
/* We have already simplified this expression. Simplifying it again
|
won't buy anything unless we weren't given a valid insn code
|
won't buy anything unless we weren't given a valid insn code
|
to process (i.e., we are canonicalizing something.). */
|
to process (i.e., we are canonicalizing something.). */
|
if (insn_code != -2
|
if (insn_code != -2
|
&& ! ATTR_IND_SIMPLIFIED_P (newexp))
|
&& ! ATTR_IND_SIMPLIFIED_P (newexp))
|
return copy_rtx_unchanging (newexp);
|
return copy_rtx_unchanging (newexp);
|
|
|
return newexp;
|
return newexp;
|
}
|
}
|
|
|
/* Optimize the attribute lists by seeing if we can determine conditional
|
/* Optimize the attribute lists by seeing if we can determine conditional
|
values from the known values of other attributes. This will save subroutine
|
values from the known values of other attributes. This will save subroutine
|
calls during the compilation. */
|
calls during the compilation. */
|
|
|
static void
|
static void
|
optimize_attrs (void)
|
optimize_attrs (void)
|
{
|
{
|
struct attr_desc *attr;
|
struct attr_desc *attr;
|
struct attr_value *av;
|
struct attr_value *av;
|
struct insn_ent *ie;
|
struct insn_ent *ie;
|
rtx newexp;
|
rtx newexp;
|
int i;
|
int i;
|
struct attr_value_list *ivbuf;
|
struct attr_value_list *ivbuf;
|
struct attr_value_list *iv;
|
struct attr_value_list *iv;
|
|
|
/* For each insn code, make a list of all the insn_ent's for it,
|
/* For each insn code, make a list of all the insn_ent's for it,
|
for all values for all attributes. */
|
for all values for all attributes. */
|
|
|
if (num_insn_ents == 0)
|
if (num_insn_ents == 0)
|
return;
|
return;
|
|
|
/* Make 2 extra elements, for "code" values -2 and -1. */
|
/* Make 2 extra elements, for "code" values -2 and -1. */
|
insn_code_values = XCNEWVEC (struct attr_value_list *, insn_code_number + 2);
|
insn_code_values = XCNEWVEC (struct attr_value_list *, insn_code_number + 2);
|
|
|
/* Offset the table address so we can index by -2 or -1. */
|
/* Offset the table address so we can index by -2 or -1. */
|
insn_code_values += 2;
|
insn_code_values += 2;
|
|
|
iv = ivbuf = XNEWVEC (struct attr_value_list, num_insn_ents);
|
iv = ivbuf = XNEWVEC (struct attr_value_list, num_insn_ents);
|
|
|
for (i = 0; i < MAX_ATTRS_INDEX; i++)
|
for (i = 0; i < MAX_ATTRS_INDEX; i++)
|
for (attr = attrs[i]; attr; attr = attr->next)
|
for (attr = attrs[i]; attr; attr = attr->next)
|
for (av = attr->first_value; av; av = av->next)
|
for (av = attr->first_value; av; av = av->next)
|
for (ie = av->first_insn; ie; ie = ie->next)
|
for (ie = av->first_insn; ie; ie = ie->next)
|
{
|
{
|
iv->attr = attr;
|
iv->attr = attr;
|
iv->av = av;
|
iv->av = av;
|
iv->ie = ie;
|
iv->ie = ie;
|
iv->next = insn_code_values[ie->def->insn_code];
|
iv->next = insn_code_values[ie->def->insn_code];
|
insn_code_values[ie->def->insn_code] = iv;
|
insn_code_values[ie->def->insn_code] = iv;
|
iv++;
|
iv++;
|
}
|
}
|
|
|
/* Sanity check on num_insn_ents. */
|
/* Sanity check on num_insn_ents. */
|
gcc_assert (iv == ivbuf + num_insn_ents);
|
gcc_assert (iv == ivbuf + num_insn_ents);
|
|
|
/* Process one insn code at a time. */
|
/* Process one insn code at a time. */
|
for (i = -2; i < insn_code_number; i++)
|
for (i = -2; i < insn_code_number; i++)
|
{
|
{
|
/* Clear the ATTR_CURR_SIMPLIFIED_P flag everywhere relevant.
|
/* Clear the ATTR_CURR_SIMPLIFIED_P flag everywhere relevant.
|
We use it to mean "already simplified for this insn". */
|
We use it to mean "already simplified for this insn". */
|
for (iv = insn_code_values[i]; iv; iv = iv->next)
|
for (iv = insn_code_values[i]; iv; iv = iv->next)
|
clear_struct_flag (iv->av->value);
|
clear_struct_flag (iv->av->value);
|
|
|
for (iv = insn_code_values[i]; iv; iv = iv->next)
|
for (iv = insn_code_values[i]; iv; iv = iv->next)
|
{
|
{
|
struct obstack *old = rtl_obstack;
|
struct obstack *old = rtl_obstack;
|
|
|
attr = iv->attr;
|
attr = iv->attr;
|
av = iv->av;
|
av = iv->av;
|
ie = iv->ie;
|
ie = iv->ie;
|
if (GET_CODE (av->value) != COND)
|
if (GET_CODE (av->value) != COND)
|
continue;
|
continue;
|
|
|
rtl_obstack = temp_obstack;
|
rtl_obstack = temp_obstack;
|
newexp = av->value;
|
newexp = av->value;
|
while (GET_CODE (newexp) == COND)
|
while (GET_CODE (newexp) == COND)
|
{
|
{
|
rtx newexp2 = simplify_cond (newexp, ie->def->insn_code,
|
rtx newexp2 = simplify_cond (newexp, ie->def->insn_code,
|
ie->def->insn_index);
|
ie->def->insn_index);
|
if (newexp2 == newexp)
|
if (newexp2 == newexp)
|
break;
|
break;
|
newexp = newexp2;
|
newexp = newexp2;
|
}
|
}
|
|
|
rtl_obstack = old;
|
rtl_obstack = old;
|
if (newexp != av->value)
|
if (newexp != av->value)
|
{
|
{
|
newexp = attr_copy_rtx (newexp);
|
newexp = attr_copy_rtx (newexp);
|
remove_insn_ent (av, ie);
|
remove_insn_ent (av, ie);
|
av = get_attr_value (newexp, attr, ie->def->insn_code);
|
av = get_attr_value (newexp, attr, ie->def->insn_code);
|
iv->av = av;
|
iv->av = av;
|
insert_insn_ent (av, ie);
|
insert_insn_ent (av, ie);
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
free (ivbuf);
|
free (ivbuf);
|
free (insn_code_values - 2);
|
free (insn_code_values - 2);
|
insn_code_values = NULL;
|
insn_code_values = NULL;
|
}
|
}
|
|
|
/* Clear the ATTR_CURR_SIMPLIFIED_P flag in EXP and its subexpressions. */
|
/* Clear the ATTR_CURR_SIMPLIFIED_P flag in EXP and its subexpressions. */
|
|
|
static void
|
static void
|
clear_struct_flag (rtx x)
|
clear_struct_flag (rtx x)
|
{
|
{
|
int i;
|
int i;
|
int j;
|
int j;
|
enum rtx_code code;
|
enum rtx_code code;
|
const char *fmt;
|
const char *fmt;
|
|
|
ATTR_CURR_SIMPLIFIED_P (x) = 0;
|
ATTR_CURR_SIMPLIFIED_P (x) = 0;
|
if (ATTR_IND_SIMPLIFIED_P (x))
|
if (ATTR_IND_SIMPLIFIED_P (x))
|
return;
|
return;
|
|
|
code = GET_CODE (x);
|
code = GET_CODE (x);
|
|
|
switch (code)
|
switch (code)
|
{
|
{
|
case REG:
|
case REG:
|
case CONST_INT:
|
case CONST_INT:
|
case CONST_DOUBLE:
|
case CONST_DOUBLE:
|
case CONST_VECTOR:
|
case CONST_VECTOR:
|
case SYMBOL_REF:
|
case SYMBOL_REF:
|
case CODE_LABEL:
|
case CODE_LABEL:
|
case PC:
|
case PC:
|
case CC0:
|
case CC0:
|
case EQ_ATTR:
|
case EQ_ATTR:
|
case ATTR_FLAG:
|
case ATTR_FLAG:
|
return;
|
return;
|
|
|
default:
|
default:
|
break;
|
break;
|
}
|
}
|
|
|
/* Compare the elements. If any pair of corresponding elements
|
/* Compare the elements. If any pair of corresponding elements
|
fail to match, return 0 for the whole things. */
|
fail to match, return 0 for the whole things. */
|
|
|
fmt = GET_RTX_FORMAT (code);
|
fmt = GET_RTX_FORMAT (code);
|
for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
|
for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
|
{
|
{
|
switch (fmt[i])
|
switch (fmt[i])
|
{
|
{
|
case 'V':
|
case 'V':
|
case 'E':
|
case 'E':
|
for (j = 0; j < XVECLEN (x, i); j++)
|
for (j = 0; j < XVECLEN (x, i); j++)
|
clear_struct_flag (XVECEXP (x, i, j));
|
clear_struct_flag (XVECEXP (x, i, j));
|
break;
|
break;
|
|
|
case 'e':
|
case 'e':
|
clear_struct_flag (XEXP (x, i));
|
clear_struct_flag (XEXP (x, i));
|
break;
|
break;
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
/* Create table entries for DEFINE_ATTR. */
|
/* Create table entries for DEFINE_ATTR. */
|
|
|
static void
|
static void
|
gen_attr (rtx exp, int lineno)
|
gen_attr (rtx exp, int lineno)
|
{
|
{
|
struct attr_desc *attr;
|
struct attr_desc *attr;
|
struct attr_value *av;
|
struct attr_value *av;
|
const char *name_ptr;
|
const char *name_ptr;
|
char *p;
|
char *p;
|
|
|
/* Make a new attribute structure. Check for duplicate by looking at
|
/* Make a new attribute structure. Check for duplicate by looking at
|
attr->default_val, since it is initialized by this routine. */
|
attr->default_val, since it is initialized by this routine. */
|
attr = find_attr (&XSTR (exp, 0), 1);
|
attr = find_attr (&XSTR (exp, 0), 1);
|
if (attr->default_val)
|
if (attr->default_val)
|
{
|
{
|
message_with_line (lineno, "duplicate definition for attribute %s",
|
message_with_line (lineno, "duplicate definition for attribute %s",
|
attr->name);
|
attr->name);
|
message_with_line (attr->lineno, "previous definition");
|
message_with_line (attr->lineno, "previous definition");
|
have_error = 1;
|
have_error = 1;
|
return;
|
return;
|
}
|
}
|
attr->lineno = lineno;
|
attr->lineno = lineno;
|
|
|
if (*XSTR (exp, 1) == '\0')
|
if (*XSTR (exp, 1) == '\0')
|
attr->is_numeric = 1;
|
attr->is_numeric = 1;
|
else
|
else
|
{
|
{
|
name_ptr = XSTR (exp, 1);
|
name_ptr = XSTR (exp, 1);
|
while ((p = next_comma_elt (&name_ptr)) != NULL)
|
while ((p = next_comma_elt (&name_ptr)) != NULL)
|
{
|
{
|
av = oballoc (struct attr_value);
|
av = oballoc (struct attr_value);
|
av->value = attr_rtx (CONST_STRING, p);
|
av->value = attr_rtx (CONST_STRING, p);
|
av->next = attr->first_value;
|
av->next = attr->first_value;
|
attr->first_value = av;
|
attr->first_value = av;
|
av->first_insn = NULL;
|
av->first_insn = NULL;
|
av->num_insns = 0;
|
av->num_insns = 0;
|
av->has_asm_insn = 0;
|
av->has_asm_insn = 0;
|
}
|
}
|
}
|
}
|
|
|
if (GET_CODE (XEXP (exp, 2)) == CONST)
|
if (GET_CODE (XEXP (exp, 2)) == CONST)
|
{
|
{
|
attr->is_const = 1;
|
attr->is_const = 1;
|
if (attr->is_numeric)
|
if (attr->is_numeric)
|
{
|
{
|
message_with_line (lineno,
|
message_with_line (lineno,
|
"constant attributes may not take numeric values");
|
"constant attributes may not take numeric values");
|
have_error = 1;
|
have_error = 1;
|
}
|
}
|
|
|
/* Get rid of the CONST node. It is allowed only at top-level. */
|
/* Get rid of the CONST node. It is allowed only at top-level. */
|
XEXP (exp, 2) = XEXP (XEXP (exp, 2), 0);
|
XEXP (exp, 2) = XEXP (XEXP (exp, 2), 0);
|
}
|
}
|
|
|
if (! strcmp_check (attr->name, length_str) && ! attr->is_numeric)
|
if (! strcmp_check (attr->name, length_str) && ! attr->is_numeric)
|
{
|
{
|
message_with_line (lineno,
|
message_with_line (lineno,
|
"`length' attribute must take numeric values");
|
"`length' attribute must take numeric values");
|
have_error = 1;
|
have_error = 1;
|
}
|
}
|
|
|
/* Set up the default value. */
|
/* Set up the default value. */
|
XEXP (exp, 2) = check_attr_value (XEXP (exp, 2), attr);
|
XEXP (exp, 2) = check_attr_value (XEXP (exp, 2), attr);
|
attr->default_val = get_attr_value (XEXP (exp, 2), attr, -2);
|
attr->default_val = get_attr_value (XEXP (exp, 2), attr, -2);
|
}
|
}
|
|
|
/* Given a pattern for DEFINE_PEEPHOLE or DEFINE_INSN, return the number of
|
/* Given a pattern for DEFINE_PEEPHOLE or DEFINE_INSN, return the number of
|
alternatives in the constraints. Assume all MATCH_OPERANDs have the same
|
alternatives in the constraints. Assume all MATCH_OPERANDs have the same
|
number of alternatives as this should be checked elsewhere. */
|
number of alternatives as this should be checked elsewhere. */
|
|
|
static int
|
static int
|
count_alternatives (rtx exp)
|
count_alternatives (rtx exp)
|
{
|
{
|
int i, j, n;
|
int i, j, n;
|
const char *fmt;
|
const char *fmt;
|
|
|
if (GET_CODE (exp) == MATCH_OPERAND)
|
if (GET_CODE (exp) == MATCH_OPERAND)
|
return n_comma_elts (XSTR (exp, 2));
|
return n_comma_elts (XSTR (exp, 2));
|
|
|
for (i = 0, fmt = GET_RTX_FORMAT (GET_CODE (exp));
|
for (i = 0, fmt = GET_RTX_FORMAT (GET_CODE (exp));
|
i < GET_RTX_LENGTH (GET_CODE (exp)); i++)
|
i < GET_RTX_LENGTH (GET_CODE (exp)); i++)
|
switch (*fmt++)
|
switch (*fmt++)
|
{
|
{
|
case 'e':
|
case 'e':
|
case 'u':
|
case 'u':
|
n = count_alternatives (XEXP (exp, i));
|
n = count_alternatives (XEXP (exp, i));
|
if (n)
|
if (n)
|
return n;
|
return n;
|
break;
|
break;
|
|
|
case 'E':
|
case 'E':
|
case 'V':
|
case 'V':
|
if (XVEC (exp, i) != NULL)
|
if (XVEC (exp, i) != NULL)
|
for (j = 0; j < XVECLEN (exp, i); j++)
|
for (j = 0; j < XVECLEN (exp, i); j++)
|
{
|
{
|
n = count_alternatives (XVECEXP (exp, i, j));
|
n = count_alternatives (XVECEXP (exp, i, j));
|
if (n)
|
if (n)
|
return n;
|
return n;
|
}
|
}
|
}
|
}
|
|
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* Returns nonzero if the given expression contains an EQ_ATTR with the
|
/* Returns nonzero if the given expression contains an EQ_ATTR with the
|
`alternative' attribute. */
|
`alternative' attribute. */
|
|
|
static int
|
static int
|
compares_alternatives_p (rtx exp)
|
compares_alternatives_p (rtx exp)
|
{
|
{
|
int i, j;
|
int i, j;
|
const char *fmt;
|
const char *fmt;
|
|
|
if (GET_CODE (exp) == EQ_ATTR && XSTR (exp, 0) == alternative_name)
|
if (GET_CODE (exp) == EQ_ATTR && XSTR (exp, 0) == alternative_name)
|
return 1;
|
return 1;
|
|
|
for (i = 0, fmt = GET_RTX_FORMAT (GET_CODE (exp));
|
for (i = 0, fmt = GET_RTX_FORMAT (GET_CODE (exp));
|
i < GET_RTX_LENGTH (GET_CODE (exp)); i++)
|
i < GET_RTX_LENGTH (GET_CODE (exp)); i++)
|
switch (*fmt++)
|
switch (*fmt++)
|
{
|
{
|
case 'e':
|
case 'e':
|
case 'u':
|
case 'u':
|
if (compares_alternatives_p (XEXP (exp, i)))
|
if (compares_alternatives_p (XEXP (exp, i)))
|
return 1;
|
return 1;
|
break;
|
break;
|
|
|
case 'E':
|
case 'E':
|
for (j = 0; j < XVECLEN (exp, i); j++)
|
for (j = 0; j < XVECLEN (exp, i); j++)
|
if (compares_alternatives_p (XVECEXP (exp, i, j)))
|
if (compares_alternatives_p (XVECEXP (exp, i, j)))
|
return 1;
|
return 1;
|
break;
|
break;
|
}
|
}
|
|
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* Process DEFINE_PEEPHOLE, DEFINE_INSN, and DEFINE_ASM_ATTRIBUTES. */
|
/* Process DEFINE_PEEPHOLE, DEFINE_INSN, and DEFINE_ASM_ATTRIBUTES. */
|
|
|
static void
|
static void
|
gen_insn (rtx exp, int lineno)
|
gen_insn (rtx exp, int lineno)
|
{
|
{
|
struct insn_def *id;
|
struct insn_def *id;
|
|
|
id = oballoc (struct insn_def);
|
id = oballoc (struct insn_def);
|
id->next = defs;
|
id->next = defs;
|
defs = id;
|
defs = id;
|
id->def = exp;
|
id->def = exp;
|
id->lineno = lineno;
|
id->lineno = lineno;
|
|
|
switch (GET_CODE (exp))
|
switch (GET_CODE (exp))
|
{
|
{
|
case DEFINE_INSN:
|
case DEFINE_INSN:
|
id->insn_code = insn_code_number;
|
id->insn_code = insn_code_number;
|
id->insn_index = insn_index_number;
|
id->insn_index = insn_index_number;
|
id->num_alternatives = count_alternatives (exp);
|
id->num_alternatives = count_alternatives (exp);
|
if (id->num_alternatives == 0)
|
if (id->num_alternatives == 0)
|
id->num_alternatives = 1;
|
id->num_alternatives = 1;
|
id->vec_idx = 4;
|
id->vec_idx = 4;
|
break;
|
break;
|
|
|
case DEFINE_PEEPHOLE:
|
case DEFINE_PEEPHOLE:
|
id->insn_code = insn_code_number;
|
id->insn_code = insn_code_number;
|
id->insn_index = insn_index_number;
|
id->insn_index = insn_index_number;
|
id->num_alternatives = count_alternatives (exp);
|
id->num_alternatives = count_alternatives (exp);
|
if (id->num_alternatives == 0)
|
if (id->num_alternatives == 0)
|
id->num_alternatives = 1;
|
id->num_alternatives = 1;
|
id->vec_idx = 3;
|
id->vec_idx = 3;
|
break;
|
break;
|
|
|
case DEFINE_ASM_ATTRIBUTES:
|
case DEFINE_ASM_ATTRIBUTES:
|
id->insn_code = -1;
|
id->insn_code = -1;
|
id->insn_index = -1;
|
id->insn_index = -1;
|
id->num_alternatives = 1;
|
id->num_alternatives = 1;
|
id->vec_idx = 0;
|
id->vec_idx = 0;
|
got_define_asm_attributes = 1;
|
got_define_asm_attributes = 1;
|
break;
|
break;
|
|
|
default:
|
default:
|
gcc_unreachable ();
|
gcc_unreachable ();
|
}
|
}
|
}
|
}
|
|
|
/* Process a DEFINE_DELAY. Validate the vector length, check if annul
|
/* Process a DEFINE_DELAY. Validate the vector length, check if annul
|
true or annul false is specified, and make a `struct delay_desc'. */
|
true or annul false is specified, and make a `struct delay_desc'. */
|
|
|
static void
|
static void
|
gen_delay (rtx def, int lineno)
|
gen_delay (rtx def, int lineno)
|
{
|
{
|
struct delay_desc *delay;
|
struct delay_desc *delay;
|
int i;
|
int i;
|
|
|
if (XVECLEN (def, 1) % 3 != 0)
|
if (XVECLEN (def, 1) % 3 != 0)
|
{
|
{
|
message_with_line (lineno,
|
message_with_line (lineno,
|
"number of elements in DEFINE_DELAY must be multiple of three");
|
"number of elements in DEFINE_DELAY must be multiple of three");
|
have_error = 1;
|
have_error = 1;
|
return;
|
return;
|
}
|
}
|
|
|
for (i = 0; i < XVECLEN (def, 1); i += 3)
|
for (i = 0; i < XVECLEN (def, 1); i += 3)
|
{
|
{
|
if (XVECEXP (def, 1, i + 1))
|
if (XVECEXP (def, 1, i + 1))
|
have_annul_true = 1;
|
have_annul_true = 1;
|
if (XVECEXP (def, 1, i + 2))
|
if (XVECEXP (def, 1, i + 2))
|
have_annul_false = 1;
|
have_annul_false = 1;
|
}
|
}
|
|
|
delay = oballoc (struct delay_desc);
|
delay = oballoc (struct delay_desc);
|
delay->def = def;
|
delay->def = def;
|
delay->num = ++num_delays;
|
delay->num = ++num_delays;
|
delay->next = delays;
|
delay->next = delays;
|
delay->lineno = lineno;
|
delay->lineno = lineno;
|
delays = delay;
|
delays = delay;
|
}
|
}
|
|
|
/* Given a piece of RTX, print a C expression to test its truth value.
|
/* Given a piece of RTX, print a C expression to test its truth value.
|
We use AND and IOR both for logical and bit-wise operations, so
|
We use AND and IOR both for logical and bit-wise operations, so
|
interpret them as logical unless they are inside a comparison expression.
|
interpret them as logical unless they are inside a comparison expression.
|
The first bit of FLAGS will be nonzero in that case.
|
The first bit of FLAGS will be nonzero in that case.
|
|
|
Set the second bit of FLAGS to make references to attribute values use
|
Set the second bit of FLAGS to make references to attribute values use
|
a cached local variable instead of calling a function. */
|
a cached local variable instead of calling a function. */
|
|
|
static void
|
static void
|
write_test_expr (rtx exp, int flags)
|
write_test_expr (rtx exp, int flags)
|
{
|
{
|
int comparison_operator = 0;
|
int comparison_operator = 0;
|
RTX_CODE code;
|
RTX_CODE code;
|
struct attr_desc *attr;
|
struct attr_desc *attr;
|
|
|
/* In order not to worry about operator precedence, surround our part of
|
/* In order not to worry about operator precedence, surround our part of
|
the expression with parentheses. */
|
the expression with parentheses. */
|
|
|
printf ("(");
|
printf ("(");
|
code = GET_CODE (exp);
|
code = GET_CODE (exp);
|
switch (code)
|
switch (code)
|
{
|
{
|
/* Binary operators. */
|
/* Binary operators. */
|
case GEU: case GTU:
|
case GEU: case GTU:
|
case LEU: case LTU:
|
case LEU: case LTU:
|
printf ("(unsigned) ");
|
printf ("(unsigned) ");
|
/* Fall through. */
|
/* Fall through. */
|
|
|
case EQ: case NE:
|
case EQ: case NE:
|
case GE: case GT:
|
case GE: case GT:
|
case LE: case LT:
|
case LE: case LT:
|
comparison_operator = 1;
|
comparison_operator = 1;
|
|
|
case PLUS: case MINUS: case MULT: case DIV: case MOD:
|
case PLUS: case MINUS: case MULT: case DIV: case MOD:
|
case AND: case IOR: case XOR:
|
case AND: case IOR: case XOR:
|
case ASHIFT: case LSHIFTRT: case ASHIFTRT:
|
case ASHIFT: case LSHIFTRT: case ASHIFTRT:
|
write_test_expr (XEXP (exp, 0), flags | comparison_operator);
|
write_test_expr (XEXP (exp, 0), flags | comparison_operator);
|
switch (code)
|
switch (code)
|
{
|
{
|
case EQ:
|
case EQ:
|
printf (" == ");
|
printf (" == ");
|
break;
|
break;
|
case NE:
|
case NE:
|
printf (" != ");
|
printf (" != ");
|
break;
|
break;
|
case GE:
|
case GE:
|
printf (" >= ");
|
printf (" >= ");
|
break;
|
break;
|
case GT:
|
case GT:
|
printf (" > ");
|
printf (" > ");
|
break;
|
break;
|
case GEU:
|
case GEU:
|
printf (" >= (unsigned) ");
|
printf (" >= (unsigned) ");
|
break;
|
break;
|
case GTU:
|
case GTU:
|
printf (" > (unsigned) ");
|
printf (" > (unsigned) ");
|
break;
|
break;
|
case LE:
|
case LE:
|
printf (" <= ");
|
printf (" <= ");
|
break;
|
break;
|
case LT:
|
case LT:
|
printf (" < ");
|
printf (" < ");
|
break;
|
break;
|
case LEU:
|
case LEU:
|
printf (" <= (unsigned) ");
|
printf (" <= (unsigned) ");
|
break;
|
break;
|
case LTU:
|
case LTU:
|
printf (" < (unsigned) ");
|
printf (" < (unsigned) ");
|
break;
|
break;
|
case PLUS:
|
case PLUS:
|
printf (" + ");
|
printf (" + ");
|
break;
|
break;
|
case MINUS:
|
case MINUS:
|
printf (" - ");
|
printf (" - ");
|
break;
|
break;
|
case MULT:
|
case MULT:
|
printf (" * ");
|
printf (" * ");
|
break;
|
break;
|
case DIV:
|
case DIV:
|
printf (" / ");
|
printf (" / ");
|
break;
|
break;
|
case MOD:
|
case MOD:
|
printf (" %% ");
|
printf (" %% ");
|
break;
|
break;
|
case AND:
|
case AND:
|
if (flags & 1)
|
if (flags & 1)
|
printf (" & ");
|
printf (" & ");
|
else
|
else
|
printf (" && ");
|
printf (" && ");
|
break;
|
break;
|
case IOR:
|
case IOR:
|
if (flags & 1)
|
if (flags & 1)
|
printf (" | ");
|
printf (" | ");
|
else
|
else
|
printf (" || ");
|
printf (" || ");
|
break;
|
break;
|
case XOR:
|
case XOR:
|
printf (" ^ ");
|
printf (" ^ ");
|
break;
|
break;
|
case ASHIFT:
|
case ASHIFT:
|
printf (" << ");
|
printf (" << ");
|
break;
|
break;
|
case LSHIFTRT:
|
case LSHIFTRT:
|
case ASHIFTRT:
|
case ASHIFTRT:
|
printf (" >> ");
|
printf (" >> ");
|
break;
|
break;
|
default:
|
default:
|
gcc_unreachable ();
|
gcc_unreachable ();
|
}
|
}
|
|
|
write_test_expr (XEXP (exp, 1), flags | comparison_operator);
|
write_test_expr (XEXP (exp, 1), flags | comparison_operator);
|
break;
|
break;
|
|
|
case NOT:
|
case NOT:
|
/* Special-case (not (eq_attrq "alternative" "x")) */
|
/* Special-case (not (eq_attrq "alternative" "x")) */
|
if (! (flags & 1) && GET_CODE (XEXP (exp, 0)) == EQ_ATTR
|
if (! (flags & 1) && GET_CODE (XEXP (exp, 0)) == EQ_ATTR
|
&& XSTR (XEXP (exp, 0), 0) == alternative_name)
|
&& XSTR (XEXP (exp, 0), 0) == alternative_name)
|
{
|
{
|
printf ("which_alternative != %s", XSTR (XEXP (exp, 0), 1));
|
printf ("which_alternative != %s", XSTR (XEXP (exp, 0), 1));
|
break;
|
break;
|
}
|
}
|
|
|
/* Otherwise, fall through to normal unary operator. */
|
/* Otherwise, fall through to normal unary operator. */
|
|
|
/* Unary operators. */
|
/* Unary operators. */
|
case ABS: case NEG:
|
case ABS: case NEG:
|
switch (code)
|
switch (code)
|
{
|
{
|
case NOT:
|
case NOT:
|
if (flags & 1)
|
if (flags & 1)
|
printf ("~ ");
|
printf ("~ ");
|
else
|
else
|
printf ("! ");
|
printf ("! ");
|
break;
|
break;
|
case ABS:
|
case ABS:
|
printf ("abs ");
|
printf ("abs ");
|
break;
|
break;
|
case NEG:
|
case NEG:
|
printf ("-");
|
printf ("-");
|
break;
|
break;
|
default:
|
default:
|
gcc_unreachable ();
|
gcc_unreachable ();
|
}
|
}
|
|
|
write_test_expr (XEXP (exp, 0), flags);
|
write_test_expr (XEXP (exp, 0), flags);
|
break;
|
break;
|
|
|
case EQ_ATTR_ALT:
|
case EQ_ATTR_ALT:
|
{
|
{
|
int set = XINT (exp, 0), bit = 0;
|
int set = XINT (exp, 0), bit = 0;
|
|
|
if (flags & 1)
|
if (flags & 1)
|
fatal ("EQ_ATTR_ALT not valid inside comparison");
|
fatal ("EQ_ATTR_ALT not valid inside comparison");
|
|
|
if (!set)
|
if (!set)
|
fatal ("Empty EQ_ATTR_ALT should be optimized out");
|
fatal ("Empty EQ_ATTR_ALT should be optimized out");
|
|
|
if (!(set & (set - 1)))
|
if (!(set & (set - 1)))
|
{
|
{
|
if (!(set & 0xffff))
|
if (!(set & 0xffff))
|
{
|
{
|
bit += 16;
|
bit += 16;
|
set >>= 16;
|
set >>= 16;
|
}
|
}
|
if (!(set & 0xff))
|
if (!(set & 0xff))
|
{
|
{
|
bit += 8;
|
bit += 8;
|
set >>= 8;
|
set >>= 8;
|
}
|
}
|
if (!(set & 0xf))
|
if (!(set & 0xf))
|
{
|
{
|
bit += 4;
|
bit += 4;
|
set >>= 4;
|
set >>= 4;
|
}
|
}
|
if (!(set & 0x3))
|
if (!(set & 0x3))
|
{
|
{
|
bit += 2;
|
bit += 2;
|
set >>= 2;
|
set >>= 2;
|
}
|
}
|
if (!(set & 1))
|
if (!(set & 1))
|
bit++;
|
bit++;
|
|
|
printf ("which_alternative %s= %d",
|
printf ("which_alternative %s= %d",
|
XINT (exp, 1) ? "!" : "=", bit);
|
XINT (exp, 1) ? "!" : "=", bit);
|
}
|
}
|
else
|
else
|
{
|
{
|
printf ("%s((1 << which_alternative) & 0x%x)",
|
printf ("%s((1 << which_alternative) & 0x%x)",
|
XINT (exp, 1) ? "!" : "", set);
|
XINT (exp, 1) ? "!" : "", set);
|
}
|
}
|
}
|
}
|
break;
|
break;
|
|
|
/* Comparison test of an attribute with a value. Most of these will
|
/* Comparison test of an attribute with a value. Most of these will
|
have been removed by optimization. Handle "alternative"
|
have been removed by optimization. Handle "alternative"
|
specially and give error if EQ_ATTR present inside a comparison. */
|
specially and give error if EQ_ATTR present inside a comparison. */
|
case EQ_ATTR:
|
case EQ_ATTR:
|
if (flags & 1)
|
if (flags & 1)
|
fatal ("EQ_ATTR not valid inside comparison");
|
fatal ("EQ_ATTR not valid inside comparison");
|
|
|
if (XSTR (exp, 0) == alternative_name)
|
if (XSTR (exp, 0) == alternative_name)
|
{
|
{
|
printf ("which_alternative == %s", XSTR (exp, 1));
|
printf ("which_alternative == %s", XSTR (exp, 1));
|
break;
|
break;
|
}
|
}
|
|
|
attr = find_attr (&XSTR (exp, 0), 0);
|
attr = find_attr (&XSTR (exp, 0), 0);
|
gcc_assert (attr);
|
gcc_assert (attr);
|
|
|
/* Now is the time to expand the value of a constant attribute. */
|
/* Now is the time to expand the value of a constant attribute. */
|
if (attr->is_const)
|
if (attr->is_const)
|
{
|
{
|
write_test_expr (evaluate_eq_attr (exp, attr->default_val->value,
|
write_test_expr (evaluate_eq_attr (exp, attr->default_val->value,
|
-2, -2),
|
-2, -2),
|
flags);
|
flags);
|
}
|
}
|
else
|
else
|
{
|
{
|
if (flags & 2)
|
if (flags & 2)
|
printf ("attr_%s", attr->name);
|
printf ("attr_%s", attr->name);
|
else
|
else
|
printf ("get_attr_%s (insn)", attr->name);
|
printf ("get_attr_%s (insn)", attr->name);
|
printf (" == ");
|
printf (" == ");
|
write_attr_valueq (attr, XSTR (exp, 1));
|
write_attr_valueq (attr, XSTR (exp, 1));
|
}
|
}
|
break;
|
break;
|
|
|
/* Comparison test of flags for define_delays. */
|
/* Comparison test of flags for define_delays. */
|
case ATTR_FLAG:
|
case ATTR_FLAG:
|
if (flags & 1)
|
if (flags & 1)
|
fatal ("ATTR_FLAG not valid inside comparison");
|
fatal ("ATTR_FLAG not valid inside comparison");
|
printf ("(flags & ATTR_FLAG_%s) != 0", XSTR (exp, 0));
|
printf ("(flags & ATTR_FLAG_%s) != 0", XSTR (exp, 0));
|
break;
|
break;
|
|
|
/* See if an operand matches a predicate. */
|
/* See if an operand matches a predicate. */
|
case MATCH_OPERAND:
|
case MATCH_OPERAND:
|
/* If only a mode is given, just ensure the mode matches the operand.
|
/* If only a mode is given, just ensure the mode matches the operand.
|
If neither a mode nor predicate is given, error. */
|
If neither a mode nor predicate is given, error. */
|
if (XSTR (exp, 1) == NULL || *XSTR (exp, 1) == '\0')
|
if (XSTR (exp, 1) == NULL || *XSTR (exp, 1) == '\0')
|
{
|
{
|
if (GET_MODE (exp) == VOIDmode)
|
if (GET_MODE (exp) == VOIDmode)
|
fatal ("null MATCH_OPERAND specified as test");
|
fatal ("null MATCH_OPERAND specified as test");
|
else
|
else
|
printf ("GET_MODE (operands[%d]) == %smode",
|
printf ("GET_MODE (operands[%d]) == %smode",
|
XINT (exp, 0), GET_MODE_NAME (GET_MODE (exp)));
|
XINT (exp, 0), GET_MODE_NAME (GET_MODE (exp)));
|
}
|
}
|
else
|
else
|
printf ("%s (operands[%d], %smode)",
|
printf ("%s (operands[%d], %smode)",
|
XSTR (exp, 1), XINT (exp, 0), GET_MODE_NAME (GET_MODE (exp)));
|
XSTR (exp, 1), XINT (exp, 0), GET_MODE_NAME (GET_MODE (exp)));
|
break;
|
break;
|
|
|
/* Constant integer. */
|
/* Constant integer. */
|
case CONST_INT:
|
case CONST_INT:
|
printf (HOST_WIDE_INT_PRINT_DEC, XWINT (exp, 0));
|
printf (HOST_WIDE_INT_PRINT_DEC, XWINT (exp, 0));
|
break;
|
break;
|
|
|
/* A random C expression. */
|
/* A random C expression. */
|
case SYMBOL_REF:
|
case SYMBOL_REF:
|
print_c_condition (XSTR (exp, 0));
|
print_c_condition (XSTR (exp, 0));
|
break;
|
break;
|
|
|
/* The address of the branch target. */
|
/* The address of the branch target. */
|
case MATCH_DUP:
|
case MATCH_DUP:
|
printf ("INSN_ADDRESSES_SET_P () ? INSN_ADDRESSES (INSN_UID (GET_CODE (operands[%d]) == LABEL_REF ? XEXP (operands[%d], 0) : operands[%d])) : 0",
|
printf ("INSN_ADDRESSES_SET_P () ? INSN_ADDRESSES (INSN_UID (GET_CODE (operands[%d]) == LABEL_REF ? XEXP (operands[%d], 0) : operands[%d])) : 0",
|
XINT (exp, 0), XINT (exp, 0), XINT (exp, 0));
|
XINT (exp, 0), XINT (exp, 0), XINT (exp, 0));
|
break;
|
break;
|
|
|
case PC:
|
case PC:
|
/* The address of the current insn. We implement this actually as the
|
/* The address of the current insn. We implement this actually as the
|
address of the current insn for backward branches, but the last
|
address of the current insn for backward branches, but the last
|
address of the next insn for forward branches, and both with
|
address of the next insn for forward branches, and both with
|
adjustments that account for the worst-case possible stretching of
|
adjustments that account for the worst-case possible stretching of
|
intervening alignments between this insn and its destination. */
|
intervening alignments between this insn and its destination. */
|
printf ("insn_current_reference_address (insn)");
|
printf ("insn_current_reference_address (insn)");
|
break;
|
break;
|
|
|
case CONST_STRING:
|
case CONST_STRING:
|
printf ("%s", XSTR (exp, 0));
|
printf ("%s", XSTR (exp, 0));
|
break;
|
break;
|
|
|
case IF_THEN_ELSE:
|
case IF_THEN_ELSE:
|
write_test_expr (XEXP (exp, 0), flags & 2);
|
write_test_expr (XEXP (exp, 0), flags & 2);
|
printf (" ? ");
|
printf (" ? ");
|
write_test_expr (XEXP (exp, 1), flags | 1);
|
write_test_expr (XEXP (exp, 1), flags | 1);
|
printf (" : ");
|
printf (" : ");
|
write_test_expr (XEXP (exp, 2), flags | 1);
|
write_test_expr (XEXP (exp, 2), flags | 1);
|
break;
|
break;
|
|
|
default:
|
default:
|
fatal ("bad RTX code `%s' in attribute calculation\n",
|
fatal ("bad RTX code `%s' in attribute calculation\n",
|
GET_RTX_NAME (code));
|
GET_RTX_NAME (code));
|
}
|
}
|
|
|
printf (")");
|
printf (")");
|
}
|
}
|
|
|
/* Given an attribute value, return the maximum CONST_STRING argument
|
/* Given an attribute value, return the maximum CONST_STRING argument
|
encountered. Set *UNKNOWNP and return INT_MAX if the value is unknown. */
|
encountered. Set *UNKNOWNP and return INT_MAX if the value is unknown. */
|
|
|
static int
|
static int
|
max_attr_value (rtx exp, int *unknownp)
|
max_attr_value (rtx exp, int *unknownp)
|
{
|
{
|
int current_max;
|
int current_max;
|
int i, n;
|
int i, n;
|
|
|
switch (GET_CODE (exp))
|
switch (GET_CODE (exp))
|
{
|
{
|
case CONST_STRING:
|
case CONST_STRING:
|
current_max = atoi (XSTR (exp, 0));
|
current_max = atoi (XSTR (exp, 0));
|
break;
|
break;
|
|
|
case COND:
|
case COND:
|
current_max = max_attr_value (XEXP (exp, 1), unknownp);
|
current_max = max_attr_value (XEXP (exp, 1), unknownp);
|
for (i = 0; i < XVECLEN (exp, 0); i += 2)
|
for (i = 0; i < XVECLEN (exp, 0); i += 2)
|
{
|
{
|
n = max_attr_value (XVECEXP (exp, 0, i + 1), unknownp);
|
n = max_attr_value (XVECEXP (exp, 0, i + 1), unknownp);
|
if (n > current_max)
|
if (n > current_max)
|
current_max = n;
|
current_max = n;
|
}
|
}
|
break;
|
break;
|
|
|
case IF_THEN_ELSE:
|
case IF_THEN_ELSE:
|
current_max = max_attr_value (XEXP (exp, 1), unknownp);
|
current_max = max_attr_value (XEXP (exp, 1), unknownp);
|
n = max_attr_value (XEXP (exp, 2), unknownp);
|
n = max_attr_value (XEXP (exp, 2), unknownp);
|
if (n > current_max)
|
if (n > current_max)
|
current_max = n;
|
current_max = n;
|
break;
|
break;
|
|
|
default:
|
default:
|
*unknownp = 1;
|
*unknownp = 1;
|
current_max = INT_MAX;
|
current_max = INT_MAX;
|
break;
|
break;
|
}
|
}
|
|
|
return current_max;
|
return current_max;
|
}
|
}
|
|
|
/* Given an attribute value, return the minimum CONST_STRING argument
|
/* Given an attribute value, return the minimum CONST_STRING argument
|
encountered. Set *UNKNOWNP and return 0 if the value is unknown. */
|
encountered. Set *UNKNOWNP and return 0 if the value is unknown. */
|
|
|
static int
|
static int
|
min_attr_value (rtx exp, int *unknownp)
|
min_attr_value (rtx exp, int *unknownp)
|
{
|
{
|
int current_min;
|
int current_min;
|
int i, n;
|
int i, n;
|
|
|
switch (GET_CODE (exp))
|
switch (GET_CODE (exp))
|
{
|
{
|
case CONST_STRING:
|
case CONST_STRING:
|
current_min = atoi (XSTR (exp, 0));
|
current_min = atoi (XSTR (exp, 0));
|
break;
|
break;
|
|
|
case COND:
|
case COND:
|
current_min = min_attr_value (XEXP (exp, 1), unknownp);
|
current_min = min_attr_value (XEXP (exp, 1), unknownp);
|
for (i = 0; i < XVECLEN (exp, 0); i += 2)
|
for (i = 0; i < XVECLEN (exp, 0); i += 2)
|
{
|
{
|
n = min_attr_value (XVECEXP (exp, 0, i + 1), unknownp);
|
n = min_attr_value (XVECEXP (exp, 0, i + 1), unknownp);
|
if (n < current_min)
|
if (n < current_min)
|
current_min = n;
|
current_min = n;
|
}
|
}
|
break;
|
break;
|
|
|
case IF_THEN_ELSE:
|
case IF_THEN_ELSE:
|
current_min = min_attr_value (XEXP (exp, 1), unknownp);
|
current_min = min_attr_value (XEXP (exp, 1), unknownp);
|
n = min_attr_value (XEXP (exp, 2), unknownp);
|
n = min_attr_value (XEXP (exp, 2), unknownp);
|
if (n < current_min)
|
if (n < current_min)
|
current_min = n;
|
current_min = n;
|
break;
|
break;
|
|
|
default:
|
default:
|
*unknownp = 1;
|
*unknownp = 1;
|
current_min = INT_MAX;
|
current_min = INT_MAX;
|
break;
|
break;
|
}
|
}
|
|
|
return current_min;
|
return current_min;
|
}
|
}
|
|
|
/* Given an attribute value, return the result of ORing together all
|
/* Given an attribute value, return the result of ORing together all
|
CONST_STRING arguments encountered. Set *UNKNOWNP and return -1
|
CONST_STRING arguments encountered. Set *UNKNOWNP and return -1
|
if the numeric value is not known. */
|
if the numeric value is not known. */
|
|
|
static int
|
static int
|
or_attr_value (rtx exp, int *unknownp)
|
or_attr_value (rtx exp, int *unknownp)
|
{
|
{
|
int current_or;
|
int current_or;
|
int i;
|
int i;
|
|
|
switch (GET_CODE (exp))
|
switch (GET_CODE (exp))
|
{
|
{
|
case CONST_STRING:
|
case CONST_STRING:
|
current_or = atoi (XSTR (exp, 0));
|
current_or = atoi (XSTR (exp, 0));
|
break;
|
break;
|
|
|
case COND:
|
case COND:
|
current_or = or_attr_value (XEXP (exp, 1), unknownp);
|
current_or = or_attr_value (XEXP (exp, 1), unknownp);
|
for (i = 0; i < XVECLEN (exp, 0); i += 2)
|
for (i = 0; i < XVECLEN (exp, 0); i += 2)
|
current_or |= or_attr_value (XVECEXP (exp, 0, i + 1), unknownp);
|
current_or |= or_attr_value (XVECEXP (exp, 0, i + 1), unknownp);
|
break;
|
break;
|
|
|
case IF_THEN_ELSE:
|
case IF_THEN_ELSE:
|
current_or = or_attr_value (XEXP (exp, 1), unknownp);
|
current_or = or_attr_value (XEXP (exp, 1), unknownp);
|
current_or |= or_attr_value (XEXP (exp, 2), unknownp);
|
current_or |= or_attr_value (XEXP (exp, 2), unknownp);
|
break;
|
break;
|
|
|
default:
|
default:
|
*unknownp = 1;
|
*unknownp = 1;
|
current_or = -1;
|
current_or = -1;
|
break;
|
break;
|
}
|
}
|
|
|
return current_or;
|
return current_or;
|
}
|
}
|
|
|
/* Scan an attribute value, possibly a conditional, and record what actions
|
/* Scan an attribute value, possibly a conditional, and record what actions
|
will be required to do any conditional tests in it.
|
will be required to do any conditional tests in it.
|
|
|
Specifically, set
|
Specifically, set
|
`must_extract' if we need to extract the insn operands
|
`must_extract' if we need to extract the insn operands
|
`must_constrain' if we must compute `which_alternative'
|
`must_constrain' if we must compute `which_alternative'
|
`address_used' if an address expression was used
|
`address_used' if an address expression was used
|
`length_used' if an (eq_attr "length" ...) was used
|
`length_used' if an (eq_attr "length" ...) was used
|
*/
|
*/
|
|
|
static void
|
static void
|
walk_attr_value (rtx exp)
|
walk_attr_value (rtx exp)
|
{
|
{
|
int i, j;
|
int i, j;
|
const char *fmt;
|
const char *fmt;
|
RTX_CODE code;
|
RTX_CODE code;
|
|
|
if (exp == NULL)
|
if (exp == NULL)
|
return;
|
return;
|
|
|
code = GET_CODE (exp);
|
code = GET_CODE (exp);
|
switch (code)
|
switch (code)
|
{
|
{
|
case SYMBOL_REF:
|
case SYMBOL_REF:
|
if (! ATTR_IND_SIMPLIFIED_P (exp))
|
if (! ATTR_IND_SIMPLIFIED_P (exp))
|
/* Since this is an arbitrary expression, it can look at anything.
|
/* Since this is an arbitrary expression, it can look at anything.
|
However, constant expressions do not depend on any particular
|
However, constant expressions do not depend on any particular
|
insn. */
|
insn. */
|
must_extract = must_constrain = 1;
|
must_extract = must_constrain = 1;
|
return;
|
return;
|
|
|
case MATCH_OPERAND:
|
case MATCH_OPERAND:
|
must_extract = 1;
|
must_extract = 1;
|
return;
|
return;
|
|
|
case EQ_ATTR_ALT:
|
case EQ_ATTR_ALT:
|
must_extract = must_constrain = 1;
|
must_extract = must_constrain = 1;
|
break;
|
break;
|
|
|
case EQ_ATTR:
|
case EQ_ATTR:
|
if (XSTR (exp, 0) == alternative_name)
|
if (XSTR (exp, 0) == alternative_name)
|
must_extract = must_constrain = 1;
|
must_extract = must_constrain = 1;
|
else if (strcmp_check (XSTR (exp, 0), length_str) == 0)
|
else if (strcmp_check (XSTR (exp, 0), length_str) == 0)
|
length_used = 1;
|
length_used = 1;
|
return;
|
return;
|
|
|
case MATCH_DUP:
|
case MATCH_DUP:
|
must_extract = 1;
|
must_extract = 1;
|
address_used = 1;
|
address_used = 1;
|
return;
|
return;
|
|
|
case PC:
|
case PC:
|
address_used = 1;
|
address_used = 1;
|
return;
|
return;
|
|
|
case ATTR_FLAG:
|
case ATTR_FLAG:
|
return;
|
return;
|
|
|
default:
|
default:
|
break;
|
break;
|
}
|
}
|
|
|
for (i = 0, fmt = GET_RTX_FORMAT (code); i < GET_RTX_LENGTH (code); i++)
|
for (i = 0, fmt = GET_RTX_FORMAT (code); i < GET_RTX_LENGTH (code); i++)
|
switch (*fmt++)
|
switch (*fmt++)
|
{
|
{
|
case 'e':
|
case 'e':
|
case 'u':
|
case 'u':
|
walk_attr_value (XEXP (exp, i));
|
walk_attr_value (XEXP (exp, i));
|
break;
|
break;
|
|
|
case 'E':
|
case 'E':
|
if (XVEC (exp, i) != NULL)
|
if (XVEC (exp, i) != NULL)
|
for (j = 0; j < XVECLEN (exp, i); j++)
|
for (j = 0; j < XVECLEN (exp, i); j++)
|
walk_attr_value (XVECEXP (exp, i, j));
|
walk_attr_value (XVECEXP (exp, i, j));
|
break;
|
break;
|
}
|
}
|
}
|
}
|
|
|
/* Write out a function to obtain the attribute for a given INSN. */
|
/* Write out a function to obtain the attribute for a given INSN. */
|
|
|
static void
|
static void
|
write_attr_get (struct attr_desc *attr)
|
write_attr_get (struct attr_desc *attr)
|
{
|
{
|
struct attr_value *av, *common_av;
|
struct attr_value *av, *common_av;
|
|
|
/* Find the most used attribute value. Handle that as the `default' of the
|
/* Find the most used attribute value. Handle that as the `default' of the
|
switch we will generate. */
|
switch we will generate. */
|
common_av = find_most_used (attr);
|
common_av = find_most_used (attr);
|
|
|
/* Write out start of function, then all values with explicit `case' lines,
|
/* Write out start of function, then all values with explicit `case' lines,
|
then a `default', then the value with the most uses. */
|
then a `default', then the value with the most uses. */
|
if (!attr->is_numeric)
|
if (!attr->is_numeric)
|
printf ("enum attr_%s\n", attr->name);
|
printf ("enum attr_%s\n", attr->name);
|
else
|
else
|
printf ("int\n");
|
printf ("int\n");
|
|
|
/* If the attribute name starts with a star, the remainder is the name of
|
/* If the attribute name starts with a star, the remainder is the name of
|
the subroutine to use, instead of `get_attr_...'. */
|
the subroutine to use, instead of `get_attr_...'. */
|
if (attr->name[0] == '*')
|
if (attr->name[0] == '*')
|
printf ("%s (rtx insn ATTRIBUTE_UNUSED)\n", &attr->name[1]);
|
printf ("%s (rtx insn ATTRIBUTE_UNUSED)\n", &attr->name[1]);
|
else if (attr->is_const == 0)
|
else if (attr->is_const == 0)
|
printf ("get_attr_%s (rtx insn ATTRIBUTE_UNUSED)\n", attr->name);
|
printf ("get_attr_%s (rtx insn ATTRIBUTE_UNUSED)\n", attr->name);
|
else
|
else
|
{
|
{
|
printf ("get_attr_%s (void)\n", attr->name);
|
printf ("get_attr_%s (void)\n", attr->name);
|
printf ("{\n");
|
printf ("{\n");
|
|
|
for (av = attr->first_value; av; av = av->next)
|
for (av = attr->first_value; av; av = av->next)
|
if (av->num_insns == 1)
|
if (av->num_insns == 1)
|
write_attr_set (attr, 2, av->value, "return", ";",
|
write_attr_set (attr, 2, av->value, "return", ";",
|
true_rtx, av->first_insn->def->insn_code,
|
true_rtx, av->first_insn->def->insn_code,
|
av->first_insn->def->insn_index);
|
av->first_insn->def->insn_index);
|
else if (av->num_insns != 0)
|
else if (av->num_insns != 0)
|
write_attr_set (attr, 2, av->value, "return", ";",
|
write_attr_set (attr, 2, av->value, "return", ";",
|
true_rtx, -2, 0);
|
true_rtx, -2, 0);
|
|
|
printf ("}\n\n");
|
printf ("}\n\n");
|
return;
|
return;
|
}
|
}
|
|
|
printf ("{\n");
|
printf ("{\n");
|
printf (" switch (recog_memoized (insn))\n");
|
printf (" switch (recog_memoized (insn))\n");
|
printf (" {\n");
|
printf (" {\n");
|
|
|
for (av = attr->first_value; av; av = av->next)
|
for (av = attr->first_value; av; av = av->next)
|
if (av != common_av)
|
if (av != common_av)
|
write_attr_case (attr, av, 1, "return", ";", 4, true_rtx);
|
write_attr_case (attr, av, 1, "return", ";", 4, true_rtx);
|
|
|
write_attr_case (attr, common_av, 0, "return", ";", 4, true_rtx);
|
write_attr_case (attr, common_av, 0, "return", ";", 4, true_rtx);
|
printf (" }\n}\n\n");
|
printf (" }\n}\n\n");
|
}
|
}
|
|
|
/* Given an AND tree of known true terms (because we are inside an `if' with
|
/* 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,
|
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
|
replace any known true terms with TRUE. Use `simplify_and_tree' to do
|
the bulk of the work. */
|
the bulk of the work. */
|
|
|
static rtx
|
static rtx
|
eliminate_known_true (rtx known_true, rtx exp, int insn_code, int insn_index)
|
eliminate_known_true (rtx known_true, rtx exp, int insn_code, int insn_index)
|
{
|
{
|
rtx term;
|
rtx term;
|
|
|
known_true = SIMPLIFY_TEST_EXP (known_true, insn_code, insn_index);
|
known_true = SIMPLIFY_TEST_EXP (known_true, insn_code, insn_index);
|
|
|
if (GET_CODE (known_true) == AND)
|
if (GET_CODE (known_true) == AND)
|
{
|
{
|
exp = eliminate_known_true (XEXP (known_true, 0), exp,
|
exp = eliminate_known_true (XEXP (known_true, 0), exp,
|
insn_code, insn_index);
|
insn_code, insn_index);
|
exp = eliminate_known_true (XEXP (known_true, 1), exp,
|
exp = eliminate_known_true (XEXP (known_true, 1), exp,
|
insn_code, insn_index);
|
insn_code, insn_index);
|
}
|
}
|
else
|
else
|
{
|
{
|
term = known_true;
|
term = known_true;
|
exp = simplify_and_tree (exp, &term, insn_code, insn_index);
|
exp = simplify_and_tree (exp, &term, insn_code, insn_index);
|
}
|
}
|
|
|
return exp;
|
return exp;
|
}
|
}
|
|
|
/* Write out a series of tests and assignment statements to perform tests and
|
/* 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
|
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"
|
and suffix strings to write around each attribute value (e.g., "return"
|
and ";"). */
|
and ";"). */
|
|
|
static void
|
static void
|
write_attr_set (struct attr_desc *attr, int indent, rtx value,
|
write_attr_set (struct attr_desc *attr, int indent, rtx value,
|
const char *prefix, const char *suffix, rtx known_true,
|
const char *prefix, const char *suffix, rtx known_true,
|
int insn_code, int insn_index)
|
int insn_code, int insn_index)
|
{
|
{
|
if (GET_CODE (value) == COND)
|
if (GET_CODE (value) == COND)
|
{
|
{
|
/* Assume the default value will be the default of the COND unless we
|
/* Assume the default value will be the default of the COND unless we
|
find an always true expression. */
|
find an always true expression. */
|
rtx default_val = XEXP (value, 1);
|
rtx default_val = XEXP (value, 1);
|
rtx our_known_true = known_true;
|
rtx our_known_true = known_true;
|
rtx newexp;
|
rtx newexp;
|
int first_if = 1;
|
int first_if = 1;
|
int i;
|
int i;
|
|
|
for (i = 0; i < XVECLEN (value, 0); i += 2)
|
for (i = 0; i < XVECLEN (value, 0); i += 2)
|
{
|
{
|
rtx testexp;
|
rtx testexp;
|
rtx inner_true;
|
rtx inner_true;
|
|
|
testexp = eliminate_known_true (our_known_true,
|
testexp = eliminate_known_true (our_known_true,
|
XVECEXP (value, 0, i),
|
XVECEXP (value, 0, i),
|
insn_code, insn_index);
|
insn_code, insn_index);
|
newexp = attr_rtx (NOT, testexp);
|
newexp = attr_rtx (NOT, testexp);
|
newexp = insert_right_side (AND, our_known_true, newexp,
|
newexp = insert_right_side (AND, our_known_true, newexp,
|
insn_code, insn_index);
|
insn_code, insn_index);
|
|
|
/* If the test expression is always true or if the next `known_true'
|
/* If the test expression is always true or if the next `known_true'
|
expression is always false, this is the last case, so break
|
expression is always false, this is the last case, so break
|
out and let this value be the `else' case. */
|
out and let this value be the `else' case. */
|
if (testexp == true_rtx || newexp == false_rtx)
|
if (testexp == true_rtx || newexp == false_rtx)
|
{
|
{
|
default_val = XVECEXP (value, 0, i + 1);
|
default_val = XVECEXP (value, 0, i + 1);
|
break;
|
break;
|
}
|
}
|
|
|
/* Compute the expression to pass to our recursive call as being
|
/* Compute the expression to pass to our recursive call as being
|
known true. */
|
known true. */
|
inner_true = insert_right_side (AND, our_known_true,
|
inner_true = insert_right_side (AND, our_known_true,
|
testexp, insn_code, insn_index);
|
testexp, insn_code, insn_index);
|
|
|
/* If this is always false, skip it. */
|
/* If this is always false, skip it. */
|
if (inner_true == false_rtx)
|
if (inner_true == false_rtx)
|
continue;
|
continue;
|
|
|
write_indent (indent);
|
write_indent (indent);
|
printf ("%sif ", first_if ? "" : "else ");
|
printf ("%sif ", first_if ? "" : "else ");
|
first_if = 0;
|
first_if = 0;
|
write_test_expr (testexp, 0);
|
write_test_expr (testexp, 0);
|
printf ("\n");
|
printf ("\n");
|
write_indent (indent + 2);
|
write_indent (indent + 2);
|
printf ("{\n");
|
printf ("{\n");
|
|
|
write_attr_set (attr, indent + 4,
|
write_attr_set (attr, indent + 4,
|
XVECEXP (value, 0, i + 1), prefix, suffix,
|
XVECEXP (value, 0, i + 1), prefix, suffix,
|
inner_true, insn_code, insn_index);
|
inner_true, insn_code, insn_index);
|
write_indent (indent + 2);
|
write_indent (indent + 2);
|
printf ("}\n");
|
printf ("}\n");
|
our_known_true = newexp;
|
our_known_true = newexp;
|
}
|
}
|
|
|
if (! first_if)
|
if (! first_if)
|
{
|
{
|
write_indent (indent);
|
write_indent (indent);
|
printf ("else\n");
|
printf ("else\n");
|
write_indent (indent + 2);
|
write_indent (indent + 2);
|
printf ("{\n");
|
printf ("{\n");
|
}
|
}
|
|
|
write_attr_set (attr, first_if ? indent : indent + 4, default_val,
|
write_attr_set (attr, first_if ? indent : indent + 4, default_val,
|
prefix, suffix, our_known_true, insn_code, insn_index);
|
prefix, suffix, our_known_true, insn_code, insn_index);
|
|
|
if (! first_if)
|
if (! first_if)
|
{
|
{
|
write_indent (indent + 2);
|
write_indent (indent + 2);
|
printf ("}\n");
|
printf ("}\n");
|
}
|
}
|
}
|
}
|
else
|
else
|
{
|
{
|
write_indent (indent);
|
write_indent (indent);
|
printf ("%s ", prefix);
|
printf ("%s ", prefix);
|
write_attr_value (attr, value);
|
write_attr_value (attr, value);
|
printf ("%s\n", suffix);
|
printf ("%s\n", suffix);
|
}
|
}
|
}
|
}
|
|
|
/* Write a series of case statements for every instruction in list IE.
|
/* Write a series of case statements for every instruction in list IE.
|
INDENT is the amount of indentation to write before each case. */
|
INDENT is the amount of indentation to write before each case. */
|
|
|
static void
|
static void
|
write_insn_cases (struct insn_ent *ie, int indent)
|
write_insn_cases (struct insn_ent *ie, int indent)
|
{
|
{
|
for (; ie != 0; ie = ie->next)
|
for (; ie != 0; ie = ie->next)
|
if (ie->def->insn_code != -1)
|
if (ie->def->insn_code != -1)
|
{
|
{
|
write_indent (indent);
|
write_indent (indent);
|
if (GET_CODE (ie->def->def) == DEFINE_PEEPHOLE)
|
if (GET_CODE (ie->def->def) == DEFINE_PEEPHOLE)
|
printf ("case %d: /* define_peephole, line %d */\n",
|
printf ("case %d: /* define_peephole, line %d */\n",
|
ie->def->insn_code, ie->def->lineno);
|
ie->def->insn_code, ie->def->lineno);
|
else
|
else
|
printf ("case %d: /* %s */\n",
|
printf ("case %d: /* %s */\n",
|
ie->def->insn_code, XSTR (ie->def->def, 0));
|
ie->def->insn_code, XSTR (ie->def->def, 0));
|
}
|
}
|
}
|
}
|
|
|
/* Write out the computation for one attribute value. */
|
/* Write out the computation for one attribute value. */
|
|
|
static void
|
static void
|
write_attr_case (struct attr_desc *attr, struct attr_value *av,
|
write_attr_case (struct attr_desc *attr, struct attr_value *av,
|
int write_case_lines, const char *prefix, const char *suffix,
|
int write_case_lines, const char *prefix, const char *suffix,
|
int indent, rtx known_true)
|
int indent, rtx known_true)
|
{
|
{
|
if (av->num_insns == 0)
|
if (av->num_insns == 0)
|
return;
|
return;
|
|
|
if (av->has_asm_insn)
|
if (av->has_asm_insn)
|
{
|
{
|
write_indent (indent);
|
write_indent (indent);
|
printf ("case -1:\n");
|
printf ("case -1:\n");
|
write_indent (indent + 2);
|
write_indent (indent + 2);
|
printf ("if (GET_CODE (PATTERN (insn)) != ASM_INPUT\n");
|
printf ("if (GET_CODE (PATTERN (insn)) != ASM_INPUT\n");
|
write_indent (indent + 2);
|
write_indent (indent + 2);
|
printf (" && asm_noperands (PATTERN (insn)) < 0)\n");
|
printf (" && asm_noperands (PATTERN (insn)) < 0)\n");
|
write_indent (indent + 2);
|
write_indent (indent + 2);
|
printf (" fatal_insn_not_found (insn);\n");
|
printf (" fatal_insn_not_found (insn);\n");
|
}
|
}
|
|
|
if (write_case_lines)
|
if (write_case_lines)
|
write_insn_cases (av->first_insn, indent);
|
write_insn_cases (av->first_insn, indent);
|
else
|
else
|
{
|
{
|
write_indent (indent);
|
write_indent (indent);
|
printf ("default:\n");
|
printf ("default:\n");
|
}
|
}
|
|
|
/* See what we have to do to output this value. */
|
/* See what we have to do to output this value. */
|
must_extract = must_constrain = address_used = 0;
|
must_extract = must_constrain = address_used = 0;
|
walk_attr_value (av->value);
|
walk_attr_value (av->value);
|
|
|
if (must_constrain)
|
if (must_constrain)
|
{
|
{
|
write_indent (indent + 2);
|
write_indent (indent + 2);
|
printf ("extract_constrain_insn_cached (insn);\n");
|
printf ("extract_constrain_insn_cached (insn);\n");
|
}
|
}
|
else if (must_extract)
|
else if (must_extract)
|
{
|
{
|
write_indent (indent + 2);
|
write_indent (indent + 2);
|
printf ("extract_insn_cached (insn);\n");
|
printf ("extract_insn_cached (insn);\n");
|
}
|
}
|
|
|
if (av->num_insns == 1)
|
if (av->num_insns == 1)
|
write_attr_set (attr, indent + 2, av->value, prefix, suffix,
|
write_attr_set (attr, indent + 2, av->value, prefix, suffix,
|
known_true, av->first_insn->def->insn_code,
|
known_true, av->first_insn->def->insn_code,
|
av->first_insn->def->insn_index);
|
av->first_insn->def->insn_index);
|
else
|
else
|
write_attr_set (attr, indent + 2, av->value, prefix, suffix,
|
write_attr_set (attr, indent + 2, av->value, prefix, suffix,
|
known_true, -2, 0);
|
known_true, -2, 0);
|
|
|
if (strncmp (prefix, "return", 6))
|
if (strncmp (prefix, "return", 6))
|
{
|
{
|
write_indent (indent + 2);
|
write_indent (indent + 2);
|
printf ("break;\n");
|
printf ("break;\n");
|
}
|
}
|
printf ("\n");
|
printf ("\n");
|
}
|
}
|
|
|
/* Utilities to write in various forms. */
|
/* Utilities to write in various forms. */
|
|
|
static void
|
static void
|
write_attr_valueq (struct attr_desc *attr, const char *s)
|
write_attr_valueq (struct attr_desc *attr, const char *s)
|
{
|
{
|
if (attr->is_numeric)
|
if (attr->is_numeric)
|
{
|
{
|
int num = atoi (s);
|
int num = atoi (s);
|
|
|
printf ("%d", num);
|
printf ("%d", num);
|
|
|
if (num > 9 || num < 0)
|
if (num > 9 || num < 0)
|
printf (" /* 0x%x */", num);
|
printf (" /* 0x%x */", num);
|
}
|
}
|
else
|
else
|
{
|
{
|
write_upcase (attr->name);
|
write_upcase (attr->name);
|
printf ("_");
|
printf ("_");
|
write_upcase (s);
|
write_upcase (s);
|
}
|
}
|
}
|
}
|
|
|
static void
|
static void
|
write_attr_value (struct attr_desc *attr, rtx value)
|
write_attr_value (struct attr_desc *attr, rtx value)
|
{
|
{
|
int op;
|
int op;
|
|
|
switch (GET_CODE (value))
|
switch (GET_CODE (value))
|
{
|
{
|
case CONST_STRING:
|
case CONST_STRING:
|
write_attr_valueq (attr, XSTR (value, 0));
|
write_attr_valueq (attr, XSTR (value, 0));
|
break;
|
break;
|
|
|
case CONST_INT:
|
case CONST_INT:
|
printf (HOST_WIDE_INT_PRINT_DEC, INTVAL (value));
|
printf (HOST_WIDE_INT_PRINT_DEC, INTVAL (value));
|
break;
|
break;
|
|
|
case SYMBOL_REF:
|
case SYMBOL_REF:
|
print_c_condition (XSTR (value, 0));
|
print_c_condition (XSTR (value, 0));
|
break;
|
break;
|
|
|
case ATTR:
|
case ATTR:
|
{
|
{
|
struct attr_desc *attr2 = find_attr (&XSTR (value, 0), 0);
|
struct attr_desc *attr2 = find_attr (&XSTR (value, 0), 0);
|
printf ("get_attr_%s (%s)", attr2->name,
|
printf ("get_attr_%s (%s)", attr2->name,
|
(attr2->is_const ? "" : "insn"));
|
(attr2->is_const ? "" : "insn"));
|
}
|
}
|
break;
|
break;
|
|
|
case PLUS:
|
case PLUS:
|
op = '+';
|
op = '+';
|
goto do_operator;
|
goto do_operator;
|
case MINUS:
|
case MINUS:
|
op = '-';
|
op = '-';
|
goto do_operator;
|
goto do_operator;
|
case MULT:
|
case MULT:
|
op = '*';
|
op = '*';
|
goto do_operator;
|
goto do_operator;
|
case DIV:
|
case DIV:
|
op = '/';
|
op = '/';
|
goto do_operator;
|
goto do_operator;
|
case MOD:
|
case MOD:
|
op = '%';
|
op = '%';
|
goto do_operator;
|
goto do_operator;
|
|
|
do_operator:
|
do_operator:
|
write_attr_value (attr, XEXP (value, 0));
|
write_attr_value (attr, XEXP (value, 0));
|
putchar (' ');
|
putchar (' ');
|
putchar (op);
|
putchar (op);
|
putchar (' ');
|
putchar (' ');
|
write_attr_value (attr, XEXP (value, 1));
|
write_attr_value (attr, XEXP (value, 1));
|
break;
|
break;
|
|
|
default:
|
default:
|
gcc_unreachable ();
|
gcc_unreachable ();
|
}
|
}
|
}
|
}
|
|
|
static void
|
static void
|
write_upcase (const char *str)
|
write_upcase (const char *str)
|
{
|
{
|
while (*str)
|
while (*str)
|
{
|
{
|
/* The argument of TOUPPER should not have side effects. */
|
/* The argument of TOUPPER should not have side effects. */
|
putchar (TOUPPER(*str));
|
putchar (TOUPPER(*str));
|
str++;
|
str++;
|
}
|
}
|
}
|
}
|
|
|
static void
|
static void
|
write_indent (int indent)
|
write_indent (int indent)
|
{
|
{
|
for (; indent > 8; indent -= 8)
|
for (; indent > 8; indent -= 8)
|
printf ("\t");
|
printf ("\t");
|
|
|
for (; indent; indent--)
|
for (; indent; indent--)
|
printf (" ");
|
printf (" ");
|
}
|
}
|
|
|
/* Write a subroutine that is given an insn that requires a delay slot, a
|
/* Write a subroutine that is given an insn that requires a delay slot, a
|
delay slot ordinal, and a candidate insn. It returns nonzero if the
|
delay slot ordinal, and a candidate insn. It returns nonzero if the
|
candidate can be placed in the specified delay slot of the insn.
|
candidate can be placed in the specified delay slot of the insn.
|
|
|
We can write as many as three subroutines. `eligible_for_delay'
|
We can write as many as three subroutines. `eligible_for_delay'
|
handles normal delay slots, `eligible_for_annul_true' indicates that
|
handles normal delay slots, `eligible_for_annul_true' indicates that
|
the specified insn can be annulled if the branch is true, and likewise
|
the specified insn can be annulled if the branch is true, and likewise
|
for `eligible_for_annul_false'.
|
for `eligible_for_annul_false'.
|
|
|
KIND is a string distinguishing these three cases ("delay", "annul_true",
|
KIND is a string distinguishing these three cases ("delay", "annul_true",
|
or "annul_false"). */
|
or "annul_false"). */
|
|
|
static void
|
static void
|
write_eligible_delay (const char *kind)
|
write_eligible_delay (const char *kind)
|
{
|
{
|
struct delay_desc *delay;
|
struct delay_desc *delay;
|
int max_slots;
|
int max_slots;
|
char str[50];
|
char str[50];
|
const char *pstr;
|
const char *pstr;
|
struct attr_desc *attr;
|
struct attr_desc *attr;
|
struct attr_value *av, *common_av;
|
struct attr_value *av, *common_av;
|
int i;
|
int i;
|
|
|
/* Compute the maximum number of delay slots required. We use the delay
|
/* 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
|
ordinal times this number plus one, plus the slot number as an index into
|
the appropriate predicate to test. */
|
the appropriate predicate to test. */
|
|
|
for (delay = delays, max_slots = 0; delay; delay = delay->next)
|
for (delay = delays, max_slots = 0; delay; delay = delay->next)
|
if (XVECLEN (delay->def, 1) / 3 > max_slots)
|
if (XVECLEN (delay->def, 1) / 3 > max_slots)
|
max_slots = XVECLEN (delay->def, 1) / 3;
|
max_slots = XVECLEN (delay->def, 1) / 3;
|
|
|
/* Write function prelude. */
|
/* Write function prelude. */
|
|
|
printf ("int\n");
|
printf ("int\n");
|
printf ("eligible_for_%s (rtx delay_insn ATTRIBUTE_UNUSED, int slot, rtx candidate_insn, int flags ATTRIBUTE_UNUSED)\n",
|
printf ("eligible_for_%s (rtx delay_insn ATTRIBUTE_UNUSED, int slot, rtx candidate_insn, int flags ATTRIBUTE_UNUSED)\n",
|
kind);
|
kind);
|
printf ("{\n");
|
printf ("{\n");
|
printf (" rtx insn;\n");
|
printf (" rtx insn;\n");
|
printf ("\n");
|
printf ("\n");
|
printf (" gcc_assert (slot < %d);\n", max_slots);
|
printf (" gcc_assert (slot < %d);\n", max_slots);
|
printf ("\n");
|
printf ("\n");
|
/* Allow dbr_schedule to pass labels, etc. This can happen if try_split
|
/* Allow dbr_schedule to pass labels, etc. This can happen if try_split
|
converts a compound instruction into a loop. */
|
converts a compound instruction into a loop. */
|
printf (" if (!INSN_P (candidate_insn))\n");
|
printf (" if (!INSN_P (candidate_insn))\n");
|
printf (" return 0;\n");
|
printf (" return 0;\n");
|
printf ("\n");
|
printf ("\n");
|
|
|
/* If more than one delay type, find out which type the delay insn is. */
|
/* If more than one delay type, find out which type the delay insn is. */
|
|
|
if (num_delays > 1)
|
if (num_delays > 1)
|
{
|
{
|
attr = find_attr (&delay_type_str, 0);
|
attr = find_attr (&delay_type_str, 0);
|
gcc_assert (attr);
|
gcc_assert (attr);
|
common_av = find_most_used (attr);
|
common_av = find_most_used (attr);
|
|
|
printf (" insn = delay_insn;\n");
|
printf (" insn = delay_insn;\n");
|
printf (" switch (recog_memoized (insn))\n");
|
printf (" switch (recog_memoized (insn))\n");
|
printf (" {\n");
|
printf (" {\n");
|
|
|
sprintf (str, " * %d;\n break;", max_slots);
|
sprintf (str, " * %d;\n break;", max_slots);
|
for (av = attr->first_value; av; av = av->next)
|
for (av = attr->first_value; av; av = av->next)
|
if (av != common_av)
|
if (av != common_av)
|
write_attr_case (attr, av, 1, "slot +=", str, 4, true_rtx);
|
write_attr_case (attr, av, 1, "slot +=", str, 4, true_rtx);
|
|
|
write_attr_case (attr, common_av, 0, "slot +=", str, 4, true_rtx);
|
write_attr_case (attr, common_av, 0, "slot +=", str, 4, true_rtx);
|
printf (" }\n\n");
|
printf (" }\n\n");
|
|
|
/* Ensure matched. Otherwise, shouldn't have been called. */
|
/* Ensure matched. Otherwise, shouldn't have been called. */
|
printf (" gcc_assert (slot >= %d);\n\n", max_slots);
|
printf (" gcc_assert (slot >= %d);\n\n", max_slots);
|
}
|
}
|
|
|
/* If just one type of delay slot, write simple switch. */
|
/* If just one type of delay slot, write simple switch. */
|
if (num_delays == 1 && max_slots == 1)
|
if (num_delays == 1 && max_slots == 1)
|
{
|
{
|
printf (" insn = candidate_insn;\n");
|
printf (" insn = candidate_insn;\n");
|
printf (" switch (recog_memoized (insn))\n");
|
printf (" switch (recog_memoized (insn))\n");
|
printf (" {\n");
|
printf (" {\n");
|
|
|
attr = find_attr (&delay_1_0_str, 0);
|
attr = find_attr (&delay_1_0_str, 0);
|
gcc_assert (attr);
|
gcc_assert (attr);
|
common_av = find_most_used (attr);
|
common_av = find_most_used (attr);
|
|
|
for (av = attr->first_value; av; av = av->next)
|
for (av = attr->first_value; av; av = av->next)
|
if (av != common_av)
|
if (av != common_av)
|
write_attr_case (attr, av, 1, "return", ";", 4, true_rtx);
|
write_attr_case (attr, av, 1, "return", ";", 4, true_rtx);
|
|
|
write_attr_case (attr, common_av, 0, "return", ";", 4, true_rtx);
|
write_attr_case (attr, common_av, 0, "return", ";", 4, true_rtx);
|
printf (" }\n");
|
printf (" }\n");
|
}
|
}
|
|
|
else
|
else
|
{
|
{
|
/* Write a nested CASE. The first indicates which condition we need to
|
/* Write a nested CASE. The first indicates which condition we need to
|
test, and the inner CASE tests the condition. */
|
test, and the inner CASE tests the condition. */
|
printf (" insn = candidate_insn;\n");
|
printf (" insn = candidate_insn;\n");
|
printf (" switch (slot)\n");
|
printf (" switch (slot)\n");
|
printf (" {\n");
|
printf (" {\n");
|
|
|
for (delay = delays; delay; delay = delay->next)
|
for (delay = delays; delay; delay = delay->next)
|
for (i = 0; i < XVECLEN (delay->def, 1); i += 3)
|
for (i = 0; i < XVECLEN (delay->def, 1); i += 3)
|
{
|
{
|
printf (" case %d:\n",
|
printf (" case %d:\n",
|
(i / 3) + (num_delays == 1 ? 0 : delay->num * max_slots));
|
(i / 3) + (num_delays == 1 ? 0 : delay->num * max_slots));
|
printf (" switch (recog_memoized (insn))\n");
|
printf (" switch (recog_memoized (insn))\n");
|
printf ("\t{\n");
|
printf ("\t{\n");
|
|
|
sprintf (str, "*%s_%d_%d", kind, delay->num, i / 3);
|
sprintf (str, "*%s_%d_%d", kind, delay->num, i / 3);
|
pstr = str;
|
pstr = str;
|
attr = find_attr (&pstr, 0);
|
attr = find_attr (&pstr, 0);
|
gcc_assert (attr);
|
gcc_assert (attr);
|
common_av = find_most_used (attr);
|
common_av = find_most_used (attr);
|
|
|
for (av = attr->first_value; av; av = av->next)
|
for (av = attr->first_value; av; av = av->next)
|
if (av != common_av)
|
if (av != common_av)
|
write_attr_case (attr, av, 1, "return", ";", 8, true_rtx);
|
write_attr_case (attr, av, 1, "return", ";", 8, true_rtx);
|
|
|
write_attr_case (attr, common_av, 0, "return", ";", 8, true_rtx);
|
write_attr_case (attr, common_av, 0, "return", ";", 8, true_rtx);
|
printf (" }\n");
|
printf (" }\n");
|
}
|
}
|
|
|
printf (" default:\n");
|
printf (" default:\n");
|
printf (" gcc_unreachable ();\n");
|
printf (" gcc_unreachable ();\n");
|
printf (" }\n");
|
printf (" }\n");
|
}
|
}
|
|
|
printf ("}\n\n");
|
printf ("}\n\n");
|
}
|
}
|
|
|
/* This page contains miscellaneous utility routines. */
|
/* This page contains miscellaneous utility routines. */
|
|
|
/* Given a pointer to a (char *), return a malloc'ed string containing the
|
/* Given a pointer to a (char *), return a malloc'ed string containing the
|
next comma-separated element. Advance the pointer to after the string
|
next comma-separated element. Advance the pointer to after the string
|
scanned, or the end-of-string. Return NULL if at end of string. */
|
scanned, or the end-of-string. Return NULL if at end of string. */
|
|
|
static char *
|
static char *
|
next_comma_elt (const char **pstr)
|
next_comma_elt (const char **pstr)
|
{
|
{
|
const char *start;
|
const char *start;
|
|
|
start = scan_comma_elt (pstr);
|
start = scan_comma_elt (pstr);
|
|
|
if (start == NULL)
|
if (start == NULL)
|
return NULL;
|
return NULL;
|
|
|
return attr_string (start, *pstr - start);
|
return attr_string (start, *pstr - start);
|
}
|
}
|
|
|
/* Return a `struct attr_desc' pointer for a given named attribute. If CREATE
|
/* Return a `struct attr_desc' pointer for a given named attribute. If CREATE
|
is nonzero, build a new attribute, if one does not exist. *NAME_P is
|
is nonzero, build a new attribute, if one does not exist. *NAME_P is
|
replaced by a pointer to a canonical copy of the string. */
|
replaced by a pointer to a canonical copy of the string. */
|
|
|
static struct attr_desc *
|
static struct attr_desc *
|
find_attr (const char **name_p, int create)
|
find_attr (const char **name_p, int create)
|
{
|
{
|
struct attr_desc *attr;
|
struct attr_desc *attr;
|
int index;
|
int index;
|
const char *name = *name_p;
|
const char *name = *name_p;
|
|
|
/* Before we resort to using `strcmp', see if the string address matches
|
/* Before we resort to using `strcmp', see if the string address matches
|
anywhere. In most cases, it should have been canonicalized to do so. */
|
anywhere. In most cases, it should have been canonicalized to do so. */
|
if (name == alternative_name)
|
if (name == alternative_name)
|
return NULL;
|
return NULL;
|
|
|
index = name[0] & (MAX_ATTRS_INDEX - 1);
|
index = name[0] & (MAX_ATTRS_INDEX - 1);
|
for (attr = attrs[index]; attr; attr = attr->next)
|
for (attr = attrs[index]; attr; attr = attr->next)
|
if (name == attr->name)
|
if (name == attr->name)
|
return attr;
|
return attr;
|
|
|
/* Otherwise, do it the slow way. */
|
/* Otherwise, do it the slow way. */
|
for (attr = attrs[index]; attr; attr = attr->next)
|
for (attr = attrs[index]; attr; attr = attr->next)
|
if (name[0] == attr->name[0] && ! strcmp (name, attr->name))
|
if (name[0] == attr->name[0] && ! strcmp (name, attr->name))
|
{
|
{
|
*name_p = attr->name;
|
*name_p = attr->name;
|
return attr;
|
return attr;
|
}
|
}
|
|
|
if (! create)
|
if (! create)
|
return NULL;
|
return NULL;
|
|
|
attr = oballoc (struct attr_desc);
|
attr = oballoc (struct attr_desc);
|
attr->name = DEF_ATTR_STRING (name);
|
attr->name = DEF_ATTR_STRING (name);
|
attr->first_value = attr->default_val = NULL;
|
attr->first_value = attr->default_val = NULL;
|
attr->is_numeric = attr->is_const = attr->is_special = 0;
|
attr->is_numeric = attr->is_const = attr->is_special = 0;
|
attr->next = attrs[index];
|
attr->next = attrs[index];
|
attrs[index] = attr;
|
attrs[index] = attr;
|
|
|
*name_p = attr->name;
|
*name_p = attr->name;
|
|
|
return attr;
|
return attr;
|
}
|
}
|
|
|
/* Create internal attribute with the given default value. */
|
/* Create internal attribute with the given default value. */
|
|
|
static void
|
static void
|
make_internal_attr (const char *name, rtx value, int special)
|
make_internal_attr (const char *name, rtx value, int special)
|
{
|
{
|
struct attr_desc *attr;
|
struct attr_desc *attr;
|
|
|
attr = find_attr (&name, 1);
|
attr = find_attr (&name, 1);
|
gcc_assert (!attr->default_val);
|
gcc_assert (!attr->default_val);
|
|
|
attr->is_numeric = 1;
|
attr->is_numeric = 1;
|
attr->is_const = 0;
|
attr->is_const = 0;
|
attr->is_special = (special & ATTR_SPECIAL) != 0;
|
attr->is_special = (special & ATTR_SPECIAL) != 0;
|
attr->default_val = get_attr_value (value, attr, -2);
|
attr->default_val = get_attr_value (value, attr, -2);
|
}
|
}
|
|
|
/* Find the most used value of an attribute. */
|
/* Find the most used value of an attribute. */
|
|
|
static struct attr_value *
|
static struct attr_value *
|
find_most_used (struct attr_desc *attr)
|
find_most_used (struct attr_desc *attr)
|
{
|
{
|
struct attr_value *av;
|
struct attr_value *av;
|
struct attr_value *most_used;
|
struct attr_value *most_used;
|
int nuses;
|
int nuses;
|
|
|
most_used = NULL;
|
most_used = NULL;
|
nuses = -1;
|
nuses = -1;
|
|
|
for (av = attr->first_value; av; av = av->next)
|
for (av = attr->first_value; av; av = av->next)
|
if (av->num_insns > nuses)
|
if (av->num_insns > nuses)
|
nuses = av->num_insns, most_used = av;
|
nuses = av->num_insns, most_used = av;
|
|
|
return most_used;
|
return most_used;
|
}
|
}
|
|
|
/* Return (attr_value "n") */
|
/* Return (attr_value "n") */
|
|
|
static rtx
|
static rtx
|
make_numeric_value (int n)
|
make_numeric_value (int n)
|
{
|
{
|
static rtx int_values[20];
|
static rtx int_values[20];
|
rtx exp;
|
rtx exp;
|
char *p;
|
char *p;
|
|
|
gcc_assert (n >= 0);
|
gcc_assert (n >= 0);
|
|
|
if (n < 20 && int_values[n])
|
if (n < 20 && int_values[n])
|
return int_values[n];
|
return int_values[n];
|
|
|
p = attr_printf (MAX_DIGITS, "%d", n);
|
p = attr_printf (MAX_DIGITS, "%d", n);
|
exp = attr_rtx (CONST_STRING, p);
|
exp = attr_rtx (CONST_STRING, p);
|
|
|
if (n < 20)
|
if (n < 20)
|
int_values[n] = exp;
|
int_values[n] = exp;
|
|
|
return exp;
|
return exp;
|
}
|
}
|
|
|
static rtx
|
static rtx
|
copy_rtx_unchanging (rtx orig)
|
copy_rtx_unchanging (rtx orig)
|
{
|
{
|
if (ATTR_IND_SIMPLIFIED_P (orig) || ATTR_CURR_SIMPLIFIED_P (orig))
|
if (ATTR_IND_SIMPLIFIED_P (orig) || ATTR_CURR_SIMPLIFIED_P (orig))
|
return orig;
|
return orig;
|
|
|
ATTR_CURR_SIMPLIFIED_P (orig) = 1;
|
ATTR_CURR_SIMPLIFIED_P (orig) = 1;
|
return orig;
|
return orig;
|
}
|
}
|
|
|
/* Determine if an insn has a constant number of delay slots, i.e., the
|
/* 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. */
|
number of delay slots is not a function of the length of the insn. */
|
|
|
static void
|
static void
|
write_const_num_delay_slots (void)
|
write_const_num_delay_slots (void)
|
{
|
{
|
struct attr_desc *attr = find_attr (&num_delay_slots_str, 0);
|
struct attr_desc *attr = find_attr (&num_delay_slots_str, 0);
|
struct attr_value *av;
|
struct attr_value *av;
|
|
|
if (attr)
|
if (attr)
|
{
|
{
|
printf ("int\nconst_num_delay_slots (rtx insn)\n");
|
printf ("int\nconst_num_delay_slots (rtx insn)\n");
|
printf ("{\n");
|
printf ("{\n");
|
printf (" switch (recog_memoized (insn))\n");
|
printf (" switch (recog_memoized (insn))\n");
|
printf (" {\n");
|
printf (" {\n");
|
|
|
for (av = attr->first_value; av; av = av->next)
|
for (av = attr->first_value; av; av = av->next)
|
{
|
{
|
length_used = 0;
|
length_used = 0;
|
walk_attr_value (av->value);
|
walk_attr_value (av->value);
|
if (length_used)
|
if (length_used)
|
write_insn_cases (av->first_insn, 4);
|
write_insn_cases (av->first_insn, 4);
|
}
|
}
|
|
|
printf (" default:\n");
|
printf (" default:\n");
|
printf (" return 1;\n");
|
printf (" return 1;\n");
|
printf (" }\n}\n\n");
|
printf (" }\n}\n\n");
|
}
|
}
|
}
|
}
|
|
|
/* Synthetic attributes used by insn-automata.c and the scheduler.
|
/* Synthetic attributes used by insn-automata.c and the scheduler.
|
These are primarily concerned with (define_insn_reservation)
|
These are primarily concerned with (define_insn_reservation)
|
patterns. */
|
patterns. */
|
|
|
struct insn_reserv
|
struct insn_reserv
|
{
|
{
|
struct insn_reserv *next;
|
struct insn_reserv *next;
|
|
|
const char *name;
|
const char *name;
|
int default_latency;
|
int default_latency;
|
rtx condexp;
|
rtx condexp;
|
|
|
/* Sequence number of this insn. */
|
/* Sequence number of this insn. */
|
int insn_num;
|
int insn_num;
|
|
|
/* Whether a (define_bypass) construct names this insn in its
|
/* Whether a (define_bypass) construct names this insn in its
|
output list. */
|
output list. */
|
bool bypassed;
|
bool bypassed;
|
};
|
};
|
|
|
static struct insn_reserv *all_insn_reservs = 0;
|
static struct insn_reserv *all_insn_reservs = 0;
|
static struct insn_reserv **last_insn_reserv_p = &all_insn_reservs;
|
static struct insn_reserv **last_insn_reserv_p = &all_insn_reservs;
|
static size_t n_insn_reservs;
|
static size_t n_insn_reservs;
|
|
|
/* Store information from a DEFINE_INSN_RESERVATION for future
|
/* Store information from a DEFINE_INSN_RESERVATION for future
|
attribute generation. */
|
attribute generation. */
|
static void
|
static void
|
gen_insn_reserv (rtx def)
|
gen_insn_reserv (rtx def)
|
{
|
{
|
struct insn_reserv *decl = oballoc (struct insn_reserv);
|
struct insn_reserv *decl = oballoc (struct insn_reserv);
|
|
|
decl->name = DEF_ATTR_STRING (XSTR (def, 0));
|
decl->name = DEF_ATTR_STRING (XSTR (def, 0));
|
decl->default_latency = XINT (def, 1);
|
decl->default_latency = XINT (def, 1);
|
decl->condexp = check_attr_test (XEXP (def, 2), 0, 0);
|
decl->condexp = check_attr_test (XEXP (def, 2), 0, 0);
|
decl->insn_num = n_insn_reservs;
|
decl->insn_num = n_insn_reservs;
|
decl->bypassed = false;
|
decl->bypassed = false;
|
decl->next = 0;
|
decl->next = 0;
|
|
|
*last_insn_reserv_p = decl;
|
*last_insn_reserv_p = decl;
|
last_insn_reserv_p = &decl->next;
|
last_insn_reserv_p = &decl->next;
|
n_insn_reservs++;
|
n_insn_reservs++;
|
}
|
}
|
|
|
/* Store information from a DEFINE_BYPASS for future attribute
|
/* Store information from a DEFINE_BYPASS for future attribute
|
generation. The only thing we care about is the list of output
|
generation. The only thing we care about is the list of output
|
insns, which will later be used to tag reservation structures with
|
insns, which will later be used to tag reservation structures with
|
a 'bypassed' bit. */
|
a 'bypassed' bit. */
|
|
|
struct bypass_list
|
struct bypass_list
|
{
|
{
|
struct bypass_list *next;
|
struct bypass_list *next;
|
const char *insn;
|
const char *insn;
|
};
|
};
|
|
|
static struct bypass_list *all_bypasses;
|
static struct bypass_list *all_bypasses;
|
static size_t n_bypasses;
|
static size_t n_bypasses;
|
|
|
static void
|
static void
|
gen_bypass_1 (const char *s, size_t len)
|
gen_bypass_1 (const char *s, size_t len)
|
{
|
{
|
struct bypass_list *b;
|
struct bypass_list *b;
|
|
|
if (len == 0)
|
if (len == 0)
|
return;
|
return;
|
|
|
s = attr_string (s, len);
|
s = attr_string (s, len);
|
for (b = all_bypasses; b; b = b->next)
|
for (b = all_bypasses; b; b = b->next)
|
if (s == b->insn)
|
if (s == b->insn)
|
return; /* already got that one */
|
return; /* already got that one */
|
|
|
b = oballoc (struct bypass_list);
|
b = oballoc (struct bypass_list);
|
b->insn = s;
|
b->insn = s;
|
b->next = all_bypasses;
|
b->next = all_bypasses;
|
all_bypasses = b;
|
all_bypasses = b;
|
n_bypasses++;
|
n_bypasses++;
|
}
|
}
|
|
|
static void
|
static void
|
gen_bypass (rtx def)
|
gen_bypass (rtx def)
|
{
|
{
|
const char *p, *base;
|
const char *p, *base;
|
|
|
for (p = base = XSTR (def, 1); *p; p++)
|
for (p = base = XSTR (def, 1); *p; p++)
|
if (*p == ',')
|
if (*p == ',')
|
{
|
{
|
gen_bypass_1 (base, p - base);
|
gen_bypass_1 (base, p - base);
|
do
|
do
|
p++;
|
p++;
|
while (ISSPACE (*p));
|
while (ISSPACE (*p));
|
base = p;
|
base = p;
|
}
|
}
|
gen_bypass_1 (base, p - base);
|
gen_bypass_1 (base, p - base);
|
}
|
}
|
|
|
/* Find and mark all of the bypassed insns. */
|
/* Find and mark all of the bypassed insns. */
|
static void
|
static void
|
process_bypasses (void)
|
process_bypasses (void)
|
{
|
{
|
struct bypass_list *b;
|
struct bypass_list *b;
|
struct insn_reserv *r;
|
struct insn_reserv *r;
|
|
|
/* The reservation list is likely to be much longer than the bypass
|
/* The reservation list is likely to be much longer than the bypass
|
list. */
|
list. */
|
for (r = all_insn_reservs; r; r = r->next)
|
for (r = all_insn_reservs; r; r = r->next)
|
for (b = all_bypasses; b; b = b->next)
|
for (b = all_bypasses; b; b = b->next)
|
if (r->name == b->insn)
|
if (r->name == b->insn)
|
r->bypassed = true;
|
r->bypassed = true;
|
}
|
}
|
|
|
/* Create all of the attributes that describe automaton properties. */
|
/* Create all of the attributes that describe automaton properties. */
|
static void
|
static void
|
make_automaton_attrs (void)
|
make_automaton_attrs (void)
|
{
|
{
|
int i;
|
int i;
|
struct insn_reserv *decl;
|
struct insn_reserv *decl;
|
rtx code_exp, lats_exp, byps_exp;
|
rtx code_exp, lats_exp, byps_exp;
|
|
|
if (n_insn_reservs == 0)
|
if (n_insn_reservs == 0)
|
return;
|
return;
|
|
|
code_exp = rtx_alloc (COND);
|
code_exp = rtx_alloc (COND);
|
lats_exp = rtx_alloc (COND);
|
lats_exp = rtx_alloc (COND);
|
|
|
XVEC (code_exp, 0) = rtvec_alloc (n_insn_reservs * 2);
|
XVEC (code_exp, 0) = rtvec_alloc (n_insn_reservs * 2);
|
XVEC (lats_exp, 0) = rtvec_alloc (n_insn_reservs * 2);
|
XVEC (lats_exp, 0) = rtvec_alloc (n_insn_reservs * 2);
|
|
|
XEXP (code_exp, 1) = make_numeric_value (n_insn_reservs + 1);
|
XEXP (code_exp, 1) = make_numeric_value (n_insn_reservs + 1);
|
XEXP (lats_exp, 1) = make_numeric_value (0);
|
XEXP (lats_exp, 1) = make_numeric_value (0);
|
|
|
for (decl = all_insn_reservs, i = 0;
|
for (decl = all_insn_reservs, i = 0;
|
decl;
|
decl;
|
decl = decl->next, i += 2)
|
decl = decl->next, i += 2)
|
{
|
{
|
XVECEXP (code_exp, 0, i) = decl->condexp;
|
XVECEXP (code_exp, 0, i) = decl->condexp;
|
XVECEXP (lats_exp, 0, i) = decl->condexp;
|
XVECEXP (lats_exp, 0, i) = decl->condexp;
|
|
|
XVECEXP (code_exp, 0, i+1) = make_numeric_value (decl->insn_num);
|
XVECEXP (code_exp, 0, i+1) = make_numeric_value (decl->insn_num);
|
XVECEXP (lats_exp, 0, i+1) = make_numeric_value (decl->default_latency);
|
XVECEXP (lats_exp, 0, i+1) = make_numeric_value (decl->default_latency);
|
}
|
}
|
|
|
if (n_bypasses == 0)
|
if (n_bypasses == 0)
|
byps_exp = make_numeric_value (0);
|
byps_exp = make_numeric_value (0);
|
else
|
else
|
{
|
{
|
process_bypasses ();
|
process_bypasses ();
|
|
|
byps_exp = rtx_alloc (COND);
|
byps_exp = rtx_alloc (COND);
|
XVEC (byps_exp, 0) = rtvec_alloc (n_bypasses * 2);
|
XVEC (byps_exp, 0) = rtvec_alloc (n_bypasses * 2);
|
XEXP (byps_exp, 1) = make_numeric_value (0);
|
XEXP (byps_exp, 1) = make_numeric_value (0);
|
for (decl = all_insn_reservs, i = 0;
|
for (decl = all_insn_reservs, i = 0;
|
decl;
|
decl;
|
decl = decl->next)
|
decl = decl->next)
|
if (decl->bypassed)
|
if (decl->bypassed)
|
{
|
{
|
XVECEXP (byps_exp, 0, i) = decl->condexp;
|
XVECEXP (byps_exp, 0, i) = decl->condexp;
|
XVECEXP (byps_exp, 0, i+1) = make_numeric_value (1);
|
XVECEXP (byps_exp, 0, i+1) = make_numeric_value (1);
|
i += 2;
|
i += 2;
|
}
|
}
|
}
|
}
|
|
|
make_internal_attr ("*internal_dfa_insn_code", code_exp, ATTR_NONE);
|
make_internal_attr ("*internal_dfa_insn_code", code_exp, ATTR_NONE);
|
make_internal_attr ("*insn_default_latency", lats_exp, ATTR_NONE);
|
make_internal_attr ("*insn_default_latency", lats_exp, ATTR_NONE);
|
make_internal_attr ("*bypass_p", byps_exp, ATTR_NONE);
|
make_internal_attr ("*bypass_p", byps_exp, ATTR_NONE);
|
}
|
}
|
|
|
int
|
int
|
main (int argc, char **argv)
|
main (int argc, char **argv)
|
{
|
{
|
rtx desc;
|
rtx desc;
|
struct attr_desc *attr;
|
struct attr_desc *attr;
|
struct insn_def *id;
|
struct insn_def *id;
|
rtx tem;
|
rtx tem;
|
int i;
|
int i;
|
|
|
progname = "genattrtab";
|
progname = "genattrtab";
|
|
|
if (init_md_reader_args (argc, argv) != SUCCESS_EXIT_CODE)
|
if (init_md_reader_args (argc, argv) != SUCCESS_EXIT_CODE)
|
return (FATAL_EXIT_CODE);
|
return (FATAL_EXIT_CODE);
|
|
|
obstack_init (hash_obstack);
|
obstack_init (hash_obstack);
|
obstack_init (temp_obstack);
|
obstack_init (temp_obstack);
|
|
|
/* Set up true and false rtx's */
|
/* Set up true and false rtx's */
|
true_rtx = rtx_alloc (CONST_INT);
|
true_rtx = rtx_alloc (CONST_INT);
|
XWINT (true_rtx, 0) = 1;
|
XWINT (true_rtx, 0) = 1;
|
false_rtx = rtx_alloc (CONST_INT);
|
false_rtx = rtx_alloc (CONST_INT);
|
XWINT (false_rtx, 0) = 0;
|
XWINT (false_rtx, 0) = 0;
|
ATTR_IND_SIMPLIFIED_P (true_rtx) = ATTR_IND_SIMPLIFIED_P (false_rtx) = 1;
|
ATTR_IND_SIMPLIFIED_P (true_rtx) = ATTR_IND_SIMPLIFIED_P (false_rtx) = 1;
|
ATTR_PERMANENT_P (true_rtx) = ATTR_PERMANENT_P (false_rtx) = 1;
|
ATTR_PERMANENT_P (true_rtx) = ATTR_PERMANENT_P (false_rtx) = 1;
|
|
|
alternative_name = DEF_ATTR_STRING ("alternative");
|
alternative_name = DEF_ATTR_STRING ("alternative");
|
length_str = DEF_ATTR_STRING ("length");
|
length_str = DEF_ATTR_STRING ("length");
|
delay_type_str = DEF_ATTR_STRING ("*delay_type");
|
delay_type_str = DEF_ATTR_STRING ("*delay_type");
|
delay_1_0_str = DEF_ATTR_STRING ("*delay_1_0");
|
delay_1_0_str = DEF_ATTR_STRING ("*delay_1_0");
|
num_delay_slots_str = DEF_ATTR_STRING ("*num_delay_slots");
|
num_delay_slots_str = DEF_ATTR_STRING ("*num_delay_slots");
|
|
|
printf ("/* Generated automatically by the program `genattrtab'\n\
|
printf ("/* Generated automatically by the program `genattrtab'\n\
|
from the machine description file `md'. */\n\n");
|
from the machine description file `md'. */\n\n");
|
|
|
/* Read the machine description. */
|
/* Read the machine description. */
|
|
|
while (1)
|
while (1)
|
{
|
{
|
int lineno;
|
int lineno;
|
|
|
desc = read_md_rtx (&lineno, &insn_code_number);
|
desc = read_md_rtx (&lineno, &insn_code_number);
|
if (desc == NULL)
|
if (desc == NULL)
|
break;
|
break;
|
|
|
switch (GET_CODE (desc))
|
switch (GET_CODE (desc))
|
{
|
{
|
case DEFINE_INSN:
|
case DEFINE_INSN:
|
case DEFINE_PEEPHOLE:
|
case DEFINE_PEEPHOLE:
|
case DEFINE_ASM_ATTRIBUTES:
|
case DEFINE_ASM_ATTRIBUTES:
|
gen_insn (desc, lineno);
|
gen_insn (desc, lineno);
|
break;
|
break;
|
|
|
case DEFINE_ATTR:
|
case DEFINE_ATTR:
|
gen_attr (desc, lineno);
|
gen_attr (desc, lineno);
|
break;
|
break;
|
|
|
case DEFINE_DELAY:
|
case DEFINE_DELAY:
|
gen_delay (desc, lineno);
|
gen_delay (desc, lineno);
|
break;
|
break;
|
|
|
case DEFINE_INSN_RESERVATION:
|
case DEFINE_INSN_RESERVATION:
|
gen_insn_reserv (desc);
|
gen_insn_reserv (desc);
|
break;
|
break;
|
|
|
case DEFINE_BYPASS:
|
case DEFINE_BYPASS:
|
gen_bypass (desc);
|
gen_bypass (desc);
|
break;
|
break;
|
|
|
default:
|
default:
|
break;
|
break;
|
}
|
}
|
if (GET_CODE (desc) != DEFINE_ASM_ATTRIBUTES)
|
if (GET_CODE (desc) != DEFINE_ASM_ATTRIBUTES)
|
insn_index_number++;
|
insn_index_number++;
|
}
|
}
|
|
|
if (have_error)
|
if (have_error)
|
return FATAL_EXIT_CODE;
|
return FATAL_EXIT_CODE;
|
|
|
insn_code_number++;
|
insn_code_number++;
|
|
|
/* If we didn't have a DEFINE_ASM_ATTRIBUTES, make a null one. */
|
/* If we didn't have a DEFINE_ASM_ATTRIBUTES, make a null one. */
|
if (! got_define_asm_attributes)
|
if (! got_define_asm_attributes)
|
{
|
{
|
tem = rtx_alloc (DEFINE_ASM_ATTRIBUTES);
|
tem = rtx_alloc (DEFINE_ASM_ATTRIBUTES);
|
XVEC (tem, 0) = rtvec_alloc (0);
|
XVEC (tem, 0) = rtvec_alloc (0);
|
gen_insn (tem, 0);
|
gen_insn (tem, 0);
|
}
|
}
|
|
|
/* Expand DEFINE_DELAY information into new attribute. */
|
/* Expand DEFINE_DELAY information into new attribute. */
|
if (num_delays)
|
if (num_delays)
|
expand_delays ();
|
expand_delays ();
|
|
|
printf ("#include \"config.h\"\n");
|
printf ("#include \"config.h\"\n");
|
printf ("#include \"system.h\"\n");
|
printf ("#include \"system.h\"\n");
|
printf ("#include \"coretypes.h\"\n");
|
printf ("#include \"coretypes.h\"\n");
|
printf ("#include \"tm.h\"\n");
|
printf ("#include \"tm.h\"\n");
|
printf ("#include \"rtl.h\"\n");
|
printf ("#include \"rtl.h\"\n");
|
printf ("#include \"insn-attr.h\"\n");
|
printf ("#include \"insn-attr.h\"\n");
|
printf ("#include \"tm_p.h\"\n");
|
printf ("#include \"tm_p.h\"\n");
|
printf ("#include \"insn-config.h\"\n");
|
printf ("#include \"insn-config.h\"\n");
|
printf ("#include \"recog.h\"\n");
|
printf ("#include \"recog.h\"\n");
|
printf ("#include \"regs.h\"\n");
|
printf ("#include \"regs.h\"\n");
|
printf ("#include \"real.h\"\n");
|
printf ("#include \"real.h\"\n");
|
printf ("#include \"output.h\"\n");
|
printf ("#include \"output.h\"\n");
|
printf ("#include \"toplev.h\"\n");
|
printf ("#include \"toplev.h\"\n");
|
printf ("#include \"flags.h\"\n");
|
printf ("#include \"flags.h\"\n");
|
printf ("#include \"function.h\"\n");
|
printf ("#include \"function.h\"\n");
|
printf ("\n");
|
printf ("\n");
|
printf ("#define operands recog_data.operand\n\n");
|
printf ("#define operands recog_data.operand\n\n");
|
|
|
/* Make `insn_alternatives'. */
|
/* Make `insn_alternatives'. */
|
insn_alternatives = oballocvec (int, insn_code_number);
|
insn_alternatives = oballocvec (int, insn_code_number);
|
for (id = defs; id; id = id->next)
|
for (id = defs; id; id = id->next)
|
if (id->insn_code >= 0)
|
if (id->insn_code >= 0)
|
insn_alternatives[id->insn_code] = (1 << id->num_alternatives) - 1;
|
insn_alternatives[id->insn_code] = (1 << id->num_alternatives) - 1;
|
|
|
/* Make `insn_n_alternatives'. */
|
/* Make `insn_n_alternatives'. */
|
insn_n_alternatives = oballocvec (int, insn_code_number);
|
insn_n_alternatives = oballocvec (int, insn_code_number);
|
for (id = defs; id; id = id->next)
|
for (id = defs; id; id = id->next)
|
if (id->insn_code >= 0)
|
if (id->insn_code >= 0)
|
insn_n_alternatives[id->insn_code] = id->num_alternatives;
|
insn_n_alternatives[id->insn_code] = id->num_alternatives;
|
|
|
/* Construct extra attributes for automata. */
|
/* Construct extra attributes for automata. */
|
make_automaton_attrs ();
|
make_automaton_attrs ();
|
|
|
/* Prepare to write out attribute subroutines by checking everything stored
|
/* Prepare to write out attribute subroutines by checking everything stored
|
away and building the attribute cases. */
|
away and building the attribute cases. */
|
|
|
check_defs ();
|
check_defs ();
|
|
|
for (i = 0; i < MAX_ATTRS_INDEX; i++)
|
for (i = 0; i < MAX_ATTRS_INDEX; i++)
|
for (attr = attrs[i]; attr; attr = attr->next)
|
for (attr = attrs[i]; attr; attr = attr->next)
|
attr->default_val->value
|
attr->default_val->value
|
= check_attr_value (attr->default_val->value, attr);
|
= check_attr_value (attr->default_val->value, attr);
|
|
|
if (have_error)
|
if (have_error)
|
return FATAL_EXIT_CODE;
|
return FATAL_EXIT_CODE;
|
|
|
for (i = 0; i < MAX_ATTRS_INDEX; i++)
|
for (i = 0; i < MAX_ATTRS_INDEX; i++)
|
for (attr = attrs[i]; attr; attr = attr->next)
|
for (attr = attrs[i]; attr; attr = attr->next)
|
fill_attr (attr);
|
fill_attr (attr);
|
|
|
/* Construct extra attributes for `length'. */
|
/* Construct extra attributes for `length'. */
|
make_length_attrs ();
|
make_length_attrs ();
|
|
|
/* Perform any possible optimizations to speed up compilation. */
|
/* Perform any possible optimizations to speed up compilation. */
|
optimize_attrs ();
|
optimize_attrs ();
|
|
|
/* Now write out all the `gen_attr_...' routines. Do these before the
|
/* Now write out all the `gen_attr_...' routines. Do these before the
|
special routines so that they get defined before they are used. */
|
special routines so that they get defined before they are used. */
|
|
|
for (i = 0; i < MAX_ATTRS_INDEX; i++)
|
for (i = 0; i < MAX_ATTRS_INDEX; i++)
|
for (attr = attrs[i]; attr; attr = attr->next)
|
for (attr = attrs[i]; attr; attr = attr->next)
|
{
|
{
|
if (! attr->is_special && ! attr->is_const)
|
if (! attr->is_special && ! attr->is_const)
|
write_attr_get (attr);
|
write_attr_get (attr);
|
}
|
}
|
|
|
/* Write out delay eligibility information, if DEFINE_DELAY present.
|
/* Write out delay eligibility information, if DEFINE_DELAY present.
|
(The function to compute the number of delay slots will be written
|
(The function to compute the number of delay slots will be written
|
below.) */
|
below.) */
|
if (num_delays)
|
if (num_delays)
|
{
|
{
|
write_eligible_delay ("delay");
|
write_eligible_delay ("delay");
|
if (have_annul_true)
|
if (have_annul_true)
|
write_eligible_delay ("annul_true");
|
write_eligible_delay ("annul_true");
|
if (have_annul_false)
|
if (have_annul_false)
|
write_eligible_delay ("annul_false");
|
write_eligible_delay ("annul_false");
|
}
|
}
|
|
|
/* Write out constant delay slot info. */
|
/* Write out constant delay slot info. */
|
write_const_num_delay_slots ();
|
write_const_num_delay_slots ();
|
|
|
write_length_unit_log ();
|
write_length_unit_log ();
|
|
|
fflush (stdout);
|
fflush (stdout);
|
return (ferror (stdout) != 0 ? FATAL_EXIT_CODE : SUCCESS_EXIT_CODE);
|
return (ferror (stdout) != 0 ? FATAL_EXIT_CODE : SUCCESS_EXIT_CODE);
|
}
|
}
|
|
|
