1*e4b17023SJohn Marino /* Generate code from machine description to compute values of attributes.
2*e4b17023SJohn Marino Copyright (C) 1991, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3*e4b17023SJohn Marino 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
4*e4b17023SJohn Marino Free Software Foundation, Inc.
5*e4b17023SJohn Marino Contributed by Richard Kenner (kenner@vlsi1.ultra.nyu.edu)
6*e4b17023SJohn Marino
7*e4b17023SJohn Marino This file is part of GCC.
8*e4b17023SJohn Marino
9*e4b17023SJohn Marino GCC is free software; you can redistribute it and/or modify it under
10*e4b17023SJohn Marino the terms of the GNU General Public License as published by the Free
11*e4b17023SJohn Marino Software Foundation; either version 3, or (at your option) any later
12*e4b17023SJohn Marino version.
13*e4b17023SJohn Marino
14*e4b17023SJohn Marino GCC is distributed in the hope that it will be useful, but WITHOUT ANY
15*e4b17023SJohn Marino WARRANTY; without even the implied warranty of MERCHANTABILITY or
16*e4b17023SJohn Marino FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17*e4b17023SJohn Marino for more details.
18*e4b17023SJohn Marino
19*e4b17023SJohn Marino You should have received a copy of the GNU General Public License
20*e4b17023SJohn Marino along with GCC; see the file COPYING3. If not see
21*e4b17023SJohn Marino <http://www.gnu.org/licenses/>. */
22*e4b17023SJohn Marino
23*e4b17023SJohn Marino /* This program handles insn attributes and the DEFINE_DELAY and
24*e4b17023SJohn Marino DEFINE_INSN_RESERVATION definitions.
25*e4b17023SJohn Marino
26*e4b17023SJohn Marino It produces a series of functions named `get_attr_...', one for each insn
27*e4b17023SJohn Marino attribute. Each of these is given the rtx for an insn and returns a member
28*e4b17023SJohn Marino of the enum for the attribute.
29*e4b17023SJohn Marino
30*e4b17023SJohn Marino These subroutines have the form of a `switch' on the INSN_CODE (via
31*e4b17023SJohn Marino `recog_memoized'). Each case either returns a constant attribute value
32*e4b17023SJohn Marino or a value that depends on tests on other attributes, the form of
33*e4b17023SJohn Marino operands, or some random C expression (encoded with a SYMBOL_REF
34*e4b17023SJohn Marino expression).
35*e4b17023SJohn Marino
36*e4b17023SJohn Marino If the attribute `alternative', or a random C expression is present,
37*e4b17023SJohn Marino `constrain_operands' is called. If either of these cases of a reference to
38*e4b17023SJohn Marino an operand is found, `extract_insn' is called.
39*e4b17023SJohn Marino
40*e4b17023SJohn Marino The special attribute `length' is also recognized. For this operand,
41*e4b17023SJohn Marino expressions involving the address of an operand or the current insn,
42*e4b17023SJohn Marino (address (pc)), are valid. In this case, an initial pass is made to
43*e4b17023SJohn Marino set all lengths that do not depend on address. Those that do are set to
44*e4b17023SJohn Marino the maximum length. Then each insn that depends on an address is checked
45*e4b17023SJohn Marino and possibly has its length changed. The process repeats until no further
46*e4b17023SJohn Marino changed are made. The resulting lengths are saved for use by
47*e4b17023SJohn Marino `get_attr_length'.
48*e4b17023SJohn Marino
49*e4b17023SJohn Marino A special form of DEFINE_ATTR, where the expression for default value is a
50*e4b17023SJohn Marino CONST expression, indicates an attribute that is constant for a given run
51*e4b17023SJohn Marino of the compiler. The subroutine generated for these attributes has no
52*e4b17023SJohn Marino parameters as it does not depend on any particular insn. Constant
53*e4b17023SJohn Marino attributes are typically used to specify which variety of processor is
54*e4b17023SJohn Marino used.
55*e4b17023SJohn Marino
56*e4b17023SJohn Marino Internal attributes are defined to handle DEFINE_DELAY and
57*e4b17023SJohn Marino DEFINE_INSN_RESERVATION. Special routines are output for these cases.
58*e4b17023SJohn Marino
59*e4b17023SJohn Marino This program works by keeping a list of possible values for each attribute.
60*e4b17023SJohn Marino These include the basic attribute choices, default values for attribute, and
61*e4b17023SJohn Marino all derived quantities.
62*e4b17023SJohn Marino
63*e4b17023SJohn Marino As the description file is read, the definition for each insn is saved in a
64*e4b17023SJohn Marino `struct insn_def'. When the file reading is complete, a `struct insn_ent'
65*e4b17023SJohn Marino is created for each insn and chained to the corresponding attribute value,
66*e4b17023SJohn Marino either that specified, or the default.
67*e4b17023SJohn Marino
68*e4b17023SJohn Marino An optimization phase is then run. This simplifies expressions for each
69*e4b17023SJohn Marino insn. EQ_ATTR tests are resolved, whenever possible, to a test that
70*e4b17023SJohn Marino indicates when the attribute has the specified value for the insn. This
71*e4b17023SJohn Marino avoids recursive calls during compilation.
72*e4b17023SJohn Marino
73*e4b17023SJohn Marino The strategy used when processing DEFINE_DELAY definitions is to create
74*e4b17023SJohn Marino arbitrarily complex expressions and have the optimization simplify them.
75*e4b17023SJohn Marino
76*e4b17023SJohn Marino Once optimization is complete, any required routines and definitions
77*e4b17023SJohn Marino will be written.
78*e4b17023SJohn Marino
79*e4b17023SJohn Marino An optimization that is not yet implemented is to hoist the constant
80*e4b17023SJohn Marino expressions entirely out of the routines and definitions that are written.
81*e4b17023SJohn Marino A way to do this is to iterate over all possible combinations of values
82*e4b17023SJohn Marino for constant attributes and generate a set of functions for that given
83*e4b17023SJohn Marino combination. An initialization function would be written that evaluates
84*e4b17023SJohn Marino the attributes and installs the corresponding set of routines and
85*e4b17023SJohn Marino definitions (each would be accessed through a pointer).
86*e4b17023SJohn Marino
87*e4b17023SJohn Marino We use the flags in an RTX as follows:
88*e4b17023SJohn Marino `unchanging' (ATTR_IND_SIMPLIFIED_P): This rtx is fully simplified
89*e4b17023SJohn Marino independent of the insn code.
90*e4b17023SJohn Marino `in_struct' (ATTR_CURR_SIMPLIFIED_P): This rtx is fully simplified
91*e4b17023SJohn Marino for the insn code currently being processed (see optimize_attrs).
92*e4b17023SJohn Marino `return_val' (ATTR_PERMANENT_P): This rtx is permanent and unique
93*e4b17023SJohn Marino (see attr_rtx). */
94*e4b17023SJohn Marino
95*e4b17023SJohn Marino #define ATTR_IND_SIMPLIFIED_P(RTX) (RTX_FLAG((RTX), unchanging))
96*e4b17023SJohn Marino #define ATTR_CURR_SIMPLIFIED_P(RTX) (RTX_FLAG((RTX), in_struct))
97*e4b17023SJohn Marino #define ATTR_PERMANENT_P(RTX) (RTX_FLAG((RTX), return_val))
98*e4b17023SJohn Marino
99*e4b17023SJohn Marino #if 0
100*e4b17023SJohn Marino #define strcmp_check(S1, S2) ((S1) == (S2) \
101*e4b17023SJohn Marino ? 0 \
102*e4b17023SJohn Marino : (gcc_assert (strcmp ((S1), (S2))), 1))
103*e4b17023SJohn Marino #else
104*e4b17023SJohn Marino #define strcmp_check(S1, S2) ((S1) != (S2))
105*e4b17023SJohn Marino #endif
106*e4b17023SJohn Marino
107*e4b17023SJohn Marino #include "bconfig.h"
108*e4b17023SJohn Marino #include "system.h"
109*e4b17023SJohn Marino #include "coretypes.h"
110*e4b17023SJohn Marino #include "tm.h"
111*e4b17023SJohn Marino #include "rtl.h"
112*e4b17023SJohn Marino #include "obstack.h"
113*e4b17023SJohn Marino #include "errors.h"
114*e4b17023SJohn Marino #include "read-md.h"
115*e4b17023SJohn Marino #include "gensupport.h"
116*e4b17023SJohn Marino #include "vecprim.h"
117*e4b17023SJohn Marino #include "fnmatch.h"
118*e4b17023SJohn Marino
119*e4b17023SJohn Marino /* Flags for make_internal_attr's `special' parameter. */
120*e4b17023SJohn Marino #define ATTR_NONE 0
121*e4b17023SJohn Marino #define ATTR_SPECIAL (1 << 0)
122*e4b17023SJohn Marino
123*e4b17023SJohn Marino static struct obstack obstack1, obstack2;
124*e4b17023SJohn Marino static struct obstack *hash_obstack = &obstack1;
125*e4b17023SJohn Marino static struct obstack *temp_obstack = &obstack2;
126*e4b17023SJohn Marino
127*e4b17023SJohn Marino /* enough space to reserve for printing out ints */
128*e4b17023SJohn Marino #define MAX_DIGITS (HOST_BITS_PER_INT * 3 / 10 + 3)
129*e4b17023SJohn Marino
130*e4b17023SJohn Marino /* Define structures used to record attributes and values. */
131*e4b17023SJohn Marino
132*e4b17023SJohn Marino /* As each DEFINE_INSN, DEFINE_PEEPHOLE, or DEFINE_ASM_ATTRIBUTES is
133*e4b17023SJohn Marino encountered, we store all the relevant information into a
134*e4b17023SJohn Marino `struct insn_def'. This is done to allow attribute definitions to occur
135*e4b17023SJohn Marino anywhere in the file. */
136*e4b17023SJohn Marino
137*e4b17023SJohn Marino struct insn_def
138*e4b17023SJohn Marino {
139*e4b17023SJohn Marino struct insn_def *next; /* Next insn in chain. */
140*e4b17023SJohn Marino rtx def; /* The DEFINE_... */
141*e4b17023SJohn Marino int insn_code; /* Instruction number. */
142*e4b17023SJohn Marino int insn_index; /* Expression number in file, for errors. */
143*e4b17023SJohn Marino int lineno; /* Line number. */
144*e4b17023SJohn Marino int num_alternatives; /* Number of alternatives. */
145*e4b17023SJohn Marino int vec_idx; /* Index of attribute vector in `def'. */
146*e4b17023SJohn Marino };
147*e4b17023SJohn Marino
148*e4b17023SJohn Marino /* Once everything has been read in, we store in each attribute value a list
149*e4b17023SJohn Marino of insn codes that have that value. Here is the structure used for the
150*e4b17023SJohn Marino list. */
151*e4b17023SJohn Marino
152*e4b17023SJohn Marino struct insn_ent
153*e4b17023SJohn Marino {
154*e4b17023SJohn Marino struct insn_ent *next; /* Next in chain. */
155*e4b17023SJohn Marino struct insn_def *def; /* Instruction definition. */
156*e4b17023SJohn Marino };
157*e4b17023SJohn Marino
158*e4b17023SJohn Marino /* Each value of an attribute (either constant or computed) is assigned a
159*e4b17023SJohn Marino structure which is used as the listhead of the insns that have that
160*e4b17023SJohn Marino value. */
161*e4b17023SJohn Marino
162*e4b17023SJohn Marino struct attr_value
163*e4b17023SJohn Marino {
164*e4b17023SJohn Marino rtx value; /* Value of attribute. */
165*e4b17023SJohn Marino struct attr_value *next; /* Next attribute value in chain. */
166*e4b17023SJohn Marino struct insn_ent *first_insn; /* First insn with this value. */
167*e4b17023SJohn Marino int num_insns; /* Number of insns with this value. */
168*e4b17023SJohn Marino int has_asm_insn; /* True if this value used for `asm' insns */
169*e4b17023SJohn Marino };
170*e4b17023SJohn Marino
171*e4b17023SJohn Marino /* Structure for each attribute. */
172*e4b17023SJohn Marino
173*e4b17023SJohn Marino struct attr_desc
174*e4b17023SJohn Marino {
175*e4b17023SJohn Marino char *name; /* Name of attribute. */
176*e4b17023SJohn Marino const char *enum_name; /* Enum name for DEFINE_ENUM_NAME. */
177*e4b17023SJohn Marino struct attr_desc *next; /* Next attribute. */
178*e4b17023SJohn Marino struct attr_value *first_value; /* First value of this attribute. */
179*e4b17023SJohn Marino struct attr_value *default_val; /* Default value for this attribute. */
180*e4b17023SJohn Marino int lineno : 24; /* Line number. */
181*e4b17023SJohn Marino unsigned is_numeric : 1; /* Values of this attribute are numeric. */
182*e4b17023SJohn Marino unsigned is_const : 1; /* Attribute value constant for each run. */
183*e4b17023SJohn Marino unsigned is_special : 1; /* Don't call `write_attr_set'. */
184*e4b17023SJohn Marino };
185*e4b17023SJohn Marino
186*e4b17023SJohn Marino /* Structure for each DEFINE_DELAY. */
187*e4b17023SJohn Marino
188*e4b17023SJohn Marino struct delay_desc
189*e4b17023SJohn Marino {
190*e4b17023SJohn Marino rtx def; /* DEFINE_DELAY expression. */
191*e4b17023SJohn Marino struct delay_desc *next; /* Next DEFINE_DELAY. */
192*e4b17023SJohn Marino int num; /* Number of DEFINE_DELAY, starting at 1. */
193*e4b17023SJohn Marino int lineno; /* Line number. */
194*e4b17023SJohn Marino };
195*e4b17023SJohn Marino
196*e4b17023SJohn Marino struct attr_value_list
197*e4b17023SJohn Marino {
198*e4b17023SJohn Marino struct attr_value *av;
199*e4b17023SJohn Marino struct insn_ent *ie;
200*e4b17023SJohn Marino struct attr_desc *attr;
201*e4b17023SJohn Marino struct attr_value_list *next;
202*e4b17023SJohn Marino };
203*e4b17023SJohn Marino
204*e4b17023SJohn Marino /* Listheads of above structures. */
205*e4b17023SJohn Marino
206*e4b17023SJohn Marino /* This one is indexed by the first character of the attribute name. */
207*e4b17023SJohn Marino #define MAX_ATTRS_INDEX 256
208*e4b17023SJohn Marino static struct attr_desc *attrs[MAX_ATTRS_INDEX];
209*e4b17023SJohn Marino static struct insn_def *defs;
210*e4b17023SJohn Marino static struct delay_desc *delays;
211*e4b17023SJohn Marino struct attr_value_list **insn_code_values;
212*e4b17023SJohn Marino
213*e4b17023SJohn Marino /* Other variables. */
214*e4b17023SJohn Marino
215*e4b17023SJohn Marino static int insn_code_number;
216*e4b17023SJohn Marino static int insn_index_number;
217*e4b17023SJohn Marino static int got_define_asm_attributes;
218*e4b17023SJohn Marino static int must_extract;
219*e4b17023SJohn Marino static int must_constrain;
220*e4b17023SJohn Marino static int address_used;
221*e4b17023SJohn Marino static int length_used;
222*e4b17023SJohn Marino static int num_delays;
223*e4b17023SJohn Marino static int have_annul_true, have_annul_false;
224*e4b17023SJohn Marino static int num_insn_ents;
225*e4b17023SJohn Marino
226*e4b17023SJohn Marino /* Stores, for each insn code, the number of constraint alternatives. */
227*e4b17023SJohn Marino
228*e4b17023SJohn Marino static int *insn_n_alternatives;
229*e4b17023SJohn Marino
230*e4b17023SJohn Marino /* Stores, for each insn code, a bitmap that has bits on for each possible
231*e4b17023SJohn Marino alternative. */
232*e4b17023SJohn Marino
233*e4b17023SJohn Marino static int *insn_alternatives;
234*e4b17023SJohn Marino
235*e4b17023SJohn Marino /* Used to simplify expressions. */
236*e4b17023SJohn Marino
237*e4b17023SJohn Marino static rtx true_rtx, false_rtx;
238*e4b17023SJohn Marino
239*e4b17023SJohn Marino /* Used to reduce calls to `strcmp' */
240*e4b17023SJohn Marino
241*e4b17023SJohn Marino static const char *alternative_name;
242*e4b17023SJohn Marino static const char *length_str;
243*e4b17023SJohn Marino static const char *delay_type_str;
244*e4b17023SJohn Marino static const char *delay_1_0_str;
245*e4b17023SJohn Marino static const char *num_delay_slots_str;
246*e4b17023SJohn Marino
247*e4b17023SJohn Marino /* Simplify an expression. Only call the routine if there is something to
248*e4b17023SJohn Marino simplify. */
249*e4b17023SJohn Marino #define SIMPLIFY_TEST_EXP(EXP,INSN_CODE,INSN_INDEX) \
250*e4b17023SJohn Marino (ATTR_IND_SIMPLIFIED_P (EXP) || ATTR_CURR_SIMPLIFIED_P (EXP) ? (EXP) \
251*e4b17023SJohn Marino : simplify_test_exp (EXP, INSN_CODE, INSN_INDEX))
252*e4b17023SJohn Marino
253*e4b17023SJohn Marino #define DEF_ATTR_STRING(S) (attr_string ((S), strlen (S)))
254*e4b17023SJohn Marino
255*e4b17023SJohn Marino /* Forward declarations of functions used before their definitions, only. */
256*e4b17023SJohn Marino static char *attr_string (const char *, int);
257*e4b17023SJohn Marino static char *attr_printf (unsigned int, const char *, ...)
258*e4b17023SJohn Marino ATTRIBUTE_PRINTF_2;
259*e4b17023SJohn Marino static rtx make_numeric_value (int);
260*e4b17023SJohn Marino static struct attr_desc *find_attr (const char **, int);
261*e4b17023SJohn Marino static rtx mk_attr_alt (int);
262*e4b17023SJohn Marino static char *next_comma_elt (const char **);
263*e4b17023SJohn Marino static rtx insert_right_side (enum rtx_code, rtx, rtx, int, int);
264*e4b17023SJohn Marino static rtx copy_boolean (rtx);
265*e4b17023SJohn Marino static int compares_alternatives_p (rtx);
266*e4b17023SJohn Marino static void make_internal_attr (const char *, rtx, int);
267*e4b17023SJohn Marino static void insert_insn_ent (struct attr_value *, struct insn_ent *);
268*e4b17023SJohn Marino static void walk_attr_value (rtx);
269*e4b17023SJohn Marino static int max_attr_value (rtx, int*);
270*e4b17023SJohn Marino static int min_attr_value (rtx, int*);
271*e4b17023SJohn Marino static int or_attr_value (rtx, int*);
272*e4b17023SJohn Marino static rtx simplify_test_exp (rtx, int, int);
273*e4b17023SJohn Marino static rtx simplify_test_exp_in_temp (rtx, int, int);
274*e4b17023SJohn Marino static rtx copy_rtx_unchanging (rtx);
275*e4b17023SJohn Marino static bool attr_alt_subset_p (rtx, rtx);
276*e4b17023SJohn Marino static bool attr_alt_subset_of_compl_p (rtx, rtx);
277*e4b17023SJohn Marino static void clear_struct_flag (rtx);
278*e4b17023SJohn Marino static void write_attr_valueq (struct attr_desc *, const char *);
279*e4b17023SJohn Marino static struct attr_value *find_most_used (struct attr_desc *);
280*e4b17023SJohn Marino static void write_attr_set (struct attr_desc *, int, rtx,
281*e4b17023SJohn Marino const char *, const char *, rtx,
282*e4b17023SJohn Marino int, int, unsigned int);
283*e4b17023SJohn Marino static void write_attr_case (struct attr_desc *, struct attr_value *,
284*e4b17023SJohn Marino int, const char *, const char *, int, rtx);
285*e4b17023SJohn Marino static void write_attr_value (struct attr_desc *, rtx);
286*e4b17023SJohn Marino static void write_upcase (const char *);
287*e4b17023SJohn Marino static void write_indent (int);
288*e4b17023SJohn Marino static rtx identity_fn (rtx);
289*e4b17023SJohn Marino static rtx zero_fn (rtx);
290*e4b17023SJohn Marino static rtx one_fn (rtx);
291*e4b17023SJohn Marino static rtx max_fn (rtx);
292*e4b17023SJohn Marino static rtx min_fn (rtx);
293*e4b17023SJohn Marino
294*e4b17023SJohn Marino #define oballoc(T) XOBNEW (hash_obstack, T)
295*e4b17023SJohn Marino #define oballocvec(T, N) XOBNEWVEC (hash_obstack, T, (N))
296*e4b17023SJohn Marino
297*e4b17023SJohn Marino /* Hash table for sharing RTL and strings. */
298*e4b17023SJohn Marino
299*e4b17023SJohn Marino /* Each hash table slot is a bucket containing a chain of these structures.
300*e4b17023SJohn Marino Strings are given negative hash codes; RTL expressions are given positive
301*e4b17023SJohn Marino hash codes. */
302*e4b17023SJohn Marino
303*e4b17023SJohn Marino struct attr_hash
304*e4b17023SJohn Marino {
305*e4b17023SJohn Marino struct attr_hash *next; /* Next structure in the bucket. */
306*e4b17023SJohn Marino int hashcode; /* Hash code of this rtx or string. */
307*e4b17023SJohn Marino union
308*e4b17023SJohn Marino {
309*e4b17023SJohn Marino char *str; /* The string (negative hash codes) */
310*e4b17023SJohn Marino rtx rtl; /* or the RTL recorded here. */
311*e4b17023SJohn Marino } u;
312*e4b17023SJohn Marino };
313*e4b17023SJohn Marino
314*e4b17023SJohn Marino /* Now here is the hash table. When recording an RTL, it is added to
315*e4b17023SJohn Marino the slot whose index is the hash code mod the table size. Note
316*e4b17023SJohn Marino that the hash table is used for several kinds of RTL (see attr_rtx)
317*e4b17023SJohn Marino and for strings. While all these live in the same table, they are
318*e4b17023SJohn Marino completely independent, and the hash code is computed differently
319*e4b17023SJohn Marino for each. */
320*e4b17023SJohn Marino
321*e4b17023SJohn Marino #define RTL_HASH_SIZE 4093
322*e4b17023SJohn Marino static struct attr_hash *attr_hash_table[RTL_HASH_SIZE];
323*e4b17023SJohn Marino
324*e4b17023SJohn Marino /* Here is how primitive or already-shared RTL's hash
325*e4b17023SJohn Marino codes are made. */
326*e4b17023SJohn Marino #define RTL_HASH(RTL) ((intptr_t) (RTL) & 0777777)
327*e4b17023SJohn Marino
328*e4b17023SJohn Marino /* Add an entry to the hash table for RTL with hash code HASHCODE. */
329*e4b17023SJohn Marino
330*e4b17023SJohn Marino static void
attr_hash_add_rtx(int hashcode,rtx rtl)331*e4b17023SJohn Marino attr_hash_add_rtx (int hashcode, rtx rtl)
332*e4b17023SJohn Marino {
333*e4b17023SJohn Marino struct attr_hash *h;
334*e4b17023SJohn Marino
335*e4b17023SJohn Marino h = XOBNEW (hash_obstack, struct attr_hash);
336*e4b17023SJohn Marino h->hashcode = hashcode;
337*e4b17023SJohn Marino h->u.rtl = rtl;
338*e4b17023SJohn Marino h->next = attr_hash_table[hashcode % RTL_HASH_SIZE];
339*e4b17023SJohn Marino attr_hash_table[hashcode % RTL_HASH_SIZE] = h;
340*e4b17023SJohn Marino }
341*e4b17023SJohn Marino
342*e4b17023SJohn Marino /* Add an entry to the hash table for STRING with hash code HASHCODE. */
343*e4b17023SJohn Marino
344*e4b17023SJohn Marino static void
attr_hash_add_string(int hashcode,char * str)345*e4b17023SJohn Marino attr_hash_add_string (int hashcode, char *str)
346*e4b17023SJohn Marino {
347*e4b17023SJohn Marino struct attr_hash *h;
348*e4b17023SJohn Marino
349*e4b17023SJohn Marino h = XOBNEW (hash_obstack, struct attr_hash);
350*e4b17023SJohn Marino h->hashcode = -hashcode;
351*e4b17023SJohn Marino h->u.str = str;
352*e4b17023SJohn Marino h->next = attr_hash_table[hashcode % RTL_HASH_SIZE];
353*e4b17023SJohn Marino attr_hash_table[hashcode % RTL_HASH_SIZE] = h;
354*e4b17023SJohn Marino }
355*e4b17023SJohn Marino
356*e4b17023SJohn Marino /* Generate an RTL expression, but avoid duplicates.
357*e4b17023SJohn Marino Set the ATTR_PERMANENT_P flag for these permanent objects.
358*e4b17023SJohn Marino
359*e4b17023SJohn Marino In some cases we cannot uniquify; then we return an ordinary
360*e4b17023SJohn Marino impermanent rtx with ATTR_PERMANENT_P clear.
361*e4b17023SJohn Marino
362*e4b17023SJohn Marino Args are as follows:
363*e4b17023SJohn Marino
364*e4b17023SJohn Marino rtx attr_rtx (code, [element1, ..., elementn]) */
365*e4b17023SJohn Marino
366*e4b17023SJohn Marino static rtx
attr_rtx_1(enum rtx_code code,va_list p)367*e4b17023SJohn Marino attr_rtx_1 (enum rtx_code code, va_list p)
368*e4b17023SJohn Marino {
369*e4b17023SJohn Marino rtx rt_val = NULL_RTX;/* RTX to return to caller... */
370*e4b17023SJohn Marino int hashcode;
371*e4b17023SJohn Marino struct attr_hash *h;
372*e4b17023SJohn Marino struct obstack *old_obstack = rtl_obstack;
373*e4b17023SJohn Marino
374*e4b17023SJohn Marino /* For each of several cases, search the hash table for an existing entry.
375*e4b17023SJohn Marino Use that entry if one is found; otherwise create a new RTL and add it
376*e4b17023SJohn Marino to the table. */
377*e4b17023SJohn Marino
378*e4b17023SJohn Marino if (GET_RTX_CLASS (code) == RTX_UNARY)
379*e4b17023SJohn Marino {
380*e4b17023SJohn Marino rtx arg0 = va_arg (p, rtx);
381*e4b17023SJohn Marino
382*e4b17023SJohn Marino /* A permanent object cannot point to impermanent ones. */
383*e4b17023SJohn Marino if (! ATTR_PERMANENT_P (arg0))
384*e4b17023SJohn Marino {
385*e4b17023SJohn Marino rt_val = rtx_alloc (code);
386*e4b17023SJohn Marino XEXP (rt_val, 0) = arg0;
387*e4b17023SJohn Marino return rt_val;
388*e4b17023SJohn Marino }
389*e4b17023SJohn Marino
390*e4b17023SJohn Marino hashcode = ((HOST_WIDE_INT) code + RTL_HASH (arg0));
391*e4b17023SJohn Marino for (h = attr_hash_table[hashcode % RTL_HASH_SIZE]; h; h = h->next)
392*e4b17023SJohn Marino if (h->hashcode == hashcode
393*e4b17023SJohn Marino && GET_CODE (h->u.rtl) == code
394*e4b17023SJohn Marino && XEXP (h->u.rtl, 0) == arg0)
395*e4b17023SJohn Marino return h->u.rtl;
396*e4b17023SJohn Marino
397*e4b17023SJohn Marino if (h == 0)
398*e4b17023SJohn Marino {
399*e4b17023SJohn Marino rtl_obstack = hash_obstack;
400*e4b17023SJohn Marino rt_val = rtx_alloc (code);
401*e4b17023SJohn Marino XEXP (rt_val, 0) = arg0;
402*e4b17023SJohn Marino }
403*e4b17023SJohn Marino }
404*e4b17023SJohn Marino else if (GET_RTX_CLASS (code) == RTX_BIN_ARITH
405*e4b17023SJohn Marino || GET_RTX_CLASS (code) == RTX_COMM_ARITH
406*e4b17023SJohn Marino || GET_RTX_CLASS (code) == RTX_COMPARE
407*e4b17023SJohn Marino || GET_RTX_CLASS (code) == RTX_COMM_COMPARE)
408*e4b17023SJohn Marino {
409*e4b17023SJohn Marino rtx arg0 = va_arg (p, rtx);
410*e4b17023SJohn Marino rtx arg1 = va_arg (p, rtx);
411*e4b17023SJohn Marino
412*e4b17023SJohn Marino /* A permanent object cannot point to impermanent ones. */
413*e4b17023SJohn Marino if (! ATTR_PERMANENT_P (arg0) || ! ATTR_PERMANENT_P (arg1))
414*e4b17023SJohn Marino {
415*e4b17023SJohn Marino rt_val = rtx_alloc (code);
416*e4b17023SJohn Marino XEXP (rt_val, 0) = arg0;
417*e4b17023SJohn Marino XEXP (rt_val, 1) = arg1;
418*e4b17023SJohn Marino return rt_val;
419*e4b17023SJohn Marino }
420*e4b17023SJohn Marino
421*e4b17023SJohn Marino hashcode = ((HOST_WIDE_INT) code + RTL_HASH (arg0) + RTL_HASH (arg1));
422*e4b17023SJohn Marino for (h = attr_hash_table[hashcode % RTL_HASH_SIZE]; h; h = h->next)
423*e4b17023SJohn Marino if (h->hashcode == hashcode
424*e4b17023SJohn Marino && GET_CODE (h->u.rtl) == code
425*e4b17023SJohn Marino && XEXP (h->u.rtl, 0) == arg0
426*e4b17023SJohn Marino && XEXP (h->u.rtl, 1) == arg1)
427*e4b17023SJohn Marino return h->u.rtl;
428*e4b17023SJohn Marino
429*e4b17023SJohn Marino if (h == 0)
430*e4b17023SJohn Marino {
431*e4b17023SJohn Marino rtl_obstack = hash_obstack;
432*e4b17023SJohn Marino rt_val = rtx_alloc (code);
433*e4b17023SJohn Marino XEXP (rt_val, 0) = arg0;
434*e4b17023SJohn Marino XEXP (rt_val, 1) = arg1;
435*e4b17023SJohn Marino }
436*e4b17023SJohn Marino }
437*e4b17023SJohn Marino else if (code == SYMBOL_REF
438*e4b17023SJohn Marino || (GET_RTX_LENGTH (code) == 1
439*e4b17023SJohn Marino && GET_RTX_FORMAT (code)[0] == 's'))
440*e4b17023SJohn Marino {
441*e4b17023SJohn Marino char *arg0 = va_arg (p, char *);
442*e4b17023SJohn Marino
443*e4b17023SJohn Marino arg0 = DEF_ATTR_STRING (arg0);
444*e4b17023SJohn Marino
445*e4b17023SJohn Marino hashcode = ((HOST_WIDE_INT) code + RTL_HASH (arg0));
446*e4b17023SJohn Marino for (h = attr_hash_table[hashcode % RTL_HASH_SIZE]; h; h = h->next)
447*e4b17023SJohn Marino if (h->hashcode == hashcode
448*e4b17023SJohn Marino && GET_CODE (h->u.rtl) == code
449*e4b17023SJohn Marino && XSTR (h->u.rtl, 0) == arg0)
450*e4b17023SJohn Marino return h->u.rtl;
451*e4b17023SJohn Marino
452*e4b17023SJohn Marino if (h == 0)
453*e4b17023SJohn Marino {
454*e4b17023SJohn Marino rtl_obstack = hash_obstack;
455*e4b17023SJohn Marino rt_val = rtx_alloc (code);
456*e4b17023SJohn Marino XSTR (rt_val, 0) = arg0;
457*e4b17023SJohn Marino if (code == SYMBOL_REF)
458*e4b17023SJohn Marino {
459*e4b17023SJohn Marino X0EXP (rt_val, 1) = NULL_RTX;
460*e4b17023SJohn Marino X0EXP (rt_val, 2) = NULL_RTX;
461*e4b17023SJohn Marino }
462*e4b17023SJohn Marino }
463*e4b17023SJohn Marino }
464*e4b17023SJohn Marino else if (GET_RTX_LENGTH (code) == 2
465*e4b17023SJohn Marino && GET_RTX_FORMAT (code)[0] == 's'
466*e4b17023SJohn Marino && GET_RTX_FORMAT (code)[1] == 's')
467*e4b17023SJohn Marino {
468*e4b17023SJohn Marino char *arg0 = va_arg (p, char *);
469*e4b17023SJohn Marino char *arg1 = va_arg (p, char *);
470*e4b17023SJohn Marino
471*e4b17023SJohn Marino hashcode = ((HOST_WIDE_INT) code + RTL_HASH (arg0) + RTL_HASH (arg1));
472*e4b17023SJohn Marino for (h = attr_hash_table[hashcode % RTL_HASH_SIZE]; h; h = h->next)
473*e4b17023SJohn Marino if (h->hashcode == hashcode
474*e4b17023SJohn Marino && GET_CODE (h->u.rtl) == code
475*e4b17023SJohn Marino && XSTR (h->u.rtl, 0) == arg0
476*e4b17023SJohn Marino && XSTR (h->u.rtl, 1) == arg1)
477*e4b17023SJohn Marino return h->u.rtl;
478*e4b17023SJohn Marino
479*e4b17023SJohn Marino if (h == 0)
480*e4b17023SJohn Marino {
481*e4b17023SJohn Marino rtl_obstack = hash_obstack;
482*e4b17023SJohn Marino rt_val = rtx_alloc (code);
483*e4b17023SJohn Marino XSTR (rt_val, 0) = arg0;
484*e4b17023SJohn Marino XSTR (rt_val, 1) = arg1;
485*e4b17023SJohn Marino }
486*e4b17023SJohn Marino }
487*e4b17023SJohn Marino else if (code == CONST_INT)
488*e4b17023SJohn Marino {
489*e4b17023SJohn Marino HOST_WIDE_INT arg0 = va_arg (p, HOST_WIDE_INT);
490*e4b17023SJohn Marino if (arg0 == 0)
491*e4b17023SJohn Marino return false_rtx;
492*e4b17023SJohn Marino else if (arg0 == 1)
493*e4b17023SJohn Marino return true_rtx;
494*e4b17023SJohn Marino else
495*e4b17023SJohn Marino goto nohash;
496*e4b17023SJohn Marino }
497*e4b17023SJohn Marino else
498*e4b17023SJohn Marino {
499*e4b17023SJohn Marino int i; /* Array indices... */
500*e4b17023SJohn Marino const char *fmt; /* Current rtx's format... */
501*e4b17023SJohn Marino nohash:
502*e4b17023SJohn Marino rt_val = rtx_alloc (code); /* Allocate the storage space. */
503*e4b17023SJohn Marino
504*e4b17023SJohn Marino fmt = GET_RTX_FORMAT (code); /* Find the right format... */
505*e4b17023SJohn Marino for (i = 0; i < GET_RTX_LENGTH (code); i++)
506*e4b17023SJohn Marino {
507*e4b17023SJohn Marino switch (*fmt++)
508*e4b17023SJohn Marino {
509*e4b17023SJohn Marino case '0': /* Unused field. */
510*e4b17023SJohn Marino break;
511*e4b17023SJohn Marino
512*e4b17023SJohn Marino case 'i': /* An integer? */
513*e4b17023SJohn Marino XINT (rt_val, i) = va_arg (p, int);
514*e4b17023SJohn Marino break;
515*e4b17023SJohn Marino
516*e4b17023SJohn Marino case 'w': /* A wide integer? */
517*e4b17023SJohn Marino XWINT (rt_val, i) = va_arg (p, HOST_WIDE_INT);
518*e4b17023SJohn Marino break;
519*e4b17023SJohn Marino
520*e4b17023SJohn Marino case 's': /* A string? */
521*e4b17023SJohn Marino XSTR (rt_val, i) = va_arg (p, char *);
522*e4b17023SJohn Marino break;
523*e4b17023SJohn Marino
524*e4b17023SJohn Marino case 'e': /* An expression? */
525*e4b17023SJohn Marino case 'u': /* An insn? Same except when printing. */
526*e4b17023SJohn Marino XEXP (rt_val, i) = va_arg (p, rtx);
527*e4b17023SJohn Marino break;
528*e4b17023SJohn Marino
529*e4b17023SJohn Marino case 'E': /* An RTX vector? */
530*e4b17023SJohn Marino XVEC (rt_val, i) = va_arg (p, rtvec);
531*e4b17023SJohn Marino break;
532*e4b17023SJohn Marino
533*e4b17023SJohn Marino default:
534*e4b17023SJohn Marino gcc_unreachable ();
535*e4b17023SJohn Marino }
536*e4b17023SJohn Marino }
537*e4b17023SJohn Marino return rt_val;
538*e4b17023SJohn Marino }
539*e4b17023SJohn Marino
540*e4b17023SJohn Marino rtl_obstack = old_obstack;
541*e4b17023SJohn Marino attr_hash_add_rtx (hashcode, rt_val);
542*e4b17023SJohn Marino ATTR_PERMANENT_P (rt_val) = 1;
543*e4b17023SJohn Marino return rt_val;
544*e4b17023SJohn Marino }
545*e4b17023SJohn Marino
546*e4b17023SJohn Marino static rtx
attr_rtx(enum rtx_code code,...)547*e4b17023SJohn Marino attr_rtx (enum rtx_code code, ...)
548*e4b17023SJohn Marino {
549*e4b17023SJohn Marino rtx result;
550*e4b17023SJohn Marino va_list p;
551*e4b17023SJohn Marino
552*e4b17023SJohn Marino va_start (p, code);
553*e4b17023SJohn Marino result = attr_rtx_1 (code, p);
554*e4b17023SJohn Marino va_end (p);
555*e4b17023SJohn Marino return result;
556*e4b17023SJohn Marino }
557*e4b17023SJohn Marino
558*e4b17023SJohn Marino /* Create a new string printed with the printf line arguments into a space
559*e4b17023SJohn Marino of at most LEN bytes:
560*e4b17023SJohn Marino
561*e4b17023SJohn Marino rtx attr_printf (len, format, [arg1, ..., argn]) */
562*e4b17023SJohn Marino
563*e4b17023SJohn Marino static char *
attr_printf(unsigned int len,const char * fmt,...)564*e4b17023SJohn Marino attr_printf (unsigned int len, const char *fmt, ...)
565*e4b17023SJohn Marino {
566*e4b17023SJohn Marino char str[256];
567*e4b17023SJohn Marino va_list p;
568*e4b17023SJohn Marino
569*e4b17023SJohn Marino va_start (p, fmt);
570*e4b17023SJohn Marino
571*e4b17023SJohn Marino gcc_assert (len < sizeof str); /* Leave room for \0. */
572*e4b17023SJohn Marino
573*e4b17023SJohn Marino vsprintf (str, fmt, p);
574*e4b17023SJohn Marino va_end (p);
575*e4b17023SJohn Marino
576*e4b17023SJohn Marino return DEF_ATTR_STRING (str);
577*e4b17023SJohn Marino }
578*e4b17023SJohn Marino
579*e4b17023SJohn Marino static rtx
attr_eq(const char * name,const char * value)580*e4b17023SJohn Marino attr_eq (const char *name, const char *value)
581*e4b17023SJohn Marino {
582*e4b17023SJohn Marino return attr_rtx (EQ_ATTR, DEF_ATTR_STRING (name), DEF_ATTR_STRING (value));
583*e4b17023SJohn Marino }
584*e4b17023SJohn Marino
585*e4b17023SJohn Marino static const char *
attr_numeral(int n)586*e4b17023SJohn Marino attr_numeral (int n)
587*e4b17023SJohn Marino {
588*e4b17023SJohn Marino return XSTR (make_numeric_value (n), 0);
589*e4b17023SJohn Marino }
590*e4b17023SJohn Marino
591*e4b17023SJohn Marino /* Return a permanent (possibly shared) copy of a string STR (not assumed
592*e4b17023SJohn Marino to be null terminated) with LEN bytes. */
593*e4b17023SJohn Marino
594*e4b17023SJohn Marino static char *
attr_string(const char * str,int len)595*e4b17023SJohn Marino attr_string (const char *str, int len)
596*e4b17023SJohn Marino {
597*e4b17023SJohn Marino struct attr_hash *h;
598*e4b17023SJohn Marino int hashcode;
599*e4b17023SJohn Marino int i;
600*e4b17023SJohn Marino char *new_str;
601*e4b17023SJohn Marino
602*e4b17023SJohn Marino /* Compute the hash code. */
603*e4b17023SJohn Marino hashcode = (len + 1) * 613 + (unsigned) str[0];
604*e4b17023SJohn Marino for (i = 1; i < len; i += 2)
605*e4b17023SJohn Marino hashcode = ((hashcode * 613) + (unsigned) str[i]);
606*e4b17023SJohn Marino if (hashcode < 0)
607*e4b17023SJohn Marino hashcode = -hashcode;
608*e4b17023SJohn Marino
609*e4b17023SJohn Marino /* Search the table for the string. */
610*e4b17023SJohn Marino for (h = attr_hash_table[hashcode % RTL_HASH_SIZE]; h; h = h->next)
611*e4b17023SJohn Marino if (h->hashcode == -hashcode && h->u.str[0] == str[0]
612*e4b17023SJohn Marino && !strncmp (h->u.str, str, len))
613*e4b17023SJohn Marino return h->u.str; /* <-- return if found. */
614*e4b17023SJohn Marino
615*e4b17023SJohn Marino /* Not found; create a permanent copy and add it to the hash table. */
616*e4b17023SJohn Marino new_str = XOBNEWVAR (hash_obstack, char, len + 1);
617*e4b17023SJohn Marino memcpy (new_str, str, len);
618*e4b17023SJohn Marino new_str[len] = '\0';
619*e4b17023SJohn Marino attr_hash_add_string (hashcode, new_str);
620*e4b17023SJohn Marino copy_md_ptr_loc (new_str, str);
621*e4b17023SJohn Marino
622*e4b17023SJohn Marino return new_str; /* Return the new string. */
623*e4b17023SJohn Marino }
624*e4b17023SJohn Marino
625*e4b17023SJohn Marino /* Check two rtx's for equality of contents,
626*e4b17023SJohn Marino taking advantage of the fact that if both are hashed
627*e4b17023SJohn Marino then they can't be equal unless they are the same object. */
628*e4b17023SJohn Marino
629*e4b17023SJohn Marino static int
attr_equal_p(rtx x,rtx y)630*e4b17023SJohn Marino attr_equal_p (rtx x, rtx y)
631*e4b17023SJohn Marino {
632*e4b17023SJohn Marino return (x == y || (! (ATTR_PERMANENT_P (x) && ATTR_PERMANENT_P (y))
633*e4b17023SJohn Marino && rtx_equal_p (x, y)));
634*e4b17023SJohn Marino }
635*e4b17023SJohn Marino
636*e4b17023SJohn Marino /* Copy an attribute value expression,
637*e4b17023SJohn Marino descending to all depths, but not copying any
638*e4b17023SJohn Marino permanent hashed subexpressions. */
639*e4b17023SJohn Marino
640*e4b17023SJohn Marino static rtx
attr_copy_rtx(rtx orig)641*e4b17023SJohn Marino attr_copy_rtx (rtx orig)
642*e4b17023SJohn Marino {
643*e4b17023SJohn Marino rtx copy;
644*e4b17023SJohn Marino int i, j;
645*e4b17023SJohn Marino RTX_CODE code;
646*e4b17023SJohn Marino const char *format_ptr;
647*e4b17023SJohn Marino
648*e4b17023SJohn Marino /* No need to copy a permanent object. */
649*e4b17023SJohn Marino if (ATTR_PERMANENT_P (orig))
650*e4b17023SJohn Marino return orig;
651*e4b17023SJohn Marino
652*e4b17023SJohn Marino code = GET_CODE (orig);
653*e4b17023SJohn Marino
654*e4b17023SJohn Marino switch (code)
655*e4b17023SJohn Marino {
656*e4b17023SJohn Marino case REG:
657*e4b17023SJohn Marino case CONST_INT:
658*e4b17023SJohn Marino case CONST_DOUBLE:
659*e4b17023SJohn Marino case CONST_VECTOR:
660*e4b17023SJohn Marino case SYMBOL_REF:
661*e4b17023SJohn Marino case MATCH_TEST:
662*e4b17023SJohn Marino case CODE_LABEL:
663*e4b17023SJohn Marino case PC:
664*e4b17023SJohn Marino case CC0:
665*e4b17023SJohn Marino return orig;
666*e4b17023SJohn Marino
667*e4b17023SJohn Marino default:
668*e4b17023SJohn Marino break;
669*e4b17023SJohn Marino }
670*e4b17023SJohn Marino
671*e4b17023SJohn Marino copy = rtx_alloc (code);
672*e4b17023SJohn Marino PUT_MODE (copy, GET_MODE (orig));
673*e4b17023SJohn Marino ATTR_IND_SIMPLIFIED_P (copy) = ATTR_IND_SIMPLIFIED_P (orig);
674*e4b17023SJohn Marino ATTR_CURR_SIMPLIFIED_P (copy) = ATTR_CURR_SIMPLIFIED_P (orig);
675*e4b17023SJohn Marino ATTR_PERMANENT_P (copy) = ATTR_PERMANENT_P (orig);
676*e4b17023SJohn Marino
677*e4b17023SJohn Marino format_ptr = GET_RTX_FORMAT (GET_CODE (copy));
678*e4b17023SJohn Marino
679*e4b17023SJohn Marino for (i = 0; i < GET_RTX_LENGTH (GET_CODE (copy)); i++)
680*e4b17023SJohn Marino {
681*e4b17023SJohn Marino switch (*format_ptr++)
682*e4b17023SJohn Marino {
683*e4b17023SJohn Marino case 'e':
684*e4b17023SJohn Marino XEXP (copy, i) = XEXP (orig, i);
685*e4b17023SJohn Marino if (XEXP (orig, i) != NULL)
686*e4b17023SJohn Marino XEXP (copy, i) = attr_copy_rtx (XEXP (orig, i));
687*e4b17023SJohn Marino break;
688*e4b17023SJohn Marino
689*e4b17023SJohn Marino case 'E':
690*e4b17023SJohn Marino case 'V':
691*e4b17023SJohn Marino XVEC (copy, i) = XVEC (orig, i);
692*e4b17023SJohn Marino if (XVEC (orig, i) != NULL)
693*e4b17023SJohn Marino {
694*e4b17023SJohn Marino XVEC (copy, i) = rtvec_alloc (XVECLEN (orig, i));
695*e4b17023SJohn Marino for (j = 0; j < XVECLEN (copy, i); j++)
696*e4b17023SJohn Marino XVECEXP (copy, i, j) = attr_copy_rtx (XVECEXP (orig, i, j));
697*e4b17023SJohn Marino }
698*e4b17023SJohn Marino break;
699*e4b17023SJohn Marino
700*e4b17023SJohn Marino case 'n':
701*e4b17023SJohn Marino case 'i':
702*e4b17023SJohn Marino XINT (copy, i) = XINT (orig, i);
703*e4b17023SJohn Marino break;
704*e4b17023SJohn Marino
705*e4b17023SJohn Marino case 'w':
706*e4b17023SJohn Marino XWINT (copy, i) = XWINT (orig, i);
707*e4b17023SJohn Marino break;
708*e4b17023SJohn Marino
709*e4b17023SJohn Marino case 's':
710*e4b17023SJohn Marino case 'S':
711*e4b17023SJohn Marino XSTR (copy, i) = XSTR (orig, i);
712*e4b17023SJohn Marino break;
713*e4b17023SJohn Marino
714*e4b17023SJohn Marino default:
715*e4b17023SJohn Marino gcc_unreachable ();
716*e4b17023SJohn Marino }
717*e4b17023SJohn Marino }
718*e4b17023SJohn Marino return copy;
719*e4b17023SJohn Marino }
720*e4b17023SJohn Marino
721*e4b17023SJohn Marino /* Given a test expression for an attribute, ensure it is validly formed.
722*e4b17023SJohn Marino IS_CONST indicates whether the expression is constant for each compiler
723*e4b17023SJohn Marino run (a constant expression may not test any particular insn).
724*e4b17023SJohn Marino
725*e4b17023SJohn Marino Convert (eq_attr "att" "a1,a2") to (ior (eq_attr ... ) (eq_attrq ..))
726*e4b17023SJohn Marino and (eq_attr "att" "!a1") to (not (eq_attr "att" "a1")). Do the latter
727*e4b17023SJohn Marino test first so that (eq_attr "att" "!a1,a2,a3") works as expected.
728*e4b17023SJohn Marino
729*e4b17023SJohn Marino Update the string address in EQ_ATTR expression to be the same used
730*e4b17023SJohn Marino in the attribute (or `alternative_name') to speed up subsequent
731*e4b17023SJohn Marino `find_attr' calls and eliminate most `strcmp' calls.
732*e4b17023SJohn Marino
733*e4b17023SJohn Marino Return the new expression, if any. */
734*e4b17023SJohn Marino
735*e4b17023SJohn Marino static rtx
check_attr_test(rtx exp,int is_const,int lineno)736*e4b17023SJohn Marino check_attr_test (rtx exp, int is_const, int lineno)
737*e4b17023SJohn Marino {
738*e4b17023SJohn Marino struct attr_desc *attr;
739*e4b17023SJohn Marino struct attr_value *av;
740*e4b17023SJohn Marino const char *name_ptr, *p;
741*e4b17023SJohn Marino rtx orexp, newexp;
742*e4b17023SJohn Marino
743*e4b17023SJohn Marino switch (GET_CODE (exp))
744*e4b17023SJohn Marino {
745*e4b17023SJohn Marino case EQ_ATTR:
746*e4b17023SJohn Marino /* Handle negation test. */
747*e4b17023SJohn Marino if (XSTR (exp, 1)[0] == '!')
748*e4b17023SJohn Marino return check_attr_test (attr_rtx (NOT,
749*e4b17023SJohn Marino attr_eq (XSTR (exp, 0),
750*e4b17023SJohn Marino &XSTR (exp, 1)[1])),
751*e4b17023SJohn Marino is_const, lineno);
752*e4b17023SJohn Marino
753*e4b17023SJohn Marino else if (n_comma_elts (XSTR (exp, 1)) == 1)
754*e4b17023SJohn Marino {
755*e4b17023SJohn Marino attr = find_attr (&XSTR (exp, 0), 0);
756*e4b17023SJohn Marino if (attr == NULL)
757*e4b17023SJohn Marino {
758*e4b17023SJohn Marino if (! strcmp (XSTR (exp, 0), "alternative"))
759*e4b17023SJohn Marino return mk_attr_alt (1 << atoi (XSTR (exp, 1)));
760*e4b17023SJohn Marino else
761*e4b17023SJohn Marino fatal ("unknown attribute `%s' in EQ_ATTR", XSTR (exp, 0));
762*e4b17023SJohn Marino }
763*e4b17023SJohn Marino
764*e4b17023SJohn Marino if (is_const && ! attr->is_const)
765*e4b17023SJohn Marino fatal ("constant expression uses insn attribute `%s' in EQ_ATTR",
766*e4b17023SJohn Marino XSTR (exp, 0));
767*e4b17023SJohn Marino
768*e4b17023SJohn Marino /* Copy this just to make it permanent,
769*e4b17023SJohn Marino so expressions using it can be permanent too. */
770*e4b17023SJohn Marino exp = attr_eq (XSTR (exp, 0), XSTR (exp, 1));
771*e4b17023SJohn Marino
772*e4b17023SJohn Marino /* It shouldn't be possible to simplify the value given to a
773*e4b17023SJohn Marino constant attribute, so don't expand this until it's time to
774*e4b17023SJohn Marino write the test expression. */
775*e4b17023SJohn Marino if (attr->is_const)
776*e4b17023SJohn Marino ATTR_IND_SIMPLIFIED_P (exp) = 1;
777*e4b17023SJohn Marino
778*e4b17023SJohn Marino if (attr->is_numeric)
779*e4b17023SJohn Marino {
780*e4b17023SJohn Marino for (p = XSTR (exp, 1); *p; p++)
781*e4b17023SJohn Marino if (! ISDIGIT (*p))
782*e4b17023SJohn Marino fatal ("attribute `%s' takes only numeric values",
783*e4b17023SJohn Marino XSTR (exp, 0));
784*e4b17023SJohn Marino }
785*e4b17023SJohn Marino else
786*e4b17023SJohn Marino {
787*e4b17023SJohn Marino for (av = attr->first_value; av; av = av->next)
788*e4b17023SJohn Marino if (GET_CODE (av->value) == CONST_STRING
789*e4b17023SJohn Marino && ! strcmp (XSTR (exp, 1), XSTR (av->value, 0)))
790*e4b17023SJohn Marino break;
791*e4b17023SJohn Marino
792*e4b17023SJohn Marino if (av == NULL)
793*e4b17023SJohn Marino fatal ("unknown value `%s' for `%s' attribute",
794*e4b17023SJohn Marino XSTR (exp, 1), XSTR (exp, 0));
795*e4b17023SJohn Marino }
796*e4b17023SJohn Marino }
797*e4b17023SJohn Marino else
798*e4b17023SJohn Marino {
799*e4b17023SJohn Marino if (! strcmp (XSTR (exp, 0), "alternative"))
800*e4b17023SJohn Marino {
801*e4b17023SJohn Marino int set = 0;
802*e4b17023SJohn Marino
803*e4b17023SJohn Marino name_ptr = XSTR (exp, 1);
804*e4b17023SJohn Marino while ((p = next_comma_elt (&name_ptr)) != NULL)
805*e4b17023SJohn Marino set |= 1 << atoi (p);
806*e4b17023SJohn Marino
807*e4b17023SJohn Marino return mk_attr_alt (set);
808*e4b17023SJohn Marino }
809*e4b17023SJohn Marino else
810*e4b17023SJohn Marino {
811*e4b17023SJohn Marino /* Make an IOR tree of the possible values. */
812*e4b17023SJohn Marino orexp = false_rtx;
813*e4b17023SJohn Marino name_ptr = XSTR (exp, 1);
814*e4b17023SJohn Marino while ((p = next_comma_elt (&name_ptr)) != NULL)
815*e4b17023SJohn Marino {
816*e4b17023SJohn Marino newexp = attr_eq (XSTR (exp, 0), p);
817*e4b17023SJohn Marino orexp = insert_right_side (IOR, orexp, newexp, -2, -2);
818*e4b17023SJohn Marino }
819*e4b17023SJohn Marino
820*e4b17023SJohn Marino return check_attr_test (orexp, is_const, lineno);
821*e4b17023SJohn Marino }
822*e4b17023SJohn Marino }
823*e4b17023SJohn Marino break;
824*e4b17023SJohn Marino
825*e4b17023SJohn Marino case ATTR_FLAG:
826*e4b17023SJohn Marino break;
827*e4b17023SJohn Marino
828*e4b17023SJohn Marino case CONST_INT:
829*e4b17023SJohn Marino /* Either TRUE or FALSE. */
830*e4b17023SJohn Marino if (XWINT (exp, 0))
831*e4b17023SJohn Marino return true_rtx;
832*e4b17023SJohn Marino else
833*e4b17023SJohn Marino return false_rtx;
834*e4b17023SJohn Marino
835*e4b17023SJohn Marino case IOR:
836*e4b17023SJohn Marino case AND:
837*e4b17023SJohn Marino XEXP (exp, 0) = check_attr_test (XEXP (exp, 0), is_const, lineno);
838*e4b17023SJohn Marino XEXP (exp, 1) = check_attr_test (XEXP (exp, 1), is_const, lineno);
839*e4b17023SJohn Marino break;
840*e4b17023SJohn Marino
841*e4b17023SJohn Marino case NOT:
842*e4b17023SJohn Marino XEXP (exp, 0) = check_attr_test (XEXP (exp, 0), is_const, lineno);
843*e4b17023SJohn Marino break;
844*e4b17023SJohn Marino
845*e4b17023SJohn Marino case MATCH_TEST:
846*e4b17023SJohn Marino exp = attr_rtx (MATCH_TEST, XSTR (exp, 0));
847*e4b17023SJohn Marino ATTR_IND_SIMPLIFIED_P (exp) = 1;
848*e4b17023SJohn Marino break;
849*e4b17023SJohn Marino
850*e4b17023SJohn Marino case MATCH_OPERAND:
851*e4b17023SJohn Marino if (is_const)
852*e4b17023SJohn Marino fatal ("RTL operator \"%s\" not valid in constant attribute test",
853*e4b17023SJohn Marino GET_RTX_NAME (GET_CODE (exp)));
854*e4b17023SJohn Marino /* These cases can't be simplified. */
855*e4b17023SJohn Marino ATTR_IND_SIMPLIFIED_P (exp) = 1;
856*e4b17023SJohn Marino break;
857*e4b17023SJohn Marino
858*e4b17023SJohn Marino case LE: case LT: case GT: case GE:
859*e4b17023SJohn Marino case LEU: case LTU: case GTU: case GEU:
860*e4b17023SJohn Marino case NE: case EQ:
861*e4b17023SJohn Marino if (GET_CODE (XEXP (exp, 0)) == SYMBOL_REF
862*e4b17023SJohn Marino && GET_CODE (XEXP (exp, 1)) == SYMBOL_REF)
863*e4b17023SJohn Marino exp = attr_rtx (GET_CODE (exp),
864*e4b17023SJohn Marino attr_rtx (SYMBOL_REF, XSTR (XEXP (exp, 0), 0)),
865*e4b17023SJohn Marino attr_rtx (SYMBOL_REF, XSTR (XEXP (exp, 1), 0)));
866*e4b17023SJohn Marino /* These cases can't be simplified. */
867*e4b17023SJohn Marino ATTR_IND_SIMPLIFIED_P (exp) = 1;
868*e4b17023SJohn Marino break;
869*e4b17023SJohn Marino
870*e4b17023SJohn Marino case SYMBOL_REF:
871*e4b17023SJohn Marino if (is_const)
872*e4b17023SJohn Marino {
873*e4b17023SJohn Marino /* These cases are valid for constant attributes, but can't be
874*e4b17023SJohn Marino simplified. */
875*e4b17023SJohn Marino exp = attr_rtx (SYMBOL_REF, XSTR (exp, 0));
876*e4b17023SJohn Marino ATTR_IND_SIMPLIFIED_P (exp) = 1;
877*e4b17023SJohn Marino break;
878*e4b17023SJohn Marino }
879*e4b17023SJohn Marino default:
880*e4b17023SJohn Marino fatal ("RTL operator \"%s\" not valid in attribute test",
881*e4b17023SJohn Marino GET_RTX_NAME (GET_CODE (exp)));
882*e4b17023SJohn Marino }
883*e4b17023SJohn Marino
884*e4b17023SJohn Marino return exp;
885*e4b17023SJohn Marino }
886*e4b17023SJohn Marino
887*e4b17023SJohn Marino /* Given an expression, ensure that it is validly formed and that all named
888*e4b17023SJohn Marino attribute values are valid for the given attribute. Issue a fatal error
889*e4b17023SJohn Marino if not. If no attribute is specified, assume a numeric attribute.
890*e4b17023SJohn Marino
891*e4b17023SJohn Marino Return a perhaps modified replacement expression for the value. */
892*e4b17023SJohn Marino
893*e4b17023SJohn Marino static rtx
check_attr_value(rtx exp,struct attr_desc * attr)894*e4b17023SJohn Marino check_attr_value (rtx exp, struct attr_desc *attr)
895*e4b17023SJohn Marino {
896*e4b17023SJohn Marino struct attr_value *av;
897*e4b17023SJohn Marino const char *p;
898*e4b17023SJohn Marino int i;
899*e4b17023SJohn Marino
900*e4b17023SJohn Marino switch (GET_CODE (exp))
901*e4b17023SJohn Marino {
902*e4b17023SJohn Marino case CONST_INT:
903*e4b17023SJohn Marino if (attr && ! attr->is_numeric)
904*e4b17023SJohn Marino {
905*e4b17023SJohn Marino error_with_line (attr->lineno,
906*e4b17023SJohn Marino "CONST_INT not valid for non-numeric attribute %s",
907*e4b17023SJohn Marino attr->name);
908*e4b17023SJohn Marino break;
909*e4b17023SJohn Marino }
910*e4b17023SJohn Marino
911*e4b17023SJohn Marino if (INTVAL (exp) < 0)
912*e4b17023SJohn Marino {
913*e4b17023SJohn Marino error_with_line (attr->lineno,
914*e4b17023SJohn Marino "negative numeric value specified for attribute %s",
915*e4b17023SJohn Marino attr->name);
916*e4b17023SJohn Marino break;
917*e4b17023SJohn Marino }
918*e4b17023SJohn Marino break;
919*e4b17023SJohn Marino
920*e4b17023SJohn Marino case CONST_STRING:
921*e4b17023SJohn Marino if (! strcmp (XSTR (exp, 0), "*"))
922*e4b17023SJohn Marino break;
923*e4b17023SJohn Marino
924*e4b17023SJohn Marino if (attr == 0 || attr->is_numeric)
925*e4b17023SJohn Marino {
926*e4b17023SJohn Marino p = XSTR (exp, 0);
927*e4b17023SJohn Marino for (; *p; p++)
928*e4b17023SJohn Marino if (! ISDIGIT (*p))
929*e4b17023SJohn Marino {
930*e4b17023SJohn Marino error_with_line (attr ? attr->lineno : 0,
931*e4b17023SJohn Marino "non-numeric value for numeric attribute %s",
932*e4b17023SJohn Marino attr ? attr->name : "internal");
933*e4b17023SJohn Marino break;
934*e4b17023SJohn Marino }
935*e4b17023SJohn Marino break;
936*e4b17023SJohn Marino }
937*e4b17023SJohn Marino
938*e4b17023SJohn Marino for (av = attr->first_value; av; av = av->next)
939*e4b17023SJohn Marino if (GET_CODE (av->value) == CONST_STRING
940*e4b17023SJohn Marino && ! strcmp (XSTR (av->value, 0), XSTR (exp, 0)))
941*e4b17023SJohn Marino break;
942*e4b17023SJohn Marino
943*e4b17023SJohn Marino if (av == NULL)
944*e4b17023SJohn Marino error_with_line (attr->lineno,
945*e4b17023SJohn Marino "unknown value `%s' for `%s' attribute",
946*e4b17023SJohn Marino XSTR (exp, 0), attr ? attr->name : "internal");
947*e4b17023SJohn Marino break;
948*e4b17023SJohn Marino
949*e4b17023SJohn Marino case IF_THEN_ELSE:
950*e4b17023SJohn Marino XEXP (exp, 0) = check_attr_test (XEXP (exp, 0),
951*e4b17023SJohn Marino attr ? attr->is_const : 0,
952*e4b17023SJohn Marino attr ? attr->lineno : 0);
953*e4b17023SJohn Marino XEXP (exp, 1) = check_attr_value (XEXP (exp, 1), attr);
954*e4b17023SJohn Marino XEXP (exp, 2) = check_attr_value (XEXP (exp, 2), attr);
955*e4b17023SJohn Marino break;
956*e4b17023SJohn Marino
957*e4b17023SJohn Marino case PLUS:
958*e4b17023SJohn Marino case MINUS:
959*e4b17023SJohn Marino case MULT:
960*e4b17023SJohn Marino case DIV:
961*e4b17023SJohn Marino case MOD:
962*e4b17023SJohn Marino if (attr && !attr->is_numeric)
963*e4b17023SJohn Marino {
964*e4b17023SJohn Marino error_with_line (attr->lineno,
965*e4b17023SJohn Marino "invalid operation `%s' for non-numeric"
966*e4b17023SJohn Marino " attribute value", GET_RTX_NAME (GET_CODE (exp)));
967*e4b17023SJohn Marino break;
968*e4b17023SJohn Marino }
969*e4b17023SJohn Marino /* Fall through. */
970*e4b17023SJohn Marino
971*e4b17023SJohn Marino case IOR:
972*e4b17023SJohn Marino case AND:
973*e4b17023SJohn Marino XEXP (exp, 0) = check_attr_value (XEXP (exp, 0), attr);
974*e4b17023SJohn Marino XEXP (exp, 1) = check_attr_value (XEXP (exp, 1), attr);
975*e4b17023SJohn Marino break;
976*e4b17023SJohn Marino
977*e4b17023SJohn Marino case FFS:
978*e4b17023SJohn Marino case CLZ:
979*e4b17023SJohn Marino case CTZ:
980*e4b17023SJohn Marino case POPCOUNT:
981*e4b17023SJohn Marino case PARITY:
982*e4b17023SJohn Marino case BSWAP:
983*e4b17023SJohn Marino XEXP (exp, 0) = check_attr_value (XEXP (exp, 0), attr);
984*e4b17023SJohn Marino break;
985*e4b17023SJohn Marino
986*e4b17023SJohn Marino case COND:
987*e4b17023SJohn Marino if (XVECLEN (exp, 0) % 2 != 0)
988*e4b17023SJohn Marino {
989*e4b17023SJohn Marino error_with_line (attr->lineno,
990*e4b17023SJohn Marino "first operand of COND must have even length");
991*e4b17023SJohn Marino break;
992*e4b17023SJohn Marino }
993*e4b17023SJohn Marino
994*e4b17023SJohn Marino for (i = 0; i < XVECLEN (exp, 0); i += 2)
995*e4b17023SJohn Marino {
996*e4b17023SJohn Marino XVECEXP (exp, 0, i) = check_attr_test (XVECEXP (exp, 0, i),
997*e4b17023SJohn Marino attr ? attr->is_const : 0,
998*e4b17023SJohn Marino attr ? attr->lineno : 0);
999*e4b17023SJohn Marino XVECEXP (exp, 0, i + 1)
1000*e4b17023SJohn Marino = check_attr_value (XVECEXP (exp, 0, i + 1), attr);
1001*e4b17023SJohn Marino }
1002*e4b17023SJohn Marino
1003*e4b17023SJohn Marino XEXP (exp, 1) = check_attr_value (XEXP (exp, 1), attr);
1004*e4b17023SJohn Marino break;
1005*e4b17023SJohn Marino
1006*e4b17023SJohn Marino case ATTR:
1007*e4b17023SJohn Marino {
1008*e4b17023SJohn Marino struct attr_desc *attr2 = find_attr (&XSTR (exp, 0), 0);
1009*e4b17023SJohn Marino if (attr2 == NULL)
1010*e4b17023SJohn Marino error_with_line (attr ? attr->lineno : 0,
1011*e4b17023SJohn Marino "unknown attribute `%s' in ATTR",
1012*e4b17023SJohn Marino XSTR (exp, 0));
1013*e4b17023SJohn Marino else if (attr && attr->is_const && ! attr2->is_const)
1014*e4b17023SJohn Marino error_with_line (attr->lineno,
1015*e4b17023SJohn Marino "non-constant attribute `%s' referenced from `%s'",
1016*e4b17023SJohn Marino XSTR (exp, 0), attr->name);
1017*e4b17023SJohn Marino else if (attr
1018*e4b17023SJohn Marino && attr->is_numeric != attr2->is_numeric)
1019*e4b17023SJohn Marino error_with_line (attr->lineno,
1020*e4b17023SJohn Marino "numeric attribute mismatch calling `%s' from `%s'",
1021*e4b17023SJohn Marino XSTR (exp, 0), attr->name);
1022*e4b17023SJohn Marino }
1023*e4b17023SJohn Marino break;
1024*e4b17023SJohn Marino
1025*e4b17023SJohn Marino case SYMBOL_REF:
1026*e4b17023SJohn Marino /* A constant SYMBOL_REF is valid as a constant attribute test and
1027*e4b17023SJohn Marino is expanded later by make_canonical into a COND. In a non-constant
1028*e4b17023SJohn Marino attribute test, it is left be. */
1029*e4b17023SJohn Marino return attr_rtx (SYMBOL_REF, XSTR (exp, 0));
1030*e4b17023SJohn Marino
1031*e4b17023SJohn Marino default:
1032*e4b17023SJohn Marino error_with_line (attr ? attr->lineno : 0,
1033*e4b17023SJohn Marino "invalid operation `%s' for attribute value",
1034*e4b17023SJohn Marino GET_RTX_NAME (GET_CODE (exp)));
1035*e4b17023SJohn Marino break;
1036*e4b17023SJohn Marino }
1037*e4b17023SJohn Marino
1038*e4b17023SJohn Marino return exp;
1039*e4b17023SJohn Marino }
1040*e4b17023SJohn Marino
1041*e4b17023SJohn Marino /* Given an SET_ATTR_ALTERNATIVE expression, convert to the canonical SET.
1042*e4b17023SJohn Marino It becomes a COND with each test being (eq_attr "alternative" "n") */
1043*e4b17023SJohn Marino
1044*e4b17023SJohn Marino static rtx
convert_set_attr_alternative(rtx exp,struct insn_def * id)1045*e4b17023SJohn Marino convert_set_attr_alternative (rtx exp, struct insn_def *id)
1046*e4b17023SJohn Marino {
1047*e4b17023SJohn Marino int num_alt = id->num_alternatives;
1048*e4b17023SJohn Marino rtx condexp;
1049*e4b17023SJohn Marino int i;
1050*e4b17023SJohn Marino
1051*e4b17023SJohn Marino if (XVECLEN (exp, 1) != num_alt)
1052*e4b17023SJohn Marino {
1053*e4b17023SJohn Marino error_with_line (id->lineno,
1054*e4b17023SJohn Marino "bad number of entries in SET_ATTR_ALTERNATIVE");
1055*e4b17023SJohn Marino return NULL_RTX;
1056*e4b17023SJohn Marino }
1057*e4b17023SJohn Marino
1058*e4b17023SJohn Marino /* Make a COND with all tests but the last. Select the last value via the
1059*e4b17023SJohn Marino default. */
1060*e4b17023SJohn Marino condexp = rtx_alloc (COND);
1061*e4b17023SJohn Marino XVEC (condexp, 0) = rtvec_alloc ((num_alt - 1) * 2);
1062*e4b17023SJohn Marino
1063*e4b17023SJohn Marino for (i = 0; i < num_alt - 1; i++)
1064*e4b17023SJohn Marino {
1065*e4b17023SJohn Marino const char *p;
1066*e4b17023SJohn Marino p = attr_numeral (i);
1067*e4b17023SJohn Marino
1068*e4b17023SJohn Marino XVECEXP (condexp, 0, 2 * i) = attr_eq (alternative_name, p);
1069*e4b17023SJohn Marino XVECEXP (condexp, 0, 2 * i + 1) = XVECEXP (exp, 1, i);
1070*e4b17023SJohn Marino }
1071*e4b17023SJohn Marino
1072*e4b17023SJohn Marino XEXP (condexp, 1) = XVECEXP (exp, 1, i);
1073*e4b17023SJohn Marino
1074*e4b17023SJohn Marino return attr_rtx (SET, attr_rtx (ATTR, XSTR (exp, 0)), condexp);
1075*e4b17023SJohn Marino }
1076*e4b17023SJohn Marino
1077*e4b17023SJohn Marino /* Given a SET_ATTR, convert to the appropriate SET. If a comma-separated
1078*e4b17023SJohn Marino list of values is given, convert to SET_ATTR_ALTERNATIVE first. */
1079*e4b17023SJohn Marino
1080*e4b17023SJohn Marino static rtx
convert_set_attr(rtx exp,struct insn_def * id)1081*e4b17023SJohn Marino convert_set_attr (rtx exp, struct insn_def *id)
1082*e4b17023SJohn Marino {
1083*e4b17023SJohn Marino rtx newexp;
1084*e4b17023SJohn Marino const char *name_ptr;
1085*e4b17023SJohn Marino char *p;
1086*e4b17023SJohn Marino int n;
1087*e4b17023SJohn Marino
1088*e4b17023SJohn Marino /* See how many alternative specified. */
1089*e4b17023SJohn Marino n = n_comma_elts (XSTR (exp, 1));
1090*e4b17023SJohn Marino if (n == 1)
1091*e4b17023SJohn Marino return attr_rtx (SET,
1092*e4b17023SJohn Marino attr_rtx (ATTR, XSTR (exp, 0)),
1093*e4b17023SJohn Marino attr_rtx (CONST_STRING, XSTR (exp, 1)));
1094*e4b17023SJohn Marino
1095*e4b17023SJohn Marino newexp = rtx_alloc (SET_ATTR_ALTERNATIVE);
1096*e4b17023SJohn Marino XSTR (newexp, 0) = XSTR (exp, 0);
1097*e4b17023SJohn Marino XVEC (newexp, 1) = rtvec_alloc (n);
1098*e4b17023SJohn Marino
1099*e4b17023SJohn Marino /* Process each comma-separated name. */
1100*e4b17023SJohn Marino name_ptr = XSTR (exp, 1);
1101*e4b17023SJohn Marino n = 0;
1102*e4b17023SJohn Marino while ((p = next_comma_elt (&name_ptr)) != NULL)
1103*e4b17023SJohn Marino XVECEXP (newexp, 1, n++) = attr_rtx (CONST_STRING, p);
1104*e4b17023SJohn Marino
1105*e4b17023SJohn Marino return convert_set_attr_alternative (newexp, id);
1106*e4b17023SJohn Marino }
1107*e4b17023SJohn Marino
1108*e4b17023SJohn Marino /* Scan all definitions, checking for validity. Also, convert any SET_ATTR
1109*e4b17023SJohn Marino and SET_ATTR_ALTERNATIVE expressions to the corresponding SET
1110*e4b17023SJohn Marino expressions. */
1111*e4b17023SJohn Marino
1112*e4b17023SJohn Marino static void
check_defs(void)1113*e4b17023SJohn Marino check_defs (void)
1114*e4b17023SJohn Marino {
1115*e4b17023SJohn Marino struct insn_def *id;
1116*e4b17023SJohn Marino struct attr_desc *attr;
1117*e4b17023SJohn Marino int i;
1118*e4b17023SJohn Marino rtx value;
1119*e4b17023SJohn Marino
1120*e4b17023SJohn Marino for (id = defs; id; id = id->next)
1121*e4b17023SJohn Marino {
1122*e4b17023SJohn Marino if (XVEC (id->def, id->vec_idx) == NULL)
1123*e4b17023SJohn Marino continue;
1124*e4b17023SJohn Marino
1125*e4b17023SJohn Marino for (i = 0; i < XVECLEN (id->def, id->vec_idx); i++)
1126*e4b17023SJohn Marino {
1127*e4b17023SJohn Marino value = XVECEXP (id->def, id->vec_idx, i);
1128*e4b17023SJohn Marino switch (GET_CODE (value))
1129*e4b17023SJohn Marino {
1130*e4b17023SJohn Marino case SET:
1131*e4b17023SJohn Marino if (GET_CODE (XEXP (value, 0)) != ATTR)
1132*e4b17023SJohn Marino {
1133*e4b17023SJohn Marino error_with_line (id->lineno, "bad attribute set");
1134*e4b17023SJohn Marino value = NULL_RTX;
1135*e4b17023SJohn Marino }
1136*e4b17023SJohn Marino break;
1137*e4b17023SJohn Marino
1138*e4b17023SJohn Marino case SET_ATTR_ALTERNATIVE:
1139*e4b17023SJohn Marino value = convert_set_attr_alternative (value, id);
1140*e4b17023SJohn Marino break;
1141*e4b17023SJohn Marino
1142*e4b17023SJohn Marino case SET_ATTR:
1143*e4b17023SJohn Marino value = convert_set_attr (value, id);
1144*e4b17023SJohn Marino break;
1145*e4b17023SJohn Marino
1146*e4b17023SJohn Marino default:
1147*e4b17023SJohn Marino error_with_line (id->lineno, "invalid attribute code %s",
1148*e4b17023SJohn Marino GET_RTX_NAME (GET_CODE (value)));
1149*e4b17023SJohn Marino value = NULL_RTX;
1150*e4b17023SJohn Marino }
1151*e4b17023SJohn Marino if (value == NULL_RTX)
1152*e4b17023SJohn Marino continue;
1153*e4b17023SJohn Marino
1154*e4b17023SJohn Marino if ((attr = find_attr (&XSTR (XEXP (value, 0), 0), 0)) == NULL)
1155*e4b17023SJohn Marino {
1156*e4b17023SJohn Marino error_with_line (id->lineno, "unknown attribute %s",
1157*e4b17023SJohn Marino XSTR (XEXP (value, 0), 0));
1158*e4b17023SJohn Marino continue;
1159*e4b17023SJohn Marino }
1160*e4b17023SJohn Marino
1161*e4b17023SJohn Marino XVECEXP (id->def, id->vec_idx, i) = value;
1162*e4b17023SJohn Marino XEXP (value, 1) = check_attr_value (XEXP (value, 1), attr);
1163*e4b17023SJohn Marino }
1164*e4b17023SJohn Marino }
1165*e4b17023SJohn Marino }
1166*e4b17023SJohn Marino
1167*e4b17023SJohn Marino /* Given a valid expression for an attribute value, remove any IF_THEN_ELSE
1168*e4b17023SJohn Marino expressions by converting them into a COND. This removes cases from this
1169*e4b17023SJohn Marino program. Also, replace an attribute value of "*" with the default attribute
1170*e4b17023SJohn Marino value. */
1171*e4b17023SJohn Marino
1172*e4b17023SJohn Marino static rtx
make_canonical(struct attr_desc * attr,rtx exp)1173*e4b17023SJohn Marino make_canonical (struct attr_desc *attr, rtx exp)
1174*e4b17023SJohn Marino {
1175*e4b17023SJohn Marino int i;
1176*e4b17023SJohn Marino rtx newexp;
1177*e4b17023SJohn Marino
1178*e4b17023SJohn Marino switch (GET_CODE (exp))
1179*e4b17023SJohn Marino {
1180*e4b17023SJohn Marino case CONST_INT:
1181*e4b17023SJohn Marino exp = make_numeric_value (INTVAL (exp));
1182*e4b17023SJohn Marino break;
1183*e4b17023SJohn Marino
1184*e4b17023SJohn Marino case CONST_STRING:
1185*e4b17023SJohn Marino if (! strcmp (XSTR (exp, 0), "*"))
1186*e4b17023SJohn Marino {
1187*e4b17023SJohn Marino if (attr == 0 || attr->default_val == 0)
1188*e4b17023SJohn Marino fatal ("(attr_value \"*\") used in invalid context");
1189*e4b17023SJohn Marino exp = attr->default_val->value;
1190*e4b17023SJohn Marino }
1191*e4b17023SJohn Marino else
1192*e4b17023SJohn Marino XSTR (exp, 0) = DEF_ATTR_STRING (XSTR (exp, 0));
1193*e4b17023SJohn Marino
1194*e4b17023SJohn Marino break;
1195*e4b17023SJohn Marino
1196*e4b17023SJohn Marino case SYMBOL_REF:
1197*e4b17023SJohn Marino if (!attr->is_const || ATTR_IND_SIMPLIFIED_P (exp))
1198*e4b17023SJohn Marino break;
1199*e4b17023SJohn Marino /* The SYMBOL_REF is constant for a given run, so mark it as unchanging.
1200*e4b17023SJohn Marino This makes the COND something that won't be considered an arbitrary
1201*e4b17023SJohn Marino expression by walk_attr_value. */
1202*e4b17023SJohn Marino ATTR_IND_SIMPLIFIED_P (exp) = 1;
1203*e4b17023SJohn Marino exp = check_attr_value (exp, attr);
1204*e4b17023SJohn Marino break;
1205*e4b17023SJohn Marino
1206*e4b17023SJohn Marino case IF_THEN_ELSE:
1207*e4b17023SJohn Marino newexp = rtx_alloc (COND);
1208*e4b17023SJohn Marino XVEC (newexp, 0) = rtvec_alloc (2);
1209*e4b17023SJohn Marino XVECEXP (newexp, 0, 0) = XEXP (exp, 0);
1210*e4b17023SJohn Marino XVECEXP (newexp, 0, 1) = XEXP (exp, 1);
1211*e4b17023SJohn Marino
1212*e4b17023SJohn Marino XEXP (newexp, 1) = XEXP (exp, 2);
1213*e4b17023SJohn Marino
1214*e4b17023SJohn Marino exp = newexp;
1215*e4b17023SJohn Marino /* Fall through to COND case since this is now a COND. */
1216*e4b17023SJohn Marino
1217*e4b17023SJohn Marino case COND:
1218*e4b17023SJohn Marino {
1219*e4b17023SJohn Marino int allsame = 1;
1220*e4b17023SJohn Marino rtx defval;
1221*e4b17023SJohn Marino
1222*e4b17023SJohn Marino /* First, check for degenerate COND. */
1223*e4b17023SJohn Marino if (XVECLEN (exp, 0) == 0)
1224*e4b17023SJohn Marino return make_canonical (attr, XEXP (exp, 1));
1225*e4b17023SJohn Marino defval = XEXP (exp, 1) = make_canonical (attr, XEXP (exp, 1));
1226*e4b17023SJohn Marino
1227*e4b17023SJohn Marino for (i = 0; i < XVECLEN (exp, 0); i += 2)
1228*e4b17023SJohn Marino {
1229*e4b17023SJohn Marino XVECEXP (exp, 0, i) = copy_boolean (XVECEXP (exp, 0, i));
1230*e4b17023SJohn Marino XVECEXP (exp, 0, i + 1)
1231*e4b17023SJohn Marino = make_canonical (attr, XVECEXP (exp, 0, i + 1));
1232*e4b17023SJohn Marino if (! rtx_equal_p (XVECEXP (exp, 0, i + 1), defval))
1233*e4b17023SJohn Marino allsame = 0;
1234*e4b17023SJohn Marino }
1235*e4b17023SJohn Marino if (allsame)
1236*e4b17023SJohn Marino return defval;
1237*e4b17023SJohn Marino }
1238*e4b17023SJohn Marino break;
1239*e4b17023SJohn Marino
1240*e4b17023SJohn Marino default:
1241*e4b17023SJohn Marino break;
1242*e4b17023SJohn Marino }
1243*e4b17023SJohn Marino
1244*e4b17023SJohn Marino return exp;
1245*e4b17023SJohn Marino }
1246*e4b17023SJohn Marino
1247*e4b17023SJohn Marino static rtx
copy_boolean(rtx exp)1248*e4b17023SJohn Marino copy_boolean (rtx exp)
1249*e4b17023SJohn Marino {
1250*e4b17023SJohn Marino if (GET_CODE (exp) == AND || GET_CODE (exp) == IOR)
1251*e4b17023SJohn Marino return attr_rtx (GET_CODE (exp), copy_boolean (XEXP (exp, 0)),
1252*e4b17023SJohn Marino copy_boolean (XEXP (exp, 1)));
1253*e4b17023SJohn Marino if (GET_CODE (exp) == MATCH_OPERAND)
1254*e4b17023SJohn Marino {
1255*e4b17023SJohn Marino XSTR (exp, 1) = DEF_ATTR_STRING (XSTR (exp, 1));
1256*e4b17023SJohn Marino XSTR (exp, 2) = DEF_ATTR_STRING (XSTR (exp, 2));
1257*e4b17023SJohn Marino }
1258*e4b17023SJohn Marino else if (GET_CODE (exp) == EQ_ATTR)
1259*e4b17023SJohn Marino {
1260*e4b17023SJohn Marino XSTR (exp, 0) = DEF_ATTR_STRING (XSTR (exp, 0));
1261*e4b17023SJohn Marino XSTR (exp, 1) = DEF_ATTR_STRING (XSTR (exp, 1));
1262*e4b17023SJohn Marino }
1263*e4b17023SJohn Marino
1264*e4b17023SJohn Marino return exp;
1265*e4b17023SJohn Marino }
1266*e4b17023SJohn Marino
1267*e4b17023SJohn Marino /* Given a value and an attribute description, return a `struct attr_value *'
1268*e4b17023SJohn Marino that represents that value. This is either an existing structure, if the
1269*e4b17023SJohn Marino value has been previously encountered, or a newly-created structure.
1270*e4b17023SJohn Marino
1271*e4b17023SJohn Marino `insn_code' is the code of an insn whose attribute has the specified
1272*e4b17023SJohn Marino value (-2 if not processing an insn). We ensure that all insns for
1273*e4b17023SJohn Marino a given value have the same number of alternatives if the value checks
1274*e4b17023SJohn Marino alternatives. */
1275*e4b17023SJohn Marino
1276*e4b17023SJohn Marino static struct attr_value *
get_attr_value(rtx value,struct attr_desc * attr,int insn_code)1277*e4b17023SJohn Marino get_attr_value (rtx value, struct attr_desc *attr, int insn_code)
1278*e4b17023SJohn Marino {
1279*e4b17023SJohn Marino struct attr_value *av;
1280*e4b17023SJohn Marino int num_alt = 0;
1281*e4b17023SJohn Marino
1282*e4b17023SJohn Marino value = make_canonical (attr, value);
1283*e4b17023SJohn Marino if (compares_alternatives_p (value))
1284*e4b17023SJohn Marino {
1285*e4b17023SJohn Marino if (insn_code < 0 || insn_alternatives == NULL)
1286*e4b17023SJohn Marino fatal ("(eq_attr \"alternatives\" ...) used in non-insn context");
1287*e4b17023SJohn Marino else
1288*e4b17023SJohn Marino num_alt = insn_alternatives[insn_code];
1289*e4b17023SJohn Marino }
1290*e4b17023SJohn Marino
1291*e4b17023SJohn Marino for (av = attr->first_value; av; av = av->next)
1292*e4b17023SJohn Marino if (rtx_equal_p (value, av->value)
1293*e4b17023SJohn Marino && (num_alt == 0 || av->first_insn == NULL
1294*e4b17023SJohn Marino || insn_alternatives[av->first_insn->def->insn_code]))
1295*e4b17023SJohn Marino return av;
1296*e4b17023SJohn Marino
1297*e4b17023SJohn Marino av = oballoc (struct attr_value);
1298*e4b17023SJohn Marino av->value = value;
1299*e4b17023SJohn Marino av->next = attr->first_value;
1300*e4b17023SJohn Marino attr->first_value = av;
1301*e4b17023SJohn Marino av->first_insn = NULL;
1302*e4b17023SJohn Marino av->num_insns = 0;
1303*e4b17023SJohn Marino av->has_asm_insn = 0;
1304*e4b17023SJohn Marino
1305*e4b17023SJohn Marino return av;
1306*e4b17023SJohn Marino }
1307*e4b17023SJohn Marino
1308*e4b17023SJohn Marino /* After all DEFINE_DELAYs have been read in, create internal attributes
1309*e4b17023SJohn Marino to generate the required routines.
1310*e4b17023SJohn Marino
1311*e4b17023SJohn Marino First, we compute the number of delay slots for each insn (as a COND of
1312*e4b17023SJohn Marino each of the test expressions in DEFINE_DELAYs). Then, if more than one
1313*e4b17023SJohn Marino delay type is specified, we compute a similar function giving the
1314*e4b17023SJohn Marino DEFINE_DELAY ordinal for each insn.
1315*e4b17023SJohn Marino
1316*e4b17023SJohn Marino Finally, for each [DEFINE_DELAY, slot #] pair, we compute an attribute that
1317*e4b17023SJohn Marino tells whether a given insn can be in that delay slot.
1318*e4b17023SJohn Marino
1319*e4b17023SJohn Marino Normal attribute filling and optimization expands these to contain the
1320*e4b17023SJohn Marino information needed to handle delay slots. */
1321*e4b17023SJohn Marino
1322*e4b17023SJohn Marino static void
expand_delays(void)1323*e4b17023SJohn Marino expand_delays (void)
1324*e4b17023SJohn Marino {
1325*e4b17023SJohn Marino struct delay_desc *delay;
1326*e4b17023SJohn Marino rtx condexp;
1327*e4b17023SJohn Marino rtx newexp;
1328*e4b17023SJohn Marino int i;
1329*e4b17023SJohn Marino char *p;
1330*e4b17023SJohn Marino
1331*e4b17023SJohn Marino /* First, generate data for `num_delay_slots' function. */
1332*e4b17023SJohn Marino
1333*e4b17023SJohn Marino condexp = rtx_alloc (COND);
1334*e4b17023SJohn Marino XVEC (condexp, 0) = rtvec_alloc (num_delays * 2);
1335*e4b17023SJohn Marino XEXP (condexp, 1) = make_numeric_value (0);
1336*e4b17023SJohn Marino
1337*e4b17023SJohn Marino for (i = 0, delay = delays; delay; i += 2, delay = delay->next)
1338*e4b17023SJohn Marino {
1339*e4b17023SJohn Marino XVECEXP (condexp, 0, i) = XEXP (delay->def, 0);
1340*e4b17023SJohn Marino XVECEXP (condexp, 0, i + 1)
1341*e4b17023SJohn Marino = make_numeric_value (XVECLEN (delay->def, 1) / 3);
1342*e4b17023SJohn Marino }
1343*e4b17023SJohn Marino
1344*e4b17023SJohn Marino make_internal_attr (num_delay_slots_str, condexp, ATTR_NONE);
1345*e4b17023SJohn Marino
1346*e4b17023SJohn Marino /* If more than one delay type, do the same for computing the delay type. */
1347*e4b17023SJohn Marino if (num_delays > 1)
1348*e4b17023SJohn Marino {
1349*e4b17023SJohn Marino condexp = rtx_alloc (COND);
1350*e4b17023SJohn Marino XVEC (condexp, 0) = rtvec_alloc (num_delays * 2);
1351*e4b17023SJohn Marino XEXP (condexp, 1) = make_numeric_value (0);
1352*e4b17023SJohn Marino
1353*e4b17023SJohn Marino for (i = 0, delay = delays; delay; i += 2, delay = delay->next)
1354*e4b17023SJohn Marino {
1355*e4b17023SJohn Marino XVECEXP (condexp, 0, i) = XEXP (delay->def, 0);
1356*e4b17023SJohn Marino XVECEXP (condexp, 0, i + 1) = make_numeric_value (delay->num);
1357*e4b17023SJohn Marino }
1358*e4b17023SJohn Marino
1359*e4b17023SJohn Marino make_internal_attr (delay_type_str, condexp, ATTR_SPECIAL);
1360*e4b17023SJohn Marino }
1361*e4b17023SJohn Marino
1362*e4b17023SJohn Marino /* For each delay possibility and delay slot, compute an eligibility
1363*e4b17023SJohn Marino attribute for non-annulled insns and for each type of annulled (annul
1364*e4b17023SJohn Marino if true and annul if false). */
1365*e4b17023SJohn Marino for (delay = delays; delay; delay = delay->next)
1366*e4b17023SJohn Marino {
1367*e4b17023SJohn Marino for (i = 0; i < XVECLEN (delay->def, 1); i += 3)
1368*e4b17023SJohn Marino {
1369*e4b17023SJohn Marino condexp = XVECEXP (delay->def, 1, i);
1370*e4b17023SJohn Marino if (condexp == 0)
1371*e4b17023SJohn Marino condexp = false_rtx;
1372*e4b17023SJohn Marino newexp = attr_rtx (IF_THEN_ELSE, condexp,
1373*e4b17023SJohn Marino make_numeric_value (1), make_numeric_value (0));
1374*e4b17023SJohn Marino
1375*e4b17023SJohn Marino p = attr_printf (sizeof "*delay__" + MAX_DIGITS * 2,
1376*e4b17023SJohn Marino "*delay_%d_%d", delay->num, i / 3);
1377*e4b17023SJohn Marino make_internal_attr (p, newexp, ATTR_SPECIAL);
1378*e4b17023SJohn Marino
1379*e4b17023SJohn Marino if (have_annul_true)
1380*e4b17023SJohn Marino {
1381*e4b17023SJohn Marino condexp = XVECEXP (delay->def, 1, i + 1);
1382*e4b17023SJohn Marino if (condexp == 0) condexp = false_rtx;
1383*e4b17023SJohn Marino newexp = attr_rtx (IF_THEN_ELSE, condexp,
1384*e4b17023SJohn Marino make_numeric_value (1),
1385*e4b17023SJohn Marino make_numeric_value (0));
1386*e4b17023SJohn Marino p = attr_printf (sizeof "*annul_true__" + MAX_DIGITS * 2,
1387*e4b17023SJohn Marino "*annul_true_%d_%d", delay->num, i / 3);
1388*e4b17023SJohn Marino make_internal_attr (p, newexp, ATTR_SPECIAL);
1389*e4b17023SJohn Marino }
1390*e4b17023SJohn Marino
1391*e4b17023SJohn Marino if (have_annul_false)
1392*e4b17023SJohn Marino {
1393*e4b17023SJohn Marino condexp = XVECEXP (delay->def, 1, i + 2);
1394*e4b17023SJohn Marino if (condexp == 0) condexp = false_rtx;
1395*e4b17023SJohn Marino newexp = attr_rtx (IF_THEN_ELSE, condexp,
1396*e4b17023SJohn Marino make_numeric_value (1),
1397*e4b17023SJohn Marino make_numeric_value (0));
1398*e4b17023SJohn Marino p = attr_printf (sizeof "*annul_false__" + MAX_DIGITS * 2,
1399*e4b17023SJohn Marino "*annul_false_%d_%d", delay->num, i / 3);
1400*e4b17023SJohn Marino make_internal_attr (p, newexp, ATTR_SPECIAL);
1401*e4b17023SJohn Marino }
1402*e4b17023SJohn Marino }
1403*e4b17023SJohn Marino }
1404*e4b17023SJohn Marino }
1405*e4b17023SJohn Marino
1406*e4b17023SJohn Marino /* Once all attributes and insns have been read and checked, we construct for
1407*e4b17023SJohn Marino each attribute value a list of all the insns that have that value for
1408*e4b17023SJohn Marino the attribute. */
1409*e4b17023SJohn Marino
1410*e4b17023SJohn Marino static void
fill_attr(struct attr_desc * attr)1411*e4b17023SJohn Marino fill_attr (struct attr_desc *attr)
1412*e4b17023SJohn Marino {
1413*e4b17023SJohn Marino struct attr_value *av;
1414*e4b17023SJohn Marino struct insn_ent *ie;
1415*e4b17023SJohn Marino struct insn_def *id;
1416*e4b17023SJohn Marino int i;
1417*e4b17023SJohn Marino rtx value;
1418*e4b17023SJohn Marino
1419*e4b17023SJohn Marino /* Don't fill constant attributes. The value is independent of
1420*e4b17023SJohn Marino any particular insn. */
1421*e4b17023SJohn Marino if (attr->is_const)
1422*e4b17023SJohn Marino return;
1423*e4b17023SJohn Marino
1424*e4b17023SJohn Marino for (id = defs; id; id = id->next)
1425*e4b17023SJohn Marino {
1426*e4b17023SJohn Marino /* If no value is specified for this insn for this attribute, use the
1427*e4b17023SJohn Marino default. */
1428*e4b17023SJohn Marino value = NULL;
1429*e4b17023SJohn Marino if (XVEC (id->def, id->vec_idx))
1430*e4b17023SJohn Marino for (i = 0; i < XVECLEN (id->def, id->vec_idx); i++)
1431*e4b17023SJohn Marino if (! strcmp_check (XSTR (XEXP (XVECEXP (id->def, id->vec_idx, i), 0), 0),
1432*e4b17023SJohn Marino attr->name))
1433*e4b17023SJohn Marino value = XEXP (XVECEXP (id->def, id->vec_idx, i), 1);
1434*e4b17023SJohn Marino
1435*e4b17023SJohn Marino if (value == NULL)
1436*e4b17023SJohn Marino av = attr->default_val;
1437*e4b17023SJohn Marino else
1438*e4b17023SJohn Marino av = get_attr_value (value, attr, id->insn_code);
1439*e4b17023SJohn Marino
1440*e4b17023SJohn Marino ie = oballoc (struct insn_ent);
1441*e4b17023SJohn Marino ie->def = id;
1442*e4b17023SJohn Marino insert_insn_ent (av, ie);
1443*e4b17023SJohn Marino }
1444*e4b17023SJohn Marino }
1445*e4b17023SJohn Marino
1446*e4b17023SJohn Marino /* Given an expression EXP, see if it is a COND or IF_THEN_ELSE that has a
1447*e4b17023SJohn Marino test that checks relative positions of insns (uses MATCH_DUP or PC).
1448*e4b17023SJohn Marino If so, replace it with what is obtained by passing the expression to
1449*e4b17023SJohn Marino ADDRESS_FN. If not but it is a COND or IF_THEN_ELSE, call this routine
1450*e4b17023SJohn Marino recursively on each value (including the default value). Otherwise,
1451*e4b17023SJohn Marino return the value returned by NO_ADDRESS_FN applied to EXP. */
1452*e4b17023SJohn Marino
1453*e4b17023SJohn Marino static rtx
substitute_address(rtx exp,rtx (* no_address_fn)(rtx),rtx (* address_fn)(rtx))1454*e4b17023SJohn Marino substitute_address (rtx exp, rtx (*no_address_fn) (rtx),
1455*e4b17023SJohn Marino rtx (*address_fn) (rtx))
1456*e4b17023SJohn Marino {
1457*e4b17023SJohn Marino int i;
1458*e4b17023SJohn Marino rtx newexp;
1459*e4b17023SJohn Marino
1460*e4b17023SJohn Marino if (GET_CODE (exp) == COND)
1461*e4b17023SJohn Marino {
1462*e4b17023SJohn Marino /* See if any tests use addresses. */
1463*e4b17023SJohn Marino address_used = 0;
1464*e4b17023SJohn Marino for (i = 0; i < XVECLEN (exp, 0); i += 2)
1465*e4b17023SJohn Marino walk_attr_value (XVECEXP (exp, 0, i));
1466*e4b17023SJohn Marino
1467*e4b17023SJohn Marino if (address_used)
1468*e4b17023SJohn Marino return (*address_fn) (exp);
1469*e4b17023SJohn Marino
1470*e4b17023SJohn Marino /* Make a new copy of this COND, replacing each element. */
1471*e4b17023SJohn Marino newexp = rtx_alloc (COND);
1472*e4b17023SJohn Marino XVEC (newexp, 0) = rtvec_alloc (XVECLEN (exp, 0));
1473*e4b17023SJohn Marino for (i = 0; i < XVECLEN (exp, 0); i += 2)
1474*e4b17023SJohn Marino {
1475*e4b17023SJohn Marino XVECEXP (newexp, 0, i) = XVECEXP (exp, 0, i);
1476*e4b17023SJohn Marino XVECEXP (newexp, 0, i + 1)
1477*e4b17023SJohn Marino = substitute_address (XVECEXP (exp, 0, i + 1),
1478*e4b17023SJohn Marino no_address_fn, address_fn);
1479*e4b17023SJohn Marino }
1480*e4b17023SJohn Marino
1481*e4b17023SJohn Marino XEXP (newexp, 1) = substitute_address (XEXP (exp, 1),
1482*e4b17023SJohn Marino no_address_fn, address_fn);
1483*e4b17023SJohn Marino
1484*e4b17023SJohn Marino return newexp;
1485*e4b17023SJohn Marino }
1486*e4b17023SJohn Marino
1487*e4b17023SJohn Marino else if (GET_CODE (exp) == IF_THEN_ELSE)
1488*e4b17023SJohn Marino {
1489*e4b17023SJohn Marino address_used = 0;
1490*e4b17023SJohn Marino walk_attr_value (XEXP (exp, 0));
1491*e4b17023SJohn Marino if (address_used)
1492*e4b17023SJohn Marino return (*address_fn) (exp);
1493*e4b17023SJohn Marino
1494*e4b17023SJohn Marino return attr_rtx (IF_THEN_ELSE,
1495*e4b17023SJohn Marino substitute_address (XEXP (exp, 0),
1496*e4b17023SJohn Marino no_address_fn, address_fn),
1497*e4b17023SJohn Marino substitute_address (XEXP (exp, 1),
1498*e4b17023SJohn Marino no_address_fn, address_fn),
1499*e4b17023SJohn Marino substitute_address (XEXP (exp, 2),
1500*e4b17023SJohn Marino no_address_fn, address_fn));
1501*e4b17023SJohn Marino }
1502*e4b17023SJohn Marino
1503*e4b17023SJohn Marino return (*no_address_fn) (exp);
1504*e4b17023SJohn Marino }
1505*e4b17023SJohn Marino
1506*e4b17023SJohn Marino /* Make new attributes from the `length' attribute. The following are made,
1507*e4b17023SJohn Marino each corresponding to a function called from `shorten_branches' or
1508*e4b17023SJohn Marino `get_attr_length':
1509*e4b17023SJohn Marino
1510*e4b17023SJohn Marino *insn_default_length This is the length of the insn to be returned
1511*e4b17023SJohn Marino by `get_attr_length' before `shorten_branches'
1512*e4b17023SJohn Marino has been called. In each case where the length
1513*e4b17023SJohn Marino depends on relative addresses, the largest
1514*e4b17023SJohn Marino possible is used. This routine is also used
1515*e4b17023SJohn Marino to compute the initial size of the insn.
1516*e4b17023SJohn Marino
1517*e4b17023SJohn Marino *insn_variable_length_p This returns 1 if the insn's length depends
1518*e4b17023SJohn Marino on relative addresses, zero otherwise.
1519*e4b17023SJohn Marino
1520*e4b17023SJohn Marino *insn_current_length This is only called when it is known that the
1521*e4b17023SJohn Marino insn has a variable length and returns the
1522*e4b17023SJohn Marino current length, based on relative addresses.
1523*e4b17023SJohn Marino */
1524*e4b17023SJohn Marino
1525*e4b17023SJohn Marino static void
make_length_attrs(void)1526*e4b17023SJohn Marino make_length_attrs (void)
1527*e4b17023SJohn Marino {
1528*e4b17023SJohn Marino static const char *new_names[] =
1529*e4b17023SJohn Marino {
1530*e4b17023SJohn Marino "*insn_default_length",
1531*e4b17023SJohn Marino "*insn_min_length",
1532*e4b17023SJohn Marino "*insn_variable_length_p",
1533*e4b17023SJohn Marino "*insn_current_length"
1534*e4b17023SJohn Marino };
1535*e4b17023SJohn Marino static rtx (*const no_address_fn[]) (rtx)
1536*e4b17023SJohn Marino = {identity_fn,identity_fn, zero_fn, zero_fn};
1537*e4b17023SJohn Marino static rtx (*const address_fn[]) (rtx)
1538*e4b17023SJohn Marino = {max_fn, min_fn, one_fn, identity_fn};
1539*e4b17023SJohn Marino size_t i;
1540*e4b17023SJohn Marino struct attr_desc *length_attr, *new_attr;
1541*e4b17023SJohn Marino struct attr_value *av, *new_av;
1542*e4b17023SJohn Marino struct insn_ent *ie, *new_ie;
1543*e4b17023SJohn Marino
1544*e4b17023SJohn Marino /* See if length attribute is defined. If so, it must be numeric. Make
1545*e4b17023SJohn Marino it special so we don't output anything for it. */
1546*e4b17023SJohn Marino length_attr = find_attr (&length_str, 0);
1547*e4b17023SJohn Marino if (length_attr == 0)
1548*e4b17023SJohn Marino return;
1549*e4b17023SJohn Marino
1550*e4b17023SJohn Marino if (! length_attr->is_numeric)
1551*e4b17023SJohn Marino fatal ("length attribute must be numeric");
1552*e4b17023SJohn Marino
1553*e4b17023SJohn Marino length_attr->is_const = 0;
1554*e4b17023SJohn Marino length_attr->is_special = 1;
1555*e4b17023SJohn Marino
1556*e4b17023SJohn Marino /* Make each new attribute, in turn. */
1557*e4b17023SJohn Marino for (i = 0; i < ARRAY_SIZE (new_names); i++)
1558*e4b17023SJohn Marino {
1559*e4b17023SJohn Marino make_internal_attr (new_names[i],
1560*e4b17023SJohn Marino substitute_address (length_attr->default_val->value,
1561*e4b17023SJohn Marino no_address_fn[i], address_fn[i]),
1562*e4b17023SJohn Marino ATTR_NONE);
1563*e4b17023SJohn Marino new_attr = find_attr (&new_names[i], 0);
1564*e4b17023SJohn Marino for (av = length_attr->first_value; av; av = av->next)
1565*e4b17023SJohn Marino for (ie = av->first_insn; ie; ie = ie->next)
1566*e4b17023SJohn Marino {
1567*e4b17023SJohn Marino new_av = get_attr_value (substitute_address (av->value,
1568*e4b17023SJohn Marino no_address_fn[i],
1569*e4b17023SJohn Marino address_fn[i]),
1570*e4b17023SJohn Marino new_attr, ie->def->insn_code);
1571*e4b17023SJohn Marino new_ie = oballoc (struct insn_ent);
1572*e4b17023SJohn Marino new_ie->def = ie->def;
1573*e4b17023SJohn Marino insert_insn_ent (new_av, new_ie);
1574*e4b17023SJohn Marino }
1575*e4b17023SJohn Marino }
1576*e4b17023SJohn Marino }
1577*e4b17023SJohn Marino
1578*e4b17023SJohn Marino /* Utility functions called from above routine. */
1579*e4b17023SJohn Marino
1580*e4b17023SJohn Marino static rtx
identity_fn(rtx exp)1581*e4b17023SJohn Marino identity_fn (rtx exp)
1582*e4b17023SJohn Marino {
1583*e4b17023SJohn Marino return exp;
1584*e4b17023SJohn Marino }
1585*e4b17023SJohn Marino
1586*e4b17023SJohn Marino static rtx
zero_fn(rtx exp ATTRIBUTE_UNUSED)1587*e4b17023SJohn Marino zero_fn (rtx exp ATTRIBUTE_UNUSED)
1588*e4b17023SJohn Marino {
1589*e4b17023SJohn Marino return make_numeric_value (0);
1590*e4b17023SJohn Marino }
1591*e4b17023SJohn Marino
1592*e4b17023SJohn Marino static rtx
one_fn(rtx exp ATTRIBUTE_UNUSED)1593*e4b17023SJohn Marino one_fn (rtx exp ATTRIBUTE_UNUSED)
1594*e4b17023SJohn Marino {
1595*e4b17023SJohn Marino return make_numeric_value (1);
1596*e4b17023SJohn Marino }
1597*e4b17023SJohn Marino
1598*e4b17023SJohn Marino static rtx
max_fn(rtx exp)1599*e4b17023SJohn Marino max_fn (rtx exp)
1600*e4b17023SJohn Marino {
1601*e4b17023SJohn Marino int unknown;
1602*e4b17023SJohn Marino return make_numeric_value (max_attr_value (exp, &unknown));
1603*e4b17023SJohn Marino }
1604*e4b17023SJohn Marino
1605*e4b17023SJohn Marino static rtx
min_fn(rtx exp)1606*e4b17023SJohn Marino min_fn (rtx exp)
1607*e4b17023SJohn Marino {
1608*e4b17023SJohn Marino int unknown;
1609*e4b17023SJohn Marino return make_numeric_value (min_attr_value (exp, &unknown));
1610*e4b17023SJohn Marino }
1611*e4b17023SJohn Marino
1612*e4b17023SJohn Marino static void
write_length_unit_log(void)1613*e4b17023SJohn Marino write_length_unit_log (void)
1614*e4b17023SJohn Marino {
1615*e4b17023SJohn Marino struct attr_desc *length_attr = find_attr (&length_str, 0);
1616*e4b17023SJohn Marino struct attr_value *av;
1617*e4b17023SJohn Marino struct insn_ent *ie;
1618*e4b17023SJohn Marino unsigned int length_unit_log, length_or;
1619*e4b17023SJohn Marino int unknown = 0;
1620*e4b17023SJohn Marino
1621*e4b17023SJohn Marino if (length_attr == 0)
1622*e4b17023SJohn Marino return;
1623*e4b17023SJohn Marino length_or = or_attr_value (length_attr->default_val->value, &unknown);
1624*e4b17023SJohn Marino for (av = length_attr->first_value; av; av = av->next)
1625*e4b17023SJohn Marino for (ie = av->first_insn; ie; ie = ie->next)
1626*e4b17023SJohn Marino length_or |= or_attr_value (av->value, &unknown);
1627*e4b17023SJohn Marino
1628*e4b17023SJohn Marino if (unknown)
1629*e4b17023SJohn Marino length_unit_log = 0;
1630*e4b17023SJohn Marino else
1631*e4b17023SJohn Marino {
1632*e4b17023SJohn Marino length_or = ~length_or;
1633*e4b17023SJohn Marino for (length_unit_log = 0; length_or & 1; length_or >>= 1)
1634*e4b17023SJohn Marino length_unit_log++;
1635*e4b17023SJohn Marino }
1636*e4b17023SJohn Marino printf ("EXPORTED_CONST int length_unit_log = %u;\n", length_unit_log);
1637*e4b17023SJohn Marino }
1638*e4b17023SJohn Marino
1639*e4b17023SJohn Marino /* Take a COND expression and see if any of the conditions in it can be
1640*e4b17023SJohn Marino simplified. If any are known true or known false for the particular insn
1641*e4b17023SJohn Marino code, the COND can be further simplified.
1642*e4b17023SJohn Marino
1643*e4b17023SJohn Marino Also call ourselves on any COND operations that are values of this COND.
1644*e4b17023SJohn Marino
1645*e4b17023SJohn Marino We do not modify EXP; rather, we make and return a new rtx. */
1646*e4b17023SJohn Marino
1647*e4b17023SJohn Marino static rtx
simplify_cond(rtx exp,int insn_code,int insn_index)1648*e4b17023SJohn Marino simplify_cond (rtx exp, int insn_code, int insn_index)
1649*e4b17023SJohn Marino {
1650*e4b17023SJohn Marino int i, j;
1651*e4b17023SJohn Marino /* We store the desired contents here,
1652*e4b17023SJohn Marino then build a new expression if they don't match EXP. */
1653*e4b17023SJohn Marino rtx defval = XEXP (exp, 1);
1654*e4b17023SJohn Marino rtx new_defval = XEXP (exp, 1);
1655*e4b17023SJohn Marino int len = XVECLEN (exp, 0);
1656*e4b17023SJohn Marino rtx *tests = XNEWVEC (rtx, len);
1657*e4b17023SJohn Marino int allsame = 1;
1658*e4b17023SJohn Marino rtx ret;
1659*e4b17023SJohn Marino
1660*e4b17023SJohn Marino /* This lets us free all storage allocated below, if appropriate. */
1661*e4b17023SJohn Marino obstack_finish (rtl_obstack);
1662*e4b17023SJohn Marino
1663*e4b17023SJohn Marino memcpy (tests, XVEC (exp, 0)->elem, len * sizeof (rtx));
1664*e4b17023SJohn Marino
1665*e4b17023SJohn Marino /* See if default value needs simplification. */
1666*e4b17023SJohn Marino if (GET_CODE (defval) == COND)
1667*e4b17023SJohn Marino new_defval = simplify_cond (defval, insn_code, insn_index);
1668*e4b17023SJohn Marino
1669*e4b17023SJohn Marino /* Simplify the subexpressions, and see what tests we can get rid of. */
1670*e4b17023SJohn Marino
1671*e4b17023SJohn Marino for (i = 0; i < len; i += 2)
1672*e4b17023SJohn Marino {
1673*e4b17023SJohn Marino rtx newtest, newval;
1674*e4b17023SJohn Marino
1675*e4b17023SJohn Marino /* Simplify this test. */
1676*e4b17023SJohn Marino newtest = simplify_test_exp_in_temp (tests[i], insn_code, insn_index);
1677*e4b17023SJohn Marino tests[i] = newtest;
1678*e4b17023SJohn Marino
1679*e4b17023SJohn Marino newval = tests[i + 1];
1680*e4b17023SJohn Marino /* See if this value may need simplification. */
1681*e4b17023SJohn Marino if (GET_CODE (newval) == COND)
1682*e4b17023SJohn Marino newval = simplify_cond (newval, insn_code, insn_index);
1683*e4b17023SJohn Marino
1684*e4b17023SJohn Marino /* Look for ways to delete or combine this test. */
1685*e4b17023SJohn Marino if (newtest == true_rtx)
1686*e4b17023SJohn Marino {
1687*e4b17023SJohn Marino /* If test is true, make this value the default
1688*e4b17023SJohn Marino and discard this + any following tests. */
1689*e4b17023SJohn Marino len = i;
1690*e4b17023SJohn Marino defval = tests[i + 1];
1691*e4b17023SJohn Marino new_defval = newval;
1692*e4b17023SJohn Marino }
1693*e4b17023SJohn Marino
1694*e4b17023SJohn Marino else if (newtest == false_rtx)
1695*e4b17023SJohn Marino {
1696*e4b17023SJohn Marino /* If test is false, discard it and its value. */
1697*e4b17023SJohn Marino for (j = i; j < len - 2; j++)
1698*e4b17023SJohn Marino tests[j] = tests[j + 2];
1699*e4b17023SJohn Marino i -= 2;
1700*e4b17023SJohn Marino len -= 2;
1701*e4b17023SJohn Marino }
1702*e4b17023SJohn Marino
1703*e4b17023SJohn Marino else if (i > 0 && attr_equal_p (newval, tests[i - 1]))
1704*e4b17023SJohn Marino {
1705*e4b17023SJohn Marino /* If this value and the value for the prev test are the same,
1706*e4b17023SJohn Marino merge the tests. */
1707*e4b17023SJohn Marino
1708*e4b17023SJohn Marino tests[i - 2]
1709*e4b17023SJohn Marino = insert_right_side (IOR, tests[i - 2], newtest,
1710*e4b17023SJohn Marino insn_code, insn_index);
1711*e4b17023SJohn Marino
1712*e4b17023SJohn Marino /* Delete this test/value. */
1713*e4b17023SJohn Marino for (j = i; j < len - 2; j++)
1714*e4b17023SJohn Marino tests[j] = tests[j + 2];
1715*e4b17023SJohn Marino len -= 2;
1716*e4b17023SJohn Marino i -= 2;
1717*e4b17023SJohn Marino }
1718*e4b17023SJohn Marino
1719*e4b17023SJohn Marino else
1720*e4b17023SJohn Marino tests[i + 1] = newval;
1721*e4b17023SJohn Marino }
1722*e4b17023SJohn Marino
1723*e4b17023SJohn Marino /* If the last test in a COND has the same value
1724*e4b17023SJohn Marino as the default value, that test isn't needed. */
1725*e4b17023SJohn Marino
1726*e4b17023SJohn Marino while (len > 0 && attr_equal_p (tests[len - 1], new_defval))
1727*e4b17023SJohn Marino len -= 2;
1728*e4b17023SJohn Marino
1729*e4b17023SJohn Marino /* See if we changed anything. */
1730*e4b17023SJohn Marino if (len != XVECLEN (exp, 0) || new_defval != XEXP (exp, 1))
1731*e4b17023SJohn Marino allsame = 0;
1732*e4b17023SJohn Marino else
1733*e4b17023SJohn Marino for (i = 0; i < len; i++)
1734*e4b17023SJohn Marino if (! attr_equal_p (tests[i], XVECEXP (exp, 0, i)))
1735*e4b17023SJohn Marino {
1736*e4b17023SJohn Marino allsame = 0;
1737*e4b17023SJohn Marino break;
1738*e4b17023SJohn Marino }
1739*e4b17023SJohn Marino
1740*e4b17023SJohn Marino if (len == 0)
1741*e4b17023SJohn Marino {
1742*e4b17023SJohn Marino if (GET_CODE (defval) == COND)
1743*e4b17023SJohn Marino ret = simplify_cond (defval, insn_code, insn_index);
1744*e4b17023SJohn Marino else
1745*e4b17023SJohn Marino ret = defval;
1746*e4b17023SJohn Marino }
1747*e4b17023SJohn Marino else if (allsame)
1748*e4b17023SJohn Marino ret = exp;
1749*e4b17023SJohn Marino else
1750*e4b17023SJohn Marino {
1751*e4b17023SJohn Marino rtx newexp = rtx_alloc (COND);
1752*e4b17023SJohn Marino
1753*e4b17023SJohn Marino XVEC (newexp, 0) = rtvec_alloc (len);
1754*e4b17023SJohn Marino memcpy (XVEC (newexp, 0)->elem, tests, len * sizeof (rtx));
1755*e4b17023SJohn Marino XEXP (newexp, 1) = new_defval;
1756*e4b17023SJohn Marino ret = newexp;
1757*e4b17023SJohn Marino }
1758*e4b17023SJohn Marino free (tests);
1759*e4b17023SJohn Marino return ret;
1760*e4b17023SJohn Marino }
1761*e4b17023SJohn Marino
1762*e4b17023SJohn Marino /* Remove an insn entry from an attribute value. */
1763*e4b17023SJohn Marino
1764*e4b17023SJohn Marino static void
remove_insn_ent(struct attr_value * av,struct insn_ent * ie)1765*e4b17023SJohn Marino remove_insn_ent (struct attr_value *av, struct insn_ent *ie)
1766*e4b17023SJohn Marino {
1767*e4b17023SJohn Marino struct insn_ent *previe;
1768*e4b17023SJohn Marino
1769*e4b17023SJohn Marino if (av->first_insn == ie)
1770*e4b17023SJohn Marino av->first_insn = ie->next;
1771*e4b17023SJohn Marino else
1772*e4b17023SJohn Marino {
1773*e4b17023SJohn Marino for (previe = av->first_insn; previe->next != ie; previe = previe->next)
1774*e4b17023SJohn Marino ;
1775*e4b17023SJohn Marino previe->next = ie->next;
1776*e4b17023SJohn Marino }
1777*e4b17023SJohn Marino
1778*e4b17023SJohn Marino av->num_insns--;
1779*e4b17023SJohn Marino if (ie->def->insn_code == -1)
1780*e4b17023SJohn Marino av->has_asm_insn = 0;
1781*e4b17023SJohn Marino
1782*e4b17023SJohn Marino num_insn_ents--;
1783*e4b17023SJohn Marino }
1784*e4b17023SJohn Marino
1785*e4b17023SJohn Marino /* Insert an insn entry in an attribute value list. */
1786*e4b17023SJohn Marino
1787*e4b17023SJohn Marino static void
insert_insn_ent(struct attr_value * av,struct insn_ent * ie)1788*e4b17023SJohn Marino insert_insn_ent (struct attr_value *av, struct insn_ent *ie)
1789*e4b17023SJohn Marino {
1790*e4b17023SJohn Marino ie->next = av->first_insn;
1791*e4b17023SJohn Marino av->first_insn = ie;
1792*e4b17023SJohn Marino av->num_insns++;
1793*e4b17023SJohn Marino if (ie->def->insn_code == -1)
1794*e4b17023SJohn Marino av->has_asm_insn = 1;
1795*e4b17023SJohn Marino
1796*e4b17023SJohn Marino num_insn_ents++;
1797*e4b17023SJohn Marino }
1798*e4b17023SJohn Marino
1799*e4b17023SJohn Marino /* This is a utility routine to take an expression that is a tree of either
1800*e4b17023SJohn Marino AND or IOR expressions and insert a new term. The new term will be
1801*e4b17023SJohn Marino inserted at the right side of the first node whose code does not match
1802*e4b17023SJohn Marino the root. A new node will be created with the root's code. Its left
1803*e4b17023SJohn Marino side will be the old right side and its right side will be the new
1804*e4b17023SJohn Marino term.
1805*e4b17023SJohn Marino
1806*e4b17023SJohn Marino If the `term' is itself a tree, all its leaves will be inserted. */
1807*e4b17023SJohn Marino
1808*e4b17023SJohn Marino static rtx
insert_right_side(enum rtx_code code,rtx exp,rtx term,int insn_code,int insn_index)1809*e4b17023SJohn Marino insert_right_side (enum rtx_code code, rtx exp, rtx term, int insn_code, int insn_index)
1810*e4b17023SJohn Marino {
1811*e4b17023SJohn Marino rtx newexp;
1812*e4b17023SJohn Marino
1813*e4b17023SJohn Marino /* Avoid consing in some special cases. */
1814*e4b17023SJohn Marino if (code == AND && term == true_rtx)
1815*e4b17023SJohn Marino return exp;
1816*e4b17023SJohn Marino if (code == AND && term == false_rtx)
1817*e4b17023SJohn Marino return false_rtx;
1818*e4b17023SJohn Marino if (code == AND && exp == true_rtx)
1819*e4b17023SJohn Marino return term;
1820*e4b17023SJohn Marino if (code == AND && exp == false_rtx)
1821*e4b17023SJohn Marino return false_rtx;
1822*e4b17023SJohn Marino if (code == IOR && term == true_rtx)
1823*e4b17023SJohn Marino return true_rtx;
1824*e4b17023SJohn Marino if (code == IOR && term == false_rtx)
1825*e4b17023SJohn Marino return exp;
1826*e4b17023SJohn Marino if (code == IOR && exp == true_rtx)
1827*e4b17023SJohn Marino return true_rtx;
1828*e4b17023SJohn Marino if (code == IOR && exp == false_rtx)
1829*e4b17023SJohn Marino return term;
1830*e4b17023SJohn Marino if (attr_equal_p (exp, term))
1831*e4b17023SJohn Marino return exp;
1832*e4b17023SJohn Marino
1833*e4b17023SJohn Marino if (GET_CODE (term) == code)
1834*e4b17023SJohn Marino {
1835*e4b17023SJohn Marino exp = insert_right_side (code, exp, XEXP (term, 0),
1836*e4b17023SJohn Marino insn_code, insn_index);
1837*e4b17023SJohn Marino exp = insert_right_side (code, exp, XEXP (term, 1),
1838*e4b17023SJohn Marino insn_code, insn_index);
1839*e4b17023SJohn Marino
1840*e4b17023SJohn Marino return exp;
1841*e4b17023SJohn Marino }
1842*e4b17023SJohn Marino
1843*e4b17023SJohn Marino if (GET_CODE (exp) == code)
1844*e4b17023SJohn Marino {
1845*e4b17023SJohn Marino rtx new_rtx = insert_right_side (code, XEXP (exp, 1),
1846*e4b17023SJohn Marino term, insn_code, insn_index);
1847*e4b17023SJohn Marino if (new_rtx != XEXP (exp, 1))
1848*e4b17023SJohn Marino /* Make a copy of this expression and call recursively. */
1849*e4b17023SJohn Marino newexp = attr_rtx (code, XEXP (exp, 0), new_rtx);
1850*e4b17023SJohn Marino else
1851*e4b17023SJohn Marino newexp = exp;
1852*e4b17023SJohn Marino }
1853*e4b17023SJohn Marino else
1854*e4b17023SJohn Marino {
1855*e4b17023SJohn Marino /* Insert the new term. */
1856*e4b17023SJohn Marino newexp = attr_rtx (code, exp, term);
1857*e4b17023SJohn Marino }
1858*e4b17023SJohn Marino
1859*e4b17023SJohn Marino return simplify_test_exp_in_temp (newexp, insn_code, insn_index);
1860*e4b17023SJohn Marino }
1861*e4b17023SJohn Marino
1862*e4b17023SJohn Marino /* If we have an expression which AND's a bunch of
1863*e4b17023SJohn Marino (not (eq_attrq "alternative" "n"))
1864*e4b17023SJohn Marino terms, we may have covered all or all but one of the possible alternatives.
1865*e4b17023SJohn Marino If so, we can optimize. Similarly for IOR's of EQ_ATTR.
1866*e4b17023SJohn Marino
1867*e4b17023SJohn Marino This routine is passed an expression and either AND or IOR. It returns a
1868*e4b17023SJohn Marino bitmask indicating which alternatives are mentioned within EXP. */
1869*e4b17023SJohn Marino
1870*e4b17023SJohn Marino static int
compute_alternative_mask(rtx exp,enum rtx_code code)1871*e4b17023SJohn Marino compute_alternative_mask (rtx exp, enum rtx_code code)
1872*e4b17023SJohn Marino {
1873*e4b17023SJohn Marino const char *string;
1874*e4b17023SJohn Marino if (GET_CODE (exp) == code)
1875*e4b17023SJohn Marino return compute_alternative_mask (XEXP (exp, 0), code)
1876*e4b17023SJohn Marino | compute_alternative_mask (XEXP (exp, 1), code);
1877*e4b17023SJohn Marino
1878*e4b17023SJohn Marino else if (code == AND && GET_CODE (exp) == NOT
1879*e4b17023SJohn Marino && GET_CODE (XEXP (exp, 0)) == EQ_ATTR
1880*e4b17023SJohn Marino && XSTR (XEXP (exp, 0), 0) == alternative_name)
1881*e4b17023SJohn Marino string = XSTR (XEXP (exp, 0), 1);
1882*e4b17023SJohn Marino
1883*e4b17023SJohn Marino else if (code == IOR && GET_CODE (exp) == EQ_ATTR
1884*e4b17023SJohn Marino && XSTR (exp, 0) == alternative_name)
1885*e4b17023SJohn Marino string = XSTR (exp, 1);
1886*e4b17023SJohn Marino
1887*e4b17023SJohn Marino else if (GET_CODE (exp) == EQ_ATTR_ALT)
1888*e4b17023SJohn Marino {
1889*e4b17023SJohn Marino if (code == AND && XINT (exp, 1))
1890*e4b17023SJohn Marino return XINT (exp, 0);
1891*e4b17023SJohn Marino
1892*e4b17023SJohn Marino if (code == IOR && !XINT (exp, 1))
1893*e4b17023SJohn Marino return XINT (exp, 0);
1894*e4b17023SJohn Marino
1895*e4b17023SJohn Marino return 0;
1896*e4b17023SJohn Marino }
1897*e4b17023SJohn Marino else
1898*e4b17023SJohn Marino return 0;
1899*e4b17023SJohn Marino
1900*e4b17023SJohn Marino if (string[1] == 0)
1901*e4b17023SJohn Marino return 1 << (string[0] - '0');
1902*e4b17023SJohn Marino return 1 << atoi (string);
1903*e4b17023SJohn Marino }
1904*e4b17023SJohn Marino
1905*e4b17023SJohn Marino /* Given I, a single-bit mask, return RTX to compare the `alternative'
1906*e4b17023SJohn Marino attribute with the value represented by that bit. */
1907*e4b17023SJohn Marino
1908*e4b17023SJohn Marino static rtx
make_alternative_compare(int mask)1909*e4b17023SJohn Marino make_alternative_compare (int mask)
1910*e4b17023SJohn Marino {
1911*e4b17023SJohn Marino return mk_attr_alt (mask);
1912*e4b17023SJohn Marino }
1913*e4b17023SJohn Marino
1914*e4b17023SJohn Marino /* If we are processing an (eq_attr "attr" "value") test, we find the value
1915*e4b17023SJohn Marino of "attr" for this insn code. From that value, we can compute a test
1916*e4b17023SJohn Marino showing when the EQ_ATTR will be true. This routine performs that
1917*e4b17023SJohn Marino computation. If a test condition involves an address, we leave the EQ_ATTR
1918*e4b17023SJohn Marino intact because addresses are only valid for the `length' attribute.
1919*e4b17023SJohn Marino
1920*e4b17023SJohn Marino EXP is the EQ_ATTR expression and ATTR is the attribute to which
1921*e4b17023SJohn Marino it refers. VALUE is the value of that attribute for the insn
1922*e4b17023SJohn Marino corresponding to INSN_CODE and INSN_INDEX. */
1923*e4b17023SJohn Marino
1924*e4b17023SJohn Marino static rtx
evaluate_eq_attr(rtx exp,struct attr_desc * attr,rtx value,int insn_code,int insn_index)1925*e4b17023SJohn Marino evaluate_eq_attr (rtx exp, struct attr_desc *attr, rtx value,
1926*e4b17023SJohn Marino int insn_code, int insn_index)
1927*e4b17023SJohn Marino {
1928*e4b17023SJohn Marino rtx orexp, andexp;
1929*e4b17023SJohn Marino rtx right;
1930*e4b17023SJohn Marino rtx newexp;
1931*e4b17023SJohn Marino int i;
1932*e4b17023SJohn Marino
1933*e4b17023SJohn Marino while (GET_CODE (value) == ATTR)
1934*e4b17023SJohn Marino {
1935*e4b17023SJohn Marino struct attr_value *av = NULL;
1936*e4b17023SJohn Marino
1937*e4b17023SJohn Marino attr = find_attr (&XSTR (value, 0), 0);
1938*e4b17023SJohn Marino
1939*e4b17023SJohn Marino if (insn_code_values)
1940*e4b17023SJohn Marino {
1941*e4b17023SJohn Marino struct attr_value_list *iv;
1942*e4b17023SJohn Marino for (iv = insn_code_values[insn_code]; iv; iv = iv->next)
1943*e4b17023SJohn Marino if (iv->attr == attr)
1944*e4b17023SJohn Marino {
1945*e4b17023SJohn Marino av = iv->av;
1946*e4b17023SJohn Marino break;
1947*e4b17023SJohn Marino }
1948*e4b17023SJohn Marino }
1949*e4b17023SJohn Marino else
1950*e4b17023SJohn Marino {
1951*e4b17023SJohn Marino struct insn_ent *ie;
1952*e4b17023SJohn Marino for (av = attr->first_value; av; av = av->next)
1953*e4b17023SJohn Marino for (ie = av->first_insn; ie; ie = ie->next)
1954*e4b17023SJohn Marino if (ie->def->insn_code == insn_code)
1955*e4b17023SJohn Marino goto got_av;
1956*e4b17023SJohn Marino }
1957*e4b17023SJohn Marino if (av)
1958*e4b17023SJohn Marino {
1959*e4b17023SJohn Marino got_av:
1960*e4b17023SJohn Marino value = av->value;
1961*e4b17023SJohn Marino }
1962*e4b17023SJohn Marino }
1963*e4b17023SJohn Marino
1964*e4b17023SJohn Marino switch (GET_CODE (value))
1965*e4b17023SJohn Marino {
1966*e4b17023SJohn Marino case CONST_STRING:
1967*e4b17023SJohn Marino if (! strcmp_check (XSTR (value, 0), XSTR (exp, 1)))
1968*e4b17023SJohn Marino newexp = true_rtx;
1969*e4b17023SJohn Marino else
1970*e4b17023SJohn Marino newexp = false_rtx;
1971*e4b17023SJohn Marino break;
1972*e4b17023SJohn Marino
1973*e4b17023SJohn Marino case SYMBOL_REF:
1974*e4b17023SJohn Marino {
1975*e4b17023SJohn Marino const char *prefix;
1976*e4b17023SJohn Marino char *string, *p;
1977*e4b17023SJohn Marino
1978*e4b17023SJohn Marino gcc_assert (GET_CODE (exp) == EQ_ATTR);
1979*e4b17023SJohn Marino prefix = attr->enum_name ? attr->enum_name : attr->name;
1980*e4b17023SJohn Marino string = ACONCAT ((prefix, "_", XSTR (exp, 1), NULL));
1981*e4b17023SJohn Marino for (p = string; *p; p++)
1982*e4b17023SJohn Marino *p = TOUPPER (*p);
1983*e4b17023SJohn Marino
1984*e4b17023SJohn Marino newexp = attr_rtx (EQ, value,
1985*e4b17023SJohn Marino attr_rtx (SYMBOL_REF,
1986*e4b17023SJohn Marino DEF_ATTR_STRING (string)));
1987*e4b17023SJohn Marino break;
1988*e4b17023SJohn Marino }
1989*e4b17023SJohn Marino
1990*e4b17023SJohn Marino case COND:
1991*e4b17023SJohn Marino /* We construct an IOR of all the cases for which the
1992*e4b17023SJohn Marino requested attribute value is present. Since we start with
1993*e4b17023SJohn Marino FALSE, if it is not present, FALSE will be returned.
1994*e4b17023SJohn Marino
1995*e4b17023SJohn Marino Each case is the AND of the NOT's of the previous conditions with the
1996*e4b17023SJohn Marino current condition; in the default case the current condition is TRUE.
1997*e4b17023SJohn Marino
1998*e4b17023SJohn Marino For each possible COND value, call ourselves recursively.
1999*e4b17023SJohn Marino
2000*e4b17023SJohn Marino The extra TRUE and FALSE expressions will be eliminated by another
2001*e4b17023SJohn Marino call to the simplification routine. */
2002*e4b17023SJohn Marino
2003*e4b17023SJohn Marino orexp = false_rtx;
2004*e4b17023SJohn Marino andexp = true_rtx;
2005*e4b17023SJohn Marino
2006*e4b17023SJohn Marino for (i = 0; i < XVECLEN (value, 0); i += 2)
2007*e4b17023SJohn Marino {
2008*e4b17023SJohn Marino rtx this_cond = simplify_test_exp_in_temp (XVECEXP (value, 0, i),
2009*e4b17023SJohn Marino insn_code, insn_index);
2010*e4b17023SJohn Marino
2011*e4b17023SJohn Marino right = insert_right_side (AND, andexp, this_cond,
2012*e4b17023SJohn Marino insn_code, insn_index);
2013*e4b17023SJohn Marino right = insert_right_side (AND, right,
2014*e4b17023SJohn Marino evaluate_eq_attr (exp, attr,
2015*e4b17023SJohn Marino XVECEXP (value, 0,
2016*e4b17023SJohn Marino i + 1),
2017*e4b17023SJohn Marino insn_code, insn_index),
2018*e4b17023SJohn Marino insn_code, insn_index);
2019*e4b17023SJohn Marino orexp = insert_right_side (IOR, orexp, right,
2020*e4b17023SJohn Marino insn_code, insn_index);
2021*e4b17023SJohn Marino
2022*e4b17023SJohn Marino /* Add this condition into the AND expression. */
2023*e4b17023SJohn Marino newexp = attr_rtx (NOT, this_cond);
2024*e4b17023SJohn Marino andexp = insert_right_side (AND, andexp, newexp,
2025*e4b17023SJohn Marino insn_code, insn_index);
2026*e4b17023SJohn Marino }
2027*e4b17023SJohn Marino
2028*e4b17023SJohn Marino /* Handle the default case. */
2029*e4b17023SJohn Marino right = insert_right_side (AND, andexp,
2030*e4b17023SJohn Marino evaluate_eq_attr (exp, attr, XEXP (value, 1),
2031*e4b17023SJohn Marino insn_code, insn_index),
2032*e4b17023SJohn Marino insn_code, insn_index);
2033*e4b17023SJohn Marino newexp = insert_right_side (IOR, orexp, right, insn_code, insn_index);
2034*e4b17023SJohn Marino break;
2035*e4b17023SJohn Marino
2036*e4b17023SJohn Marino default:
2037*e4b17023SJohn Marino gcc_unreachable ();
2038*e4b17023SJohn Marino }
2039*e4b17023SJohn Marino
2040*e4b17023SJohn Marino /* If uses an address, must return original expression. But set the
2041*e4b17023SJohn Marino ATTR_IND_SIMPLIFIED_P bit so we don't try to simplify it again. */
2042*e4b17023SJohn Marino
2043*e4b17023SJohn Marino address_used = 0;
2044*e4b17023SJohn Marino walk_attr_value (newexp);
2045*e4b17023SJohn Marino
2046*e4b17023SJohn Marino if (address_used)
2047*e4b17023SJohn Marino {
2048*e4b17023SJohn Marino if (! ATTR_IND_SIMPLIFIED_P (exp))
2049*e4b17023SJohn Marino return copy_rtx_unchanging (exp);
2050*e4b17023SJohn Marino return exp;
2051*e4b17023SJohn Marino }
2052*e4b17023SJohn Marino else
2053*e4b17023SJohn Marino return newexp;
2054*e4b17023SJohn Marino }
2055*e4b17023SJohn Marino
2056*e4b17023SJohn Marino /* This routine is called when an AND of a term with a tree of AND's is
2057*e4b17023SJohn Marino encountered. If the term or its complement is present in the tree, it
2058*e4b17023SJohn Marino can be replaced with TRUE or FALSE, respectively.
2059*e4b17023SJohn Marino
2060*e4b17023SJohn Marino Note that (eq_attr "att" "v1") and (eq_attr "att" "v2") cannot both
2061*e4b17023SJohn Marino be true and hence are complementary.
2062*e4b17023SJohn Marino
2063*e4b17023SJohn Marino There is one special case: If we see
2064*e4b17023SJohn Marino (and (not (eq_attr "att" "v1"))
2065*e4b17023SJohn Marino (eq_attr "att" "v2"))
2066*e4b17023SJohn Marino this can be replaced by (eq_attr "att" "v2"). To do this we need to
2067*e4b17023SJohn Marino replace the term, not anything in the AND tree. So we pass a pointer to
2068*e4b17023SJohn Marino the term. */
2069*e4b17023SJohn Marino
2070*e4b17023SJohn Marino static rtx
simplify_and_tree(rtx exp,rtx * pterm,int insn_code,int insn_index)2071*e4b17023SJohn Marino simplify_and_tree (rtx exp, rtx *pterm, int insn_code, int insn_index)
2072*e4b17023SJohn Marino {
2073*e4b17023SJohn Marino rtx left, right;
2074*e4b17023SJohn Marino rtx newexp;
2075*e4b17023SJohn Marino rtx temp;
2076*e4b17023SJohn Marino int left_eliminates_term, right_eliminates_term;
2077*e4b17023SJohn Marino
2078*e4b17023SJohn Marino if (GET_CODE (exp) == AND)
2079*e4b17023SJohn Marino {
2080*e4b17023SJohn Marino left = simplify_and_tree (XEXP (exp, 0), pterm, insn_code, insn_index);
2081*e4b17023SJohn Marino right = simplify_and_tree (XEXP (exp, 1), pterm, insn_code, insn_index);
2082*e4b17023SJohn Marino if (left != XEXP (exp, 0) || right != XEXP (exp, 1))
2083*e4b17023SJohn Marino {
2084*e4b17023SJohn Marino newexp = attr_rtx (AND, left, right);
2085*e4b17023SJohn Marino
2086*e4b17023SJohn Marino exp = simplify_test_exp_in_temp (newexp, insn_code, insn_index);
2087*e4b17023SJohn Marino }
2088*e4b17023SJohn Marino }
2089*e4b17023SJohn Marino
2090*e4b17023SJohn Marino else if (GET_CODE (exp) == IOR)
2091*e4b17023SJohn Marino {
2092*e4b17023SJohn Marino /* For the IOR case, we do the same as above, except that we can
2093*e4b17023SJohn Marino only eliminate `term' if both sides of the IOR would do so. */
2094*e4b17023SJohn Marino temp = *pterm;
2095*e4b17023SJohn Marino left = simplify_and_tree (XEXP (exp, 0), &temp, insn_code, insn_index);
2096*e4b17023SJohn Marino left_eliminates_term = (temp == true_rtx);
2097*e4b17023SJohn Marino
2098*e4b17023SJohn Marino temp = *pterm;
2099*e4b17023SJohn Marino right = simplify_and_tree (XEXP (exp, 1), &temp, insn_code, insn_index);
2100*e4b17023SJohn Marino right_eliminates_term = (temp == true_rtx);
2101*e4b17023SJohn Marino
2102*e4b17023SJohn Marino if (left_eliminates_term && right_eliminates_term)
2103*e4b17023SJohn Marino *pterm = true_rtx;
2104*e4b17023SJohn Marino
2105*e4b17023SJohn Marino if (left != XEXP (exp, 0) || right != XEXP (exp, 1))
2106*e4b17023SJohn Marino {
2107*e4b17023SJohn Marino newexp = attr_rtx (IOR, left, right);
2108*e4b17023SJohn Marino
2109*e4b17023SJohn Marino exp = simplify_test_exp_in_temp (newexp, insn_code, insn_index);
2110*e4b17023SJohn Marino }
2111*e4b17023SJohn Marino }
2112*e4b17023SJohn Marino
2113*e4b17023SJohn Marino /* Check for simplifications. Do some extra checking here since this
2114*e4b17023SJohn Marino routine is called so many times. */
2115*e4b17023SJohn Marino
2116*e4b17023SJohn Marino if (exp == *pterm)
2117*e4b17023SJohn Marino return true_rtx;
2118*e4b17023SJohn Marino
2119*e4b17023SJohn Marino else if (GET_CODE (exp) == NOT && XEXP (exp, 0) == *pterm)
2120*e4b17023SJohn Marino return false_rtx;
2121*e4b17023SJohn Marino
2122*e4b17023SJohn Marino else if (GET_CODE (*pterm) == NOT && exp == XEXP (*pterm, 0))
2123*e4b17023SJohn Marino return false_rtx;
2124*e4b17023SJohn Marino
2125*e4b17023SJohn Marino else if (GET_CODE (exp) == EQ_ATTR_ALT && GET_CODE (*pterm) == EQ_ATTR_ALT)
2126*e4b17023SJohn Marino {
2127*e4b17023SJohn Marino if (attr_alt_subset_p (*pterm, exp))
2128*e4b17023SJohn Marino return true_rtx;
2129*e4b17023SJohn Marino
2130*e4b17023SJohn Marino if (attr_alt_subset_of_compl_p (*pterm, exp))
2131*e4b17023SJohn Marino return false_rtx;
2132*e4b17023SJohn Marino
2133*e4b17023SJohn Marino if (attr_alt_subset_p (exp, *pterm))
2134*e4b17023SJohn Marino *pterm = true_rtx;
2135*e4b17023SJohn Marino
2136*e4b17023SJohn Marino return exp;
2137*e4b17023SJohn Marino }
2138*e4b17023SJohn Marino
2139*e4b17023SJohn Marino else if (GET_CODE (exp) == EQ_ATTR && GET_CODE (*pterm) == EQ_ATTR)
2140*e4b17023SJohn Marino {
2141*e4b17023SJohn Marino if (XSTR (exp, 0) != XSTR (*pterm, 0))
2142*e4b17023SJohn Marino return exp;
2143*e4b17023SJohn Marino
2144*e4b17023SJohn Marino if (! strcmp_check (XSTR (exp, 1), XSTR (*pterm, 1)))
2145*e4b17023SJohn Marino return true_rtx;
2146*e4b17023SJohn Marino else
2147*e4b17023SJohn Marino return false_rtx;
2148*e4b17023SJohn Marino }
2149*e4b17023SJohn Marino
2150*e4b17023SJohn Marino else if (GET_CODE (*pterm) == EQ_ATTR && GET_CODE (exp) == NOT
2151*e4b17023SJohn Marino && GET_CODE (XEXP (exp, 0)) == EQ_ATTR)
2152*e4b17023SJohn Marino {
2153*e4b17023SJohn Marino if (XSTR (*pterm, 0) != XSTR (XEXP (exp, 0), 0))
2154*e4b17023SJohn Marino return exp;
2155*e4b17023SJohn Marino
2156*e4b17023SJohn Marino if (! strcmp_check (XSTR (*pterm, 1), XSTR (XEXP (exp, 0), 1)))
2157*e4b17023SJohn Marino return false_rtx;
2158*e4b17023SJohn Marino else
2159*e4b17023SJohn Marino return true_rtx;
2160*e4b17023SJohn Marino }
2161*e4b17023SJohn Marino
2162*e4b17023SJohn Marino else if (GET_CODE (exp) == EQ_ATTR && GET_CODE (*pterm) == NOT
2163*e4b17023SJohn Marino && GET_CODE (XEXP (*pterm, 0)) == EQ_ATTR)
2164*e4b17023SJohn Marino {
2165*e4b17023SJohn Marino if (XSTR (exp, 0) != XSTR (XEXP (*pterm, 0), 0))
2166*e4b17023SJohn Marino return exp;
2167*e4b17023SJohn Marino
2168*e4b17023SJohn Marino if (! strcmp_check (XSTR (exp, 1), XSTR (XEXP (*pterm, 0), 1)))
2169*e4b17023SJohn Marino return false_rtx;
2170*e4b17023SJohn Marino else
2171*e4b17023SJohn Marino *pterm = true_rtx;
2172*e4b17023SJohn Marino }
2173*e4b17023SJohn Marino
2174*e4b17023SJohn Marino else if (GET_CODE (exp) == NOT && GET_CODE (*pterm) == NOT)
2175*e4b17023SJohn Marino {
2176*e4b17023SJohn Marino if (attr_equal_p (XEXP (exp, 0), XEXP (*pterm, 0)))
2177*e4b17023SJohn Marino return true_rtx;
2178*e4b17023SJohn Marino }
2179*e4b17023SJohn Marino
2180*e4b17023SJohn Marino else if (GET_CODE (exp) == NOT)
2181*e4b17023SJohn Marino {
2182*e4b17023SJohn Marino if (attr_equal_p (XEXP (exp, 0), *pterm))
2183*e4b17023SJohn Marino return false_rtx;
2184*e4b17023SJohn Marino }
2185*e4b17023SJohn Marino
2186*e4b17023SJohn Marino else if (GET_CODE (*pterm) == NOT)
2187*e4b17023SJohn Marino {
2188*e4b17023SJohn Marino if (attr_equal_p (XEXP (*pterm, 0), exp))
2189*e4b17023SJohn Marino return false_rtx;
2190*e4b17023SJohn Marino }
2191*e4b17023SJohn Marino
2192*e4b17023SJohn Marino else if (attr_equal_p (exp, *pterm))
2193*e4b17023SJohn Marino return true_rtx;
2194*e4b17023SJohn Marino
2195*e4b17023SJohn Marino return exp;
2196*e4b17023SJohn Marino }
2197*e4b17023SJohn Marino
2198*e4b17023SJohn Marino /* Similar to `simplify_and_tree', but for IOR trees. */
2199*e4b17023SJohn Marino
2200*e4b17023SJohn Marino static rtx
simplify_or_tree(rtx exp,rtx * pterm,int insn_code,int insn_index)2201*e4b17023SJohn Marino simplify_or_tree (rtx exp, rtx *pterm, int insn_code, int insn_index)
2202*e4b17023SJohn Marino {
2203*e4b17023SJohn Marino rtx left, right;
2204*e4b17023SJohn Marino rtx newexp;
2205*e4b17023SJohn Marino rtx temp;
2206*e4b17023SJohn Marino int left_eliminates_term, right_eliminates_term;
2207*e4b17023SJohn Marino
2208*e4b17023SJohn Marino if (GET_CODE (exp) == IOR)
2209*e4b17023SJohn Marino {
2210*e4b17023SJohn Marino left = simplify_or_tree (XEXP (exp, 0), pterm, insn_code, insn_index);
2211*e4b17023SJohn Marino right = simplify_or_tree (XEXP (exp, 1), pterm, insn_code, insn_index);
2212*e4b17023SJohn Marino if (left != XEXP (exp, 0) || right != XEXP (exp, 1))
2213*e4b17023SJohn Marino {
2214*e4b17023SJohn Marino newexp = attr_rtx (GET_CODE (exp), left, right);
2215*e4b17023SJohn Marino
2216*e4b17023SJohn Marino exp = simplify_test_exp_in_temp (newexp, insn_code, insn_index);
2217*e4b17023SJohn Marino }
2218*e4b17023SJohn Marino }
2219*e4b17023SJohn Marino
2220*e4b17023SJohn Marino else if (GET_CODE (exp) == AND)
2221*e4b17023SJohn Marino {
2222*e4b17023SJohn Marino /* For the AND case, we do the same as above, except that we can
2223*e4b17023SJohn Marino only eliminate `term' if both sides of the AND would do so. */
2224*e4b17023SJohn Marino temp = *pterm;
2225*e4b17023SJohn Marino left = simplify_or_tree (XEXP (exp, 0), &temp, insn_code, insn_index);
2226*e4b17023SJohn Marino left_eliminates_term = (temp == false_rtx);
2227*e4b17023SJohn Marino
2228*e4b17023SJohn Marino temp = *pterm;
2229*e4b17023SJohn Marino right = simplify_or_tree (XEXP (exp, 1), &temp, insn_code, insn_index);
2230*e4b17023SJohn Marino right_eliminates_term = (temp == false_rtx);
2231*e4b17023SJohn Marino
2232*e4b17023SJohn Marino if (left_eliminates_term && right_eliminates_term)
2233*e4b17023SJohn Marino *pterm = false_rtx;
2234*e4b17023SJohn Marino
2235*e4b17023SJohn Marino if (left != XEXP (exp, 0) || right != XEXP (exp, 1))
2236*e4b17023SJohn Marino {
2237*e4b17023SJohn Marino newexp = attr_rtx (GET_CODE (exp), left, right);
2238*e4b17023SJohn Marino
2239*e4b17023SJohn Marino exp = simplify_test_exp_in_temp (newexp, insn_code, insn_index);
2240*e4b17023SJohn Marino }
2241*e4b17023SJohn Marino }
2242*e4b17023SJohn Marino
2243*e4b17023SJohn Marino if (attr_equal_p (exp, *pterm))
2244*e4b17023SJohn Marino return false_rtx;
2245*e4b17023SJohn Marino
2246*e4b17023SJohn Marino else if (GET_CODE (exp) == NOT && attr_equal_p (XEXP (exp, 0), *pterm))
2247*e4b17023SJohn Marino return true_rtx;
2248*e4b17023SJohn Marino
2249*e4b17023SJohn Marino else if (GET_CODE (*pterm) == NOT && attr_equal_p (XEXP (*pterm, 0), exp))
2250*e4b17023SJohn Marino return true_rtx;
2251*e4b17023SJohn Marino
2252*e4b17023SJohn Marino else if (GET_CODE (*pterm) == EQ_ATTR && GET_CODE (exp) == NOT
2253*e4b17023SJohn Marino && GET_CODE (XEXP (exp, 0)) == EQ_ATTR
2254*e4b17023SJohn Marino && XSTR (*pterm, 0) == XSTR (XEXP (exp, 0), 0))
2255*e4b17023SJohn Marino *pterm = false_rtx;
2256*e4b17023SJohn Marino
2257*e4b17023SJohn Marino else if (GET_CODE (exp) == EQ_ATTR && GET_CODE (*pterm) == NOT
2258*e4b17023SJohn Marino && GET_CODE (XEXP (*pterm, 0)) == EQ_ATTR
2259*e4b17023SJohn Marino && XSTR (exp, 0) == XSTR (XEXP (*pterm, 0), 0))
2260*e4b17023SJohn Marino return false_rtx;
2261*e4b17023SJohn Marino
2262*e4b17023SJohn Marino return exp;
2263*e4b17023SJohn Marino }
2264*e4b17023SJohn Marino
2265*e4b17023SJohn Marino /* Compute approximate cost of the expression. Used to decide whether
2266*e4b17023SJohn Marino expression is cheap enough for inline. */
2267*e4b17023SJohn Marino static int
attr_rtx_cost(rtx x)2268*e4b17023SJohn Marino attr_rtx_cost (rtx x)
2269*e4b17023SJohn Marino {
2270*e4b17023SJohn Marino int cost = 0;
2271*e4b17023SJohn Marino enum rtx_code code;
2272*e4b17023SJohn Marino if (!x)
2273*e4b17023SJohn Marino return 0;
2274*e4b17023SJohn Marino code = GET_CODE (x);
2275*e4b17023SJohn Marino switch (code)
2276*e4b17023SJohn Marino {
2277*e4b17023SJohn Marino case MATCH_OPERAND:
2278*e4b17023SJohn Marino if (XSTR (x, 1)[0])
2279*e4b17023SJohn Marino return 10;
2280*e4b17023SJohn Marino else
2281*e4b17023SJohn Marino return 0;
2282*e4b17023SJohn Marino
2283*e4b17023SJohn Marino case EQ_ATTR_ALT:
2284*e4b17023SJohn Marino return 0;
2285*e4b17023SJohn Marino
2286*e4b17023SJohn Marino case EQ_ATTR:
2287*e4b17023SJohn Marino /* Alternatives don't result into function call. */
2288*e4b17023SJohn Marino if (!strcmp_check (XSTR (x, 0), alternative_name))
2289*e4b17023SJohn Marino return 0;
2290*e4b17023SJohn Marino else
2291*e4b17023SJohn Marino return 5;
2292*e4b17023SJohn Marino default:
2293*e4b17023SJohn Marino {
2294*e4b17023SJohn Marino int i, j;
2295*e4b17023SJohn Marino const char *fmt = GET_RTX_FORMAT (code);
2296*e4b17023SJohn Marino for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
2297*e4b17023SJohn Marino {
2298*e4b17023SJohn Marino switch (fmt[i])
2299*e4b17023SJohn Marino {
2300*e4b17023SJohn Marino case 'V':
2301*e4b17023SJohn Marino case 'E':
2302*e4b17023SJohn Marino for (j = 0; j < XVECLEN (x, i); j++)
2303*e4b17023SJohn Marino cost += attr_rtx_cost (XVECEXP (x, i, j));
2304*e4b17023SJohn Marino break;
2305*e4b17023SJohn Marino case 'e':
2306*e4b17023SJohn Marino cost += attr_rtx_cost (XEXP (x, i));
2307*e4b17023SJohn Marino break;
2308*e4b17023SJohn Marino }
2309*e4b17023SJohn Marino }
2310*e4b17023SJohn Marino }
2311*e4b17023SJohn Marino break;
2312*e4b17023SJohn Marino }
2313*e4b17023SJohn Marino return cost;
2314*e4b17023SJohn Marino }
2315*e4b17023SJohn Marino
2316*e4b17023SJohn Marino /* Simplify test expression and use temporary obstack in order to avoid
2317*e4b17023SJohn Marino memory bloat. Use ATTR_IND_SIMPLIFIED to avoid unnecessary simplifications
2318*e4b17023SJohn Marino and avoid unnecessary copying if possible. */
2319*e4b17023SJohn Marino
2320*e4b17023SJohn Marino static rtx
simplify_test_exp_in_temp(rtx exp,int insn_code,int insn_index)2321*e4b17023SJohn Marino simplify_test_exp_in_temp (rtx exp, int insn_code, int insn_index)
2322*e4b17023SJohn Marino {
2323*e4b17023SJohn Marino rtx x;
2324*e4b17023SJohn Marino struct obstack *old;
2325*e4b17023SJohn Marino if (ATTR_IND_SIMPLIFIED_P (exp))
2326*e4b17023SJohn Marino return exp;
2327*e4b17023SJohn Marino old = rtl_obstack;
2328*e4b17023SJohn Marino rtl_obstack = temp_obstack;
2329*e4b17023SJohn Marino x = simplify_test_exp (exp, insn_code, insn_index);
2330*e4b17023SJohn Marino rtl_obstack = old;
2331*e4b17023SJohn Marino if (x == exp || rtl_obstack == temp_obstack)
2332*e4b17023SJohn Marino return x;
2333*e4b17023SJohn Marino return attr_copy_rtx (x);
2334*e4b17023SJohn Marino }
2335*e4b17023SJohn Marino
2336*e4b17023SJohn Marino /* Returns true if S1 is a subset of S2. */
2337*e4b17023SJohn Marino
2338*e4b17023SJohn Marino static bool
attr_alt_subset_p(rtx s1,rtx s2)2339*e4b17023SJohn Marino attr_alt_subset_p (rtx s1, rtx s2)
2340*e4b17023SJohn Marino {
2341*e4b17023SJohn Marino switch ((XINT (s1, 1) << 1) | XINT (s2, 1))
2342*e4b17023SJohn Marino {
2343*e4b17023SJohn Marino case (0 << 1) | 0:
2344*e4b17023SJohn Marino return !(XINT (s1, 0) &~ XINT (s2, 0));
2345*e4b17023SJohn Marino
2346*e4b17023SJohn Marino case (0 << 1) | 1:
2347*e4b17023SJohn Marino return !(XINT (s1, 0) & XINT (s2, 0));
2348*e4b17023SJohn Marino
2349*e4b17023SJohn Marino case (1 << 1) | 0:
2350*e4b17023SJohn Marino return false;
2351*e4b17023SJohn Marino
2352*e4b17023SJohn Marino case (1 << 1) | 1:
2353*e4b17023SJohn Marino return !(XINT (s2, 0) &~ XINT (s1, 0));
2354*e4b17023SJohn Marino
2355*e4b17023SJohn Marino default:
2356*e4b17023SJohn Marino gcc_unreachable ();
2357*e4b17023SJohn Marino }
2358*e4b17023SJohn Marino }
2359*e4b17023SJohn Marino
2360*e4b17023SJohn Marino /* Returns true if S1 is a subset of complement of S2. */
2361*e4b17023SJohn Marino
2362*e4b17023SJohn Marino static bool
attr_alt_subset_of_compl_p(rtx s1,rtx s2)2363*e4b17023SJohn Marino attr_alt_subset_of_compl_p (rtx s1, rtx s2)
2364*e4b17023SJohn Marino {
2365*e4b17023SJohn Marino switch ((XINT (s1, 1) << 1) | XINT (s2, 1))
2366*e4b17023SJohn Marino {
2367*e4b17023SJohn Marino case (0 << 1) | 0:
2368*e4b17023SJohn Marino return !(XINT (s1, 0) & XINT (s2, 0));
2369*e4b17023SJohn Marino
2370*e4b17023SJohn Marino case (0 << 1) | 1:
2371*e4b17023SJohn Marino return !(XINT (s1, 0) & ~XINT (s2, 0));
2372*e4b17023SJohn Marino
2373*e4b17023SJohn Marino case (1 << 1) | 0:
2374*e4b17023SJohn Marino return !(XINT (s2, 0) &~ XINT (s1, 0));
2375*e4b17023SJohn Marino
2376*e4b17023SJohn Marino case (1 << 1) | 1:
2377*e4b17023SJohn Marino return false;
2378*e4b17023SJohn Marino
2379*e4b17023SJohn Marino default:
2380*e4b17023SJohn Marino gcc_unreachable ();
2381*e4b17023SJohn Marino }
2382*e4b17023SJohn Marino }
2383*e4b17023SJohn Marino
2384*e4b17023SJohn Marino /* Return EQ_ATTR_ALT expression representing intersection of S1 and S2. */
2385*e4b17023SJohn Marino
2386*e4b17023SJohn Marino static rtx
attr_alt_intersection(rtx s1,rtx s2)2387*e4b17023SJohn Marino attr_alt_intersection (rtx s1, rtx s2)
2388*e4b17023SJohn Marino {
2389*e4b17023SJohn Marino rtx result = rtx_alloc (EQ_ATTR_ALT);
2390*e4b17023SJohn Marino
2391*e4b17023SJohn Marino switch ((XINT (s1, 1) << 1) | XINT (s2, 1))
2392*e4b17023SJohn Marino {
2393*e4b17023SJohn Marino case (0 << 1) | 0:
2394*e4b17023SJohn Marino XINT (result, 0) = XINT (s1, 0) & XINT (s2, 0);
2395*e4b17023SJohn Marino break;
2396*e4b17023SJohn Marino case (0 << 1) | 1:
2397*e4b17023SJohn Marino XINT (result, 0) = XINT (s1, 0) & ~XINT (s2, 0);
2398*e4b17023SJohn Marino break;
2399*e4b17023SJohn Marino case (1 << 1) | 0:
2400*e4b17023SJohn Marino XINT (result, 0) = XINT (s2, 0) & ~XINT (s1, 0);
2401*e4b17023SJohn Marino break;
2402*e4b17023SJohn Marino case (1 << 1) | 1:
2403*e4b17023SJohn Marino XINT (result, 0) = XINT (s1, 0) | XINT (s2, 0);
2404*e4b17023SJohn Marino break;
2405*e4b17023SJohn Marino default:
2406*e4b17023SJohn Marino gcc_unreachable ();
2407*e4b17023SJohn Marino }
2408*e4b17023SJohn Marino XINT (result, 1) = XINT (s1, 1) & XINT (s2, 1);
2409*e4b17023SJohn Marino
2410*e4b17023SJohn Marino return result;
2411*e4b17023SJohn Marino }
2412*e4b17023SJohn Marino
2413*e4b17023SJohn Marino /* Return EQ_ATTR_ALT expression representing union of S1 and S2. */
2414*e4b17023SJohn Marino
2415*e4b17023SJohn Marino static rtx
attr_alt_union(rtx s1,rtx s2)2416*e4b17023SJohn Marino attr_alt_union (rtx s1, rtx s2)
2417*e4b17023SJohn Marino {
2418*e4b17023SJohn Marino rtx result = rtx_alloc (EQ_ATTR_ALT);
2419*e4b17023SJohn Marino
2420*e4b17023SJohn Marino switch ((XINT (s1, 1) << 1) | XINT (s2, 1))
2421*e4b17023SJohn Marino {
2422*e4b17023SJohn Marino case (0 << 1) | 0:
2423*e4b17023SJohn Marino XINT (result, 0) = XINT (s1, 0) | XINT (s2, 0);
2424*e4b17023SJohn Marino break;
2425*e4b17023SJohn Marino case (0 << 1) | 1:
2426*e4b17023SJohn Marino XINT (result, 0) = XINT (s2, 0) & ~XINT (s1, 0);
2427*e4b17023SJohn Marino break;
2428*e4b17023SJohn Marino case (1 << 1) | 0:
2429*e4b17023SJohn Marino XINT (result, 0) = XINT (s1, 0) & ~XINT (s2, 0);
2430*e4b17023SJohn Marino break;
2431*e4b17023SJohn Marino case (1 << 1) | 1:
2432*e4b17023SJohn Marino XINT (result, 0) = XINT (s1, 0) & XINT (s2, 0);
2433*e4b17023SJohn Marino break;
2434*e4b17023SJohn Marino default:
2435*e4b17023SJohn Marino gcc_unreachable ();
2436*e4b17023SJohn Marino }
2437*e4b17023SJohn Marino
2438*e4b17023SJohn Marino XINT (result, 1) = XINT (s1, 1) | XINT (s2, 1);
2439*e4b17023SJohn Marino return result;
2440*e4b17023SJohn Marino }
2441*e4b17023SJohn Marino
2442*e4b17023SJohn Marino /* Return EQ_ATTR_ALT expression representing complement of S. */
2443*e4b17023SJohn Marino
2444*e4b17023SJohn Marino static rtx
attr_alt_complement(rtx s)2445*e4b17023SJohn Marino attr_alt_complement (rtx s)
2446*e4b17023SJohn Marino {
2447*e4b17023SJohn Marino rtx result = rtx_alloc (EQ_ATTR_ALT);
2448*e4b17023SJohn Marino
2449*e4b17023SJohn Marino XINT (result, 0) = XINT (s, 0);
2450*e4b17023SJohn Marino XINT (result, 1) = 1 - XINT (s, 1);
2451*e4b17023SJohn Marino
2452*e4b17023SJohn Marino return result;
2453*e4b17023SJohn Marino }
2454*e4b17023SJohn Marino
2455*e4b17023SJohn Marino /* Return EQ_ATTR_ALT expression representing set containing elements set
2456*e4b17023SJohn Marino in E. */
2457*e4b17023SJohn Marino
2458*e4b17023SJohn Marino static rtx
mk_attr_alt(int e)2459*e4b17023SJohn Marino mk_attr_alt (int e)
2460*e4b17023SJohn Marino {
2461*e4b17023SJohn Marino rtx result = rtx_alloc (EQ_ATTR_ALT);
2462*e4b17023SJohn Marino
2463*e4b17023SJohn Marino XINT (result, 0) = e;
2464*e4b17023SJohn Marino XINT (result, 1) = 0;
2465*e4b17023SJohn Marino
2466*e4b17023SJohn Marino return result;
2467*e4b17023SJohn Marino }
2468*e4b17023SJohn Marino
2469*e4b17023SJohn Marino /* Given an expression, see if it can be simplified for a particular insn
2470*e4b17023SJohn Marino code based on the values of other attributes being tested. This can
2471*e4b17023SJohn Marino eliminate nested get_attr_... calls.
2472*e4b17023SJohn Marino
2473*e4b17023SJohn Marino Note that if an endless recursion is specified in the patterns, the
2474*e4b17023SJohn Marino optimization will loop. However, it will do so in precisely the cases where
2475*e4b17023SJohn Marino an infinite recursion loop could occur during compilation. It's better that
2476*e4b17023SJohn Marino it occurs here! */
2477*e4b17023SJohn Marino
2478*e4b17023SJohn Marino static rtx
simplify_test_exp(rtx exp,int insn_code,int insn_index)2479*e4b17023SJohn Marino simplify_test_exp (rtx exp, int insn_code, int insn_index)
2480*e4b17023SJohn Marino {
2481*e4b17023SJohn Marino rtx left, right;
2482*e4b17023SJohn Marino struct attr_desc *attr;
2483*e4b17023SJohn Marino struct attr_value *av;
2484*e4b17023SJohn Marino struct insn_ent *ie;
2485*e4b17023SJohn Marino struct attr_value_list *iv;
2486*e4b17023SJohn Marino int i;
2487*e4b17023SJohn Marino rtx newexp = exp;
2488*e4b17023SJohn Marino bool left_alt, right_alt;
2489*e4b17023SJohn Marino
2490*e4b17023SJohn Marino /* Don't re-simplify something we already simplified. */
2491*e4b17023SJohn Marino if (ATTR_IND_SIMPLIFIED_P (exp) || ATTR_CURR_SIMPLIFIED_P (exp))
2492*e4b17023SJohn Marino return exp;
2493*e4b17023SJohn Marino
2494*e4b17023SJohn Marino switch (GET_CODE (exp))
2495*e4b17023SJohn Marino {
2496*e4b17023SJohn Marino case AND:
2497*e4b17023SJohn Marino left = SIMPLIFY_TEST_EXP (XEXP (exp, 0), insn_code, insn_index);
2498*e4b17023SJohn Marino if (left == false_rtx)
2499*e4b17023SJohn Marino return false_rtx;
2500*e4b17023SJohn Marino right = SIMPLIFY_TEST_EXP (XEXP (exp, 1), insn_code, insn_index);
2501*e4b17023SJohn Marino if (right == false_rtx)
2502*e4b17023SJohn Marino return false_rtx;
2503*e4b17023SJohn Marino
2504*e4b17023SJohn Marino if (GET_CODE (left) == EQ_ATTR_ALT
2505*e4b17023SJohn Marino && GET_CODE (right) == EQ_ATTR_ALT)
2506*e4b17023SJohn Marino {
2507*e4b17023SJohn Marino exp = attr_alt_intersection (left, right);
2508*e4b17023SJohn Marino return simplify_test_exp (exp, insn_code, insn_index);
2509*e4b17023SJohn Marino }
2510*e4b17023SJohn Marino
2511*e4b17023SJohn Marino /* If either side is an IOR and we have (eq_attr "alternative" ..")
2512*e4b17023SJohn Marino present on both sides, apply the distributive law since this will
2513*e4b17023SJohn Marino yield simplifications. */
2514*e4b17023SJohn Marino if ((GET_CODE (left) == IOR || GET_CODE (right) == IOR)
2515*e4b17023SJohn Marino && compute_alternative_mask (left, IOR)
2516*e4b17023SJohn Marino && compute_alternative_mask (right, IOR))
2517*e4b17023SJohn Marino {
2518*e4b17023SJohn Marino if (GET_CODE (left) == IOR)
2519*e4b17023SJohn Marino {
2520*e4b17023SJohn Marino rtx tem = left;
2521*e4b17023SJohn Marino left = right;
2522*e4b17023SJohn Marino right = tem;
2523*e4b17023SJohn Marino }
2524*e4b17023SJohn Marino
2525*e4b17023SJohn Marino newexp = attr_rtx (IOR,
2526*e4b17023SJohn Marino attr_rtx (AND, left, XEXP (right, 0)),
2527*e4b17023SJohn Marino attr_rtx (AND, left, XEXP (right, 1)));
2528*e4b17023SJohn Marino
2529*e4b17023SJohn Marino return SIMPLIFY_TEST_EXP (newexp, insn_code, insn_index);
2530*e4b17023SJohn Marino }
2531*e4b17023SJohn Marino
2532*e4b17023SJohn Marino /* Try with the term on both sides. */
2533*e4b17023SJohn Marino right = simplify_and_tree (right, &left, insn_code, insn_index);
2534*e4b17023SJohn Marino if (left == XEXP (exp, 0) && right == XEXP (exp, 1))
2535*e4b17023SJohn Marino left = simplify_and_tree (left, &right, insn_code, insn_index);
2536*e4b17023SJohn Marino
2537*e4b17023SJohn Marino if (left == false_rtx || right == false_rtx)
2538*e4b17023SJohn Marino return false_rtx;
2539*e4b17023SJohn Marino else if (left == true_rtx)
2540*e4b17023SJohn Marino {
2541*e4b17023SJohn Marino return right;
2542*e4b17023SJohn Marino }
2543*e4b17023SJohn Marino else if (right == true_rtx)
2544*e4b17023SJohn Marino {
2545*e4b17023SJohn Marino return left;
2546*e4b17023SJohn Marino }
2547*e4b17023SJohn Marino /* See if all or all but one of the insn's alternatives are specified
2548*e4b17023SJohn Marino in this tree. Optimize if so. */
2549*e4b17023SJohn Marino
2550*e4b17023SJohn Marino if (GET_CODE (left) == NOT)
2551*e4b17023SJohn Marino left_alt = (GET_CODE (XEXP (left, 0)) == EQ_ATTR
2552*e4b17023SJohn Marino && XSTR (XEXP (left, 0), 0) == alternative_name);
2553*e4b17023SJohn Marino else
2554*e4b17023SJohn Marino left_alt = (GET_CODE (left) == EQ_ATTR_ALT
2555*e4b17023SJohn Marino && XINT (left, 1));
2556*e4b17023SJohn Marino
2557*e4b17023SJohn Marino if (GET_CODE (right) == NOT)
2558*e4b17023SJohn Marino right_alt = (GET_CODE (XEXP (right, 0)) == EQ_ATTR
2559*e4b17023SJohn Marino && XSTR (XEXP (right, 0), 0) == alternative_name);
2560*e4b17023SJohn Marino else
2561*e4b17023SJohn Marino right_alt = (GET_CODE (right) == EQ_ATTR_ALT
2562*e4b17023SJohn Marino && XINT (right, 1));
2563*e4b17023SJohn Marino
2564*e4b17023SJohn Marino if (insn_code >= 0
2565*e4b17023SJohn Marino && (GET_CODE (left) == AND
2566*e4b17023SJohn Marino || left_alt
2567*e4b17023SJohn Marino || GET_CODE (right) == AND
2568*e4b17023SJohn Marino || right_alt))
2569*e4b17023SJohn Marino {
2570*e4b17023SJohn Marino i = compute_alternative_mask (exp, AND);
2571*e4b17023SJohn Marino if (i & ~insn_alternatives[insn_code])
2572*e4b17023SJohn Marino fatal ("invalid alternative specified for pattern number %d",
2573*e4b17023SJohn Marino insn_index);
2574*e4b17023SJohn Marino
2575*e4b17023SJohn Marino /* If all alternatives are excluded, this is false. */
2576*e4b17023SJohn Marino i ^= insn_alternatives[insn_code];
2577*e4b17023SJohn Marino if (i == 0)
2578*e4b17023SJohn Marino return false_rtx;
2579*e4b17023SJohn Marino else if ((i & (i - 1)) == 0 && insn_alternatives[insn_code] > 1)
2580*e4b17023SJohn Marino {
2581*e4b17023SJohn Marino /* If just one excluded, AND a comparison with that one to the
2582*e4b17023SJohn Marino front of the tree. The others will be eliminated by
2583*e4b17023SJohn Marino optimization. We do not want to do this if the insn has one
2584*e4b17023SJohn Marino alternative and we have tested none of them! */
2585*e4b17023SJohn Marino left = make_alternative_compare (i);
2586*e4b17023SJohn Marino right = simplify_and_tree (exp, &left, insn_code, insn_index);
2587*e4b17023SJohn Marino newexp = attr_rtx (AND, left, right);
2588*e4b17023SJohn Marino
2589*e4b17023SJohn Marino return SIMPLIFY_TEST_EXP (newexp, insn_code, insn_index);
2590*e4b17023SJohn Marino }
2591*e4b17023SJohn Marino }
2592*e4b17023SJohn Marino
2593*e4b17023SJohn Marino if (left != XEXP (exp, 0) || right != XEXP (exp, 1))
2594*e4b17023SJohn Marino {
2595*e4b17023SJohn Marino newexp = attr_rtx (AND, left, right);
2596*e4b17023SJohn Marino return SIMPLIFY_TEST_EXP (newexp, insn_code, insn_index);
2597*e4b17023SJohn Marino }
2598*e4b17023SJohn Marino break;
2599*e4b17023SJohn Marino
2600*e4b17023SJohn Marino case IOR:
2601*e4b17023SJohn Marino left = SIMPLIFY_TEST_EXP (XEXP (exp, 0), insn_code, insn_index);
2602*e4b17023SJohn Marino if (left == true_rtx)
2603*e4b17023SJohn Marino return true_rtx;
2604*e4b17023SJohn Marino right = SIMPLIFY_TEST_EXP (XEXP (exp, 1), insn_code, insn_index);
2605*e4b17023SJohn Marino if (right == true_rtx)
2606*e4b17023SJohn Marino return true_rtx;
2607*e4b17023SJohn Marino
2608*e4b17023SJohn Marino if (GET_CODE (left) == EQ_ATTR_ALT
2609*e4b17023SJohn Marino && GET_CODE (right) == EQ_ATTR_ALT)
2610*e4b17023SJohn Marino {
2611*e4b17023SJohn Marino exp = attr_alt_union (left, right);
2612*e4b17023SJohn Marino return simplify_test_exp (exp, insn_code, insn_index);
2613*e4b17023SJohn Marino }
2614*e4b17023SJohn Marino
2615*e4b17023SJohn Marino right = simplify_or_tree (right, &left, insn_code, insn_index);
2616*e4b17023SJohn Marino if (left == XEXP (exp, 0) && right == XEXP (exp, 1))
2617*e4b17023SJohn Marino left = simplify_or_tree (left, &right, insn_code, insn_index);
2618*e4b17023SJohn Marino
2619*e4b17023SJohn Marino if (right == true_rtx || left == true_rtx)
2620*e4b17023SJohn Marino return true_rtx;
2621*e4b17023SJohn Marino else if (left == false_rtx)
2622*e4b17023SJohn Marino {
2623*e4b17023SJohn Marino return right;
2624*e4b17023SJohn Marino }
2625*e4b17023SJohn Marino else if (right == false_rtx)
2626*e4b17023SJohn Marino {
2627*e4b17023SJohn Marino return left;
2628*e4b17023SJohn Marino }
2629*e4b17023SJohn Marino
2630*e4b17023SJohn Marino /* Test for simple cases where the distributive law is useful. I.e.,
2631*e4b17023SJohn Marino convert (ior (and (x) (y))
2632*e4b17023SJohn Marino (and (x) (z)))
2633*e4b17023SJohn Marino to (and (x)
2634*e4b17023SJohn Marino (ior (y) (z)))
2635*e4b17023SJohn Marino */
2636*e4b17023SJohn Marino
2637*e4b17023SJohn Marino else if (GET_CODE (left) == AND && GET_CODE (right) == AND
2638*e4b17023SJohn Marino && attr_equal_p (XEXP (left, 0), XEXP (right, 0)))
2639*e4b17023SJohn Marino {
2640*e4b17023SJohn Marino newexp = attr_rtx (IOR, XEXP (left, 1), XEXP (right, 1));
2641*e4b17023SJohn Marino
2642*e4b17023SJohn Marino left = XEXP (left, 0);
2643*e4b17023SJohn Marino right = newexp;
2644*e4b17023SJohn Marino newexp = attr_rtx (AND, left, right);
2645*e4b17023SJohn Marino return SIMPLIFY_TEST_EXP (newexp, insn_code, insn_index);
2646*e4b17023SJohn Marino }
2647*e4b17023SJohn Marino
2648*e4b17023SJohn Marino /* See if all or all but one of the insn's alternatives are specified
2649*e4b17023SJohn Marino in this tree. Optimize if so. */
2650*e4b17023SJohn Marino
2651*e4b17023SJohn Marino else if (insn_code >= 0
2652*e4b17023SJohn Marino && (GET_CODE (left) == IOR
2653*e4b17023SJohn Marino || (GET_CODE (left) == EQ_ATTR_ALT
2654*e4b17023SJohn Marino && !XINT (left, 1))
2655*e4b17023SJohn Marino || (GET_CODE (left) == EQ_ATTR
2656*e4b17023SJohn Marino && XSTR (left, 0) == alternative_name)
2657*e4b17023SJohn Marino || GET_CODE (right) == IOR
2658*e4b17023SJohn Marino || (GET_CODE (right) == EQ_ATTR_ALT
2659*e4b17023SJohn Marino && !XINT (right, 1))
2660*e4b17023SJohn Marino || (GET_CODE (right) == EQ_ATTR
2661*e4b17023SJohn Marino && XSTR (right, 0) == alternative_name)))
2662*e4b17023SJohn Marino {
2663*e4b17023SJohn Marino i = compute_alternative_mask (exp, IOR);
2664*e4b17023SJohn Marino if (i & ~insn_alternatives[insn_code])
2665*e4b17023SJohn Marino fatal ("invalid alternative specified for pattern number %d",
2666*e4b17023SJohn Marino insn_index);
2667*e4b17023SJohn Marino
2668*e4b17023SJohn Marino /* If all alternatives are included, this is true. */
2669*e4b17023SJohn Marino i ^= insn_alternatives[insn_code];
2670*e4b17023SJohn Marino if (i == 0)
2671*e4b17023SJohn Marino return true_rtx;
2672*e4b17023SJohn Marino else if ((i & (i - 1)) == 0 && insn_alternatives[insn_code] > 1)
2673*e4b17023SJohn Marino {
2674*e4b17023SJohn Marino /* If just one excluded, IOR a comparison with that one to the
2675*e4b17023SJohn Marino front of the tree. The others will be eliminated by
2676*e4b17023SJohn Marino optimization. We do not want to do this if the insn has one
2677*e4b17023SJohn Marino alternative and we have tested none of them! */
2678*e4b17023SJohn Marino left = make_alternative_compare (i);
2679*e4b17023SJohn Marino right = simplify_and_tree (exp, &left, insn_code, insn_index);
2680*e4b17023SJohn Marino newexp = attr_rtx (IOR, attr_rtx (NOT, left), right);
2681*e4b17023SJohn Marino
2682*e4b17023SJohn Marino return SIMPLIFY_TEST_EXP (newexp, insn_code, insn_index);
2683*e4b17023SJohn Marino }
2684*e4b17023SJohn Marino }
2685*e4b17023SJohn Marino
2686*e4b17023SJohn Marino if (left != XEXP (exp, 0) || right != XEXP (exp, 1))
2687*e4b17023SJohn Marino {
2688*e4b17023SJohn Marino newexp = attr_rtx (IOR, left, right);
2689*e4b17023SJohn Marino return SIMPLIFY_TEST_EXP (newexp, insn_code, insn_index);
2690*e4b17023SJohn Marino }
2691*e4b17023SJohn Marino break;
2692*e4b17023SJohn Marino
2693*e4b17023SJohn Marino case NOT:
2694*e4b17023SJohn Marino if (GET_CODE (XEXP (exp, 0)) == NOT)
2695*e4b17023SJohn Marino {
2696*e4b17023SJohn Marino left = SIMPLIFY_TEST_EXP (XEXP (XEXP (exp, 0), 0),
2697*e4b17023SJohn Marino insn_code, insn_index);
2698*e4b17023SJohn Marino return left;
2699*e4b17023SJohn Marino }
2700*e4b17023SJohn Marino
2701*e4b17023SJohn Marino left = SIMPLIFY_TEST_EXP (XEXP (exp, 0), insn_code, insn_index);
2702*e4b17023SJohn Marino if (GET_CODE (left) == NOT)
2703*e4b17023SJohn Marino return XEXP (left, 0);
2704*e4b17023SJohn Marino
2705*e4b17023SJohn Marino if (left == false_rtx)
2706*e4b17023SJohn Marino return true_rtx;
2707*e4b17023SJohn Marino if (left == true_rtx)
2708*e4b17023SJohn Marino return false_rtx;
2709*e4b17023SJohn Marino
2710*e4b17023SJohn Marino if (GET_CODE (left) == EQ_ATTR_ALT)
2711*e4b17023SJohn Marino {
2712*e4b17023SJohn Marino exp = attr_alt_complement (left);
2713*e4b17023SJohn Marino return simplify_test_exp (exp, insn_code, insn_index);
2714*e4b17023SJohn Marino }
2715*e4b17023SJohn Marino
2716*e4b17023SJohn Marino /* Try to apply De`Morgan's laws. */
2717*e4b17023SJohn Marino if (GET_CODE (left) == IOR)
2718*e4b17023SJohn Marino {
2719*e4b17023SJohn Marino newexp = attr_rtx (AND,
2720*e4b17023SJohn Marino attr_rtx (NOT, XEXP (left, 0)),
2721*e4b17023SJohn Marino attr_rtx (NOT, XEXP (left, 1)));
2722*e4b17023SJohn Marino
2723*e4b17023SJohn Marino newexp = SIMPLIFY_TEST_EXP (newexp, insn_code, insn_index);
2724*e4b17023SJohn Marino }
2725*e4b17023SJohn Marino else if (GET_CODE (left) == AND)
2726*e4b17023SJohn Marino {
2727*e4b17023SJohn Marino newexp = attr_rtx (IOR,
2728*e4b17023SJohn Marino attr_rtx (NOT, XEXP (left, 0)),
2729*e4b17023SJohn Marino attr_rtx (NOT, XEXP (left, 1)));
2730*e4b17023SJohn Marino
2731*e4b17023SJohn Marino newexp = SIMPLIFY_TEST_EXP (newexp, insn_code, insn_index);
2732*e4b17023SJohn Marino }
2733*e4b17023SJohn Marino else if (left != XEXP (exp, 0))
2734*e4b17023SJohn Marino {
2735*e4b17023SJohn Marino newexp = attr_rtx (NOT, left);
2736*e4b17023SJohn Marino }
2737*e4b17023SJohn Marino break;
2738*e4b17023SJohn Marino
2739*e4b17023SJohn Marino case EQ_ATTR_ALT:
2740*e4b17023SJohn Marino if (!XINT (exp, 0))
2741*e4b17023SJohn Marino return XINT (exp, 1) ? true_rtx : false_rtx;
2742*e4b17023SJohn Marino break;
2743*e4b17023SJohn Marino
2744*e4b17023SJohn Marino case EQ_ATTR:
2745*e4b17023SJohn Marino if (XSTR (exp, 0) == alternative_name)
2746*e4b17023SJohn Marino {
2747*e4b17023SJohn Marino newexp = mk_attr_alt (1 << atoi (XSTR (exp, 1)));
2748*e4b17023SJohn Marino break;
2749*e4b17023SJohn Marino }
2750*e4b17023SJohn Marino
2751*e4b17023SJohn Marino /* Look at the value for this insn code in the specified attribute.
2752*e4b17023SJohn Marino We normally can replace this comparison with the condition that
2753*e4b17023SJohn Marino would give this insn the values being tested for. */
2754*e4b17023SJohn Marino if (insn_code >= 0
2755*e4b17023SJohn Marino && (attr = find_attr (&XSTR (exp, 0), 0)) != NULL)
2756*e4b17023SJohn Marino {
2757*e4b17023SJohn Marino rtx x;
2758*e4b17023SJohn Marino
2759*e4b17023SJohn Marino av = NULL;
2760*e4b17023SJohn Marino if (insn_code_values)
2761*e4b17023SJohn Marino {
2762*e4b17023SJohn Marino for (iv = insn_code_values[insn_code]; iv; iv = iv->next)
2763*e4b17023SJohn Marino if (iv->attr == attr)
2764*e4b17023SJohn Marino {
2765*e4b17023SJohn Marino av = iv->av;
2766*e4b17023SJohn Marino break;
2767*e4b17023SJohn Marino }
2768*e4b17023SJohn Marino }
2769*e4b17023SJohn Marino else
2770*e4b17023SJohn Marino {
2771*e4b17023SJohn Marino for (av = attr->first_value; av; av = av->next)
2772*e4b17023SJohn Marino for (ie = av->first_insn; ie; ie = ie->next)
2773*e4b17023SJohn Marino if (ie->def->insn_code == insn_code)
2774*e4b17023SJohn Marino goto got_av;
2775*e4b17023SJohn Marino }
2776*e4b17023SJohn Marino
2777*e4b17023SJohn Marino if (av)
2778*e4b17023SJohn Marino {
2779*e4b17023SJohn Marino got_av:
2780*e4b17023SJohn Marino x = evaluate_eq_attr (exp, attr, av->value,
2781*e4b17023SJohn Marino insn_code, insn_index);
2782*e4b17023SJohn Marino x = SIMPLIFY_TEST_EXP (x, insn_code, insn_index);
2783*e4b17023SJohn Marino if (attr_rtx_cost(x) < 20)
2784*e4b17023SJohn Marino return x;
2785*e4b17023SJohn Marino }
2786*e4b17023SJohn Marino }
2787*e4b17023SJohn Marino break;
2788*e4b17023SJohn Marino
2789*e4b17023SJohn Marino default:
2790*e4b17023SJohn Marino break;
2791*e4b17023SJohn Marino }
2792*e4b17023SJohn Marino
2793*e4b17023SJohn Marino /* We have already simplified this expression. Simplifying it again
2794*e4b17023SJohn Marino won't buy anything unless we weren't given a valid insn code
2795*e4b17023SJohn Marino to process (i.e., we are canonicalizing something.). */
2796*e4b17023SJohn Marino if (insn_code != -2
2797*e4b17023SJohn Marino && ! ATTR_IND_SIMPLIFIED_P (newexp))
2798*e4b17023SJohn Marino return copy_rtx_unchanging (newexp);
2799*e4b17023SJohn Marino
2800*e4b17023SJohn Marino return newexp;
2801*e4b17023SJohn Marino }
2802*e4b17023SJohn Marino
2803*e4b17023SJohn Marino /* Optimize the attribute lists by seeing if we can determine conditional
2804*e4b17023SJohn Marino values from the known values of other attributes. This will save subroutine
2805*e4b17023SJohn Marino calls during the compilation. */
2806*e4b17023SJohn Marino
2807*e4b17023SJohn Marino static void
optimize_attrs(void)2808*e4b17023SJohn Marino optimize_attrs (void)
2809*e4b17023SJohn Marino {
2810*e4b17023SJohn Marino struct attr_desc *attr;
2811*e4b17023SJohn Marino struct attr_value *av;
2812*e4b17023SJohn Marino struct insn_ent *ie;
2813*e4b17023SJohn Marino rtx newexp;
2814*e4b17023SJohn Marino int i;
2815*e4b17023SJohn Marino struct attr_value_list *ivbuf;
2816*e4b17023SJohn Marino struct attr_value_list *iv;
2817*e4b17023SJohn Marino
2818*e4b17023SJohn Marino /* For each insn code, make a list of all the insn_ent's for it,
2819*e4b17023SJohn Marino for all values for all attributes. */
2820*e4b17023SJohn Marino
2821*e4b17023SJohn Marino if (num_insn_ents == 0)
2822*e4b17023SJohn Marino return;
2823*e4b17023SJohn Marino
2824*e4b17023SJohn Marino /* Make 2 extra elements, for "code" values -2 and -1. */
2825*e4b17023SJohn Marino insn_code_values = XCNEWVEC (struct attr_value_list *, insn_code_number + 2);
2826*e4b17023SJohn Marino
2827*e4b17023SJohn Marino /* Offset the table address so we can index by -2 or -1. */
2828*e4b17023SJohn Marino insn_code_values += 2;
2829*e4b17023SJohn Marino
2830*e4b17023SJohn Marino iv = ivbuf = XNEWVEC (struct attr_value_list, num_insn_ents);
2831*e4b17023SJohn Marino
2832*e4b17023SJohn Marino for (i = 0; i < MAX_ATTRS_INDEX; i++)
2833*e4b17023SJohn Marino for (attr = attrs[i]; attr; attr = attr->next)
2834*e4b17023SJohn Marino for (av = attr->first_value; av; av = av->next)
2835*e4b17023SJohn Marino for (ie = av->first_insn; ie; ie = ie->next)
2836*e4b17023SJohn Marino {
2837*e4b17023SJohn Marino iv->attr = attr;
2838*e4b17023SJohn Marino iv->av = av;
2839*e4b17023SJohn Marino iv->ie = ie;
2840*e4b17023SJohn Marino iv->next = insn_code_values[ie->def->insn_code];
2841*e4b17023SJohn Marino insn_code_values[ie->def->insn_code] = iv;
2842*e4b17023SJohn Marino iv++;
2843*e4b17023SJohn Marino }
2844*e4b17023SJohn Marino
2845*e4b17023SJohn Marino /* Sanity check on num_insn_ents. */
2846*e4b17023SJohn Marino gcc_assert (iv == ivbuf + num_insn_ents);
2847*e4b17023SJohn Marino
2848*e4b17023SJohn Marino /* Process one insn code at a time. */
2849*e4b17023SJohn Marino for (i = -2; i < insn_code_number; i++)
2850*e4b17023SJohn Marino {
2851*e4b17023SJohn Marino /* Clear the ATTR_CURR_SIMPLIFIED_P flag everywhere relevant.
2852*e4b17023SJohn Marino We use it to mean "already simplified for this insn". */
2853*e4b17023SJohn Marino for (iv = insn_code_values[i]; iv; iv = iv->next)
2854*e4b17023SJohn Marino clear_struct_flag (iv->av->value);
2855*e4b17023SJohn Marino
2856*e4b17023SJohn Marino for (iv = insn_code_values[i]; iv; iv = iv->next)
2857*e4b17023SJohn Marino {
2858*e4b17023SJohn Marino struct obstack *old = rtl_obstack;
2859*e4b17023SJohn Marino
2860*e4b17023SJohn Marino attr = iv->attr;
2861*e4b17023SJohn Marino av = iv->av;
2862*e4b17023SJohn Marino ie = iv->ie;
2863*e4b17023SJohn Marino if (GET_CODE (av->value) != COND)
2864*e4b17023SJohn Marino continue;
2865*e4b17023SJohn Marino
2866*e4b17023SJohn Marino rtl_obstack = temp_obstack;
2867*e4b17023SJohn Marino newexp = av->value;
2868*e4b17023SJohn Marino while (GET_CODE (newexp) == COND)
2869*e4b17023SJohn Marino {
2870*e4b17023SJohn Marino rtx newexp2 = simplify_cond (newexp, ie->def->insn_code,
2871*e4b17023SJohn Marino ie->def->insn_index);
2872*e4b17023SJohn Marino if (newexp2 == newexp)
2873*e4b17023SJohn Marino break;
2874*e4b17023SJohn Marino newexp = newexp2;
2875*e4b17023SJohn Marino }
2876*e4b17023SJohn Marino
2877*e4b17023SJohn Marino rtl_obstack = old;
2878*e4b17023SJohn Marino if (newexp != av->value)
2879*e4b17023SJohn Marino {
2880*e4b17023SJohn Marino newexp = attr_copy_rtx (newexp);
2881*e4b17023SJohn Marino remove_insn_ent (av, ie);
2882*e4b17023SJohn Marino av = get_attr_value (newexp, attr, ie->def->insn_code);
2883*e4b17023SJohn Marino iv->av = av;
2884*e4b17023SJohn Marino insert_insn_ent (av, ie);
2885*e4b17023SJohn Marino }
2886*e4b17023SJohn Marino }
2887*e4b17023SJohn Marino }
2888*e4b17023SJohn Marino
2889*e4b17023SJohn Marino free (ivbuf);
2890*e4b17023SJohn Marino free (insn_code_values - 2);
2891*e4b17023SJohn Marino insn_code_values = NULL;
2892*e4b17023SJohn Marino }
2893*e4b17023SJohn Marino
2894*e4b17023SJohn Marino /* Clear the ATTR_CURR_SIMPLIFIED_P flag in EXP and its subexpressions. */
2895*e4b17023SJohn Marino
2896*e4b17023SJohn Marino static void
clear_struct_flag(rtx x)2897*e4b17023SJohn Marino clear_struct_flag (rtx x)
2898*e4b17023SJohn Marino {
2899*e4b17023SJohn Marino int i;
2900*e4b17023SJohn Marino int j;
2901*e4b17023SJohn Marino enum rtx_code code;
2902*e4b17023SJohn Marino const char *fmt;
2903*e4b17023SJohn Marino
2904*e4b17023SJohn Marino ATTR_CURR_SIMPLIFIED_P (x) = 0;
2905*e4b17023SJohn Marino if (ATTR_IND_SIMPLIFIED_P (x))
2906*e4b17023SJohn Marino return;
2907*e4b17023SJohn Marino
2908*e4b17023SJohn Marino code = GET_CODE (x);
2909*e4b17023SJohn Marino
2910*e4b17023SJohn Marino switch (code)
2911*e4b17023SJohn Marino {
2912*e4b17023SJohn Marino case REG:
2913*e4b17023SJohn Marino case CONST_INT:
2914*e4b17023SJohn Marino case CONST_DOUBLE:
2915*e4b17023SJohn Marino case CONST_VECTOR:
2916*e4b17023SJohn Marino case MATCH_TEST:
2917*e4b17023SJohn Marino case SYMBOL_REF:
2918*e4b17023SJohn Marino case CODE_LABEL:
2919*e4b17023SJohn Marino case PC:
2920*e4b17023SJohn Marino case CC0:
2921*e4b17023SJohn Marino case EQ_ATTR:
2922*e4b17023SJohn Marino case ATTR_FLAG:
2923*e4b17023SJohn Marino return;
2924*e4b17023SJohn Marino
2925*e4b17023SJohn Marino default:
2926*e4b17023SJohn Marino break;
2927*e4b17023SJohn Marino }
2928*e4b17023SJohn Marino
2929*e4b17023SJohn Marino /* Compare the elements. If any pair of corresponding elements
2930*e4b17023SJohn Marino fail to match, return 0 for the whole things. */
2931*e4b17023SJohn Marino
2932*e4b17023SJohn Marino fmt = GET_RTX_FORMAT (code);
2933*e4b17023SJohn Marino for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
2934*e4b17023SJohn Marino {
2935*e4b17023SJohn Marino switch (fmt[i])
2936*e4b17023SJohn Marino {
2937*e4b17023SJohn Marino case 'V':
2938*e4b17023SJohn Marino case 'E':
2939*e4b17023SJohn Marino for (j = 0; j < XVECLEN (x, i); j++)
2940*e4b17023SJohn Marino clear_struct_flag (XVECEXP (x, i, j));
2941*e4b17023SJohn Marino break;
2942*e4b17023SJohn Marino
2943*e4b17023SJohn Marino case 'e':
2944*e4b17023SJohn Marino clear_struct_flag (XEXP (x, i));
2945*e4b17023SJohn Marino break;
2946*e4b17023SJohn Marino }
2947*e4b17023SJohn Marino }
2948*e4b17023SJohn Marino }
2949*e4b17023SJohn Marino
2950*e4b17023SJohn Marino /* Add attribute value NAME to the beginning of ATTR's list. */
2951*e4b17023SJohn Marino
2952*e4b17023SJohn Marino static void
add_attr_value(struct attr_desc * attr,const char * name)2953*e4b17023SJohn Marino add_attr_value (struct attr_desc *attr, const char *name)
2954*e4b17023SJohn Marino {
2955*e4b17023SJohn Marino struct attr_value *av;
2956*e4b17023SJohn Marino
2957*e4b17023SJohn Marino av = oballoc (struct attr_value);
2958*e4b17023SJohn Marino av->value = attr_rtx (CONST_STRING, name);
2959*e4b17023SJohn Marino av->next = attr->first_value;
2960*e4b17023SJohn Marino attr->first_value = av;
2961*e4b17023SJohn Marino av->first_insn = NULL;
2962*e4b17023SJohn Marino av->num_insns = 0;
2963*e4b17023SJohn Marino av->has_asm_insn = 0;
2964*e4b17023SJohn Marino }
2965*e4b17023SJohn Marino
2966*e4b17023SJohn Marino /* Create table entries for DEFINE_ATTR or DEFINE_ENUM_ATTR. */
2967*e4b17023SJohn Marino
2968*e4b17023SJohn Marino static void
gen_attr(rtx exp,int lineno)2969*e4b17023SJohn Marino gen_attr (rtx exp, int lineno)
2970*e4b17023SJohn Marino {
2971*e4b17023SJohn Marino struct enum_type *et;
2972*e4b17023SJohn Marino struct enum_value *ev;
2973*e4b17023SJohn Marino struct attr_desc *attr;
2974*e4b17023SJohn Marino const char *name_ptr;
2975*e4b17023SJohn Marino char *p;
2976*e4b17023SJohn Marino
2977*e4b17023SJohn Marino /* Make a new attribute structure. Check for duplicate by looking at
2978*e4b17023SJohn Marino attr->default_val, since it is initialized by this routine. */
2979*e4b17023SJohn Marino attr = find_attr (&XSTR (exp, 0), 1);
2980*e4b17023SJohn Marino if (attr->default_val)
2981*e4b17023SJohn Marino {
2982*e4b17023SJohn Marino error_with_line (lineno, "duplicate definition for attribute %s",
2983*e4b17023SJohn Marino attr->name);
2984*e4b17023SJohn Marino message_with_line (attr->lineno, "previous definition");
2985*e4b17023SJohn Marino return;
2986*e4b17023SJohn Marino }
2987*e4b17023SJohn Marino attr->lineno = lineno;
2988*e4b17023SJohn Marino
2989*e4b17023SJohn Marino if (GET_CODE (exp) == DEFINE_ENUM_ATTR)
2990*e4b17023SJohn Marino {
2991*e4b17023SJohn Marino attr->enum_name = XSTR (exp, 1);
2992*e4b17023SJohn Marino et = lookup_enum_type (XSTR (exp, 1));
2993*e4b17023SJohn Marino if (!et || !et->md_p)
2994*e4b17023SJohn Marino error_with_line (lineno, "No define_enum called `%s' defined",
2995*e4b17023SJohn Marino attr->name);
2996*e4b17023SJohn Marino for (ev = et->values; ev; ev = ev->next)
2997*e4b17023SJohn Marino add_attr_value (attr, ev->name);
2998*e4b17023SJohn Marino }
2999*e4b17023SJohn Marino else if (*XSTR (exp, 1) == '\0')
3000*e4b17023SJohn Marino attr->is_numeric = 1;
3001*e4b17023SJohn Marino else
3002*e4b17023SJohn Marino {
3003*e4b17023SJohn Marino name_ptr = XSTR (exp, 1);
3004*e4b17023SJohn Marino while ((p = next_comma_elt (&name_ptr)) != NULL)
3005*e4b17023SJohn Marino add_attr_value (attr, p);
3006*e4b17023SJohn Marino }
3007*e4b17023SJohn Marino
3008*e4b17023SJohn Marino if (GET_CODE (XEXP (exp, 2)) == CONST)
3009*e4b17023SJohn Marino {
3010*e4b17023SJohn Marino attr->is_const = 1;
3011*e4b17023SJohn Marino if (attr->is_numeric)
3012*e4b17023SJohn Marino error_with_line (lineno,
3013*e4b17023SJohn Marino "constant attributes may not take numeric values");
3014*e4b17023SJohn Marino
3015*e4b17023SJohn Marino /* Get rid of the CONST node. It is allowed only at top-level. */
3016*e4b17023SJohn Marino XEXP (exp, 2) = XEXP (XEXP (exp, 2), 0);
3017*e4b17023SJohn Marino }
3018*e4b17023SJohn Marino
3019*e4b17023SJohn Marino if (! strcmp_check (attr->name, length_str) && ! attr->is_numeric)
3020*e4b17023SJohn Marino error_with_line (lineno, "`length' attribute must take numeric values");
3021*e4b17023SJohn Marino
3022*e4b17023SJohn Marino /* Set up the default value. */
3023*e4b17023SJohn Marino XEXP (exp, 2) = check_attr_value (XEXP (exp, 2), attr);
3024*e4b17023SJohn Marino attr->default_val = get_attr_value (XEXP (exp, 2), attr, -2);
3025*e4b17023SJohn Marino }
3026*e4b17023SJohn Marino
3027*e4b17023SJohn Marino /* Given a pattern for DEFINE_PEEPHOLE or DEFINE_INSN, return the number of
3028*e4b17023SJohn Marino alternatives in the constraints. Assume all MATCH_OPERANDs have the same
3029*e4b17023SJohn Marino number of alternatives as this should be checked elsewhere. */
3030*e4b17023SJohn Marino
3031*e4b17023SJohn Marino static int
count_alternatives(rtx exp)3032*e4b17023SJohn Marino count_alternatives (rtx exp)
3033*e4b17023SJohn Marino {
3034*e4b17023SJohn Marino int i, j, n;
3035*e4b17023SJohn Marino const char *fmt;
3036*e4b17023SJohn Marino
3037*e4b17023SJohn Marino if (GET_CODE (exp) == MATCH_OPERAND)
3038*e4b17023SJohn Marino return n_comma_elts (XSTR (exp, 2));
3039*e4b17023SJohn Marino
3040*e4b17023SJohn Marino for (i = 0, fmt = GET_RTX_FORMAT (GET_CODE (exp));
3041*e4b17023SJohn Marino i < GET_RTX_LENGTH (GET_CODE (exp)); i++)
3042*e4b17023SJohn Marino switch (*fmt++)
3043*e4b17023SJohn Marino {
3044*e4b17023SJohn Marino case 'e':
3045*e4b17023SJohn Marino case 'u':
3046*e4b17023SJohn Marino n = count_alternatives (XEXP (exp, i));
3047*e4b17023SJohn Marino if (n)
3048*e4b17023SJohn Marino return n;
3049*e4b17023SJohn Marino break;
3050*e4b17023SJohn Marino
3051*e4b17023SJohn Marino case 'E':
3052*e4b17023SJohn Marino case 'V':
3053*e4b17023SJohn Marino if (XVEC (exp, i) != NULL)
3054*e4b17023SJohn Marino for (j = 0; j < XVECLEN (exp, i); j++)
3055*e4b17023SJohn Marino {
3056*e4b17023SJohn Marino n = count_alternatives (XVECEXP (exp, i, j));
3057*e4b17023SJohn Marino if (n)
3058*e4b17023SJohn Marino return n;
3059*e4b17023SJohn Marino }
3060*e4b17023SJohn Marino }
3061*e4b17023SJohn Marino
3062*e4b17023SJohn Marino return 0;
3063*e4b17023SJohn Marino }
3064*e4b17023SJohn Marino
3065*e4b17023SJohn Marino /* Returns nonzero if the given expression contains an EQ_ATTR with the
3066*e4b17023SJohn Marino `alternative' attribute. */
3067*e4b17023SJohn Marino
3068*e4b17023SJohn Marino static int
compares_alternatives_p(rtx exp)3069*e4b17023SJohn Marino compares_alternatives_p (rtx exp)
3070*e4b17023SJohn Marino {
3071*e4b17023SJohn Marino int i, j;
3072*e4b17023SJohn Marino const char *fmt;
3073*e4b17023SJohn Marino
3074*e4b17023SJohn Marino if (GET_CODE (exp) == EQ_ATTR && XSTR (exp, 0) == alternative_name)
3075*e4b17023SJohn Marino return 1;
3076*e4b17023SJohn Marino
3077*e4b17023SJohn Marino for (i = 0, fmt = GET_RTX_FORMAT (GET_CODE (exp));
3078*e4b17023SJohn Marino i < GET_RTX_LENGTH (GET_CODE (exp)); i++)
3079*e4b17023SJohn Marino switch (*fmt++)
3080*e4b17023SJohn Marino {
3081*e4b17023SJohn Marino case 'e':
3082*e4b17023SJohn Marino case 'u':
3083*e4b17023SJohn Marino if (compares_alternatives_p (XEXP (exp, i)))
3084*e4b17023SJohn Marino return 1;
3085*e4b17023SJohn Marino break;
3086*e4b17023SJohn Marino
3087*e4b17023SJohn Marino case 'E':
3088*e4b17023SJohn Marino for (j = 0; j < XVECLEN (exp, i); j++)
3089*e4b17023SJohn Marino if (compares_alternatives_p (XVECEXP (exp, i, j)))
3090*e4b17023SJohn Marino return 1;
3091*e4b17023SJohn Marino break;
3092*e4b17023SJohn Marino }
3093*e4b17023SJohn Marino
3094*e4b17023SJohn Marino return 0;
3095*e4b17023SJohn Marino }
3096*e4b17023SJohn Marino
3097*e4b17023SJohn Marino /* Process DEFINE_PEEPHOLE, DEFINE_INSN, and DEFINE_ASM_ATTRIBUTES. */
3098*e4b17023SJohn Marino
3099*e4b17023SJohn Marino static void
gen_insn(rtx exp,int lineno)3100*e4b17023SJohn Marino gen_insn (rtx exp, int lineno)
3101*e4b17023SJohn Marino {
3102*e4b17023SJohn Marino struct insn_def *id;
3103*e4b17023SJohn Marino
3104*e4b17023SJohn Marino id = oballoc (struct insn_def);
3105*e4b17023SJohn Marino id->next = defs;
3106*e4b17023SJohn Marino defs = id;
3107*e4b17023SJohn Marino id->def = exp;
3108*e4b17023SJohn Marino id->lineno = lineno;
3109*e4b17023SJohn Marino
3110*e4b17023SJohn Marino switch (GET_CODE (exp))
3111*e4b17023SJohn Marino {
3112*e4b17023SJohn Marino case DEFINE_INSN:
3113*e4b17023SJohn Marino id->insn_code = insn_code_number;
3114*e4b17023SJohn Marino id->insn_index = insn_index_number;
3115*e4b17023SJohn Marino id->num_alternatives = count_alternatives (exp);
3116*e4b17023SJohn Marino if (id->num_alternatives == 0)
3117*e4b17023SJohn Marino id->num_alternatives = 1;
3118*e4b17023SJohn Marino id->vec_idx = 4;
3119*e4b17023SJohn Marino break;
3120*e4b17023SJohn Marino
3121*e4b17023SJohn Marino case DEFINE_PEEPHOLE:
3122*e4b17023SJohn Marino id->insn_code = insn_code_number;
3123*e4b17023SJohn Marino id->insn_index = insn_index_number;
3124*e4b17023SJohn Marino id->num_alternatives = count_alternatives (exp);
3125*e4b17023SJohn Marino if (id->num_alternatives == 0)
3126*e4b17023SJohn Marino id->num_alternatives = 1;
3127*e4b17023SJohn Marino id->vec_idx = 3;
3128*e4b17023SJohn Marino break;
3129*e4b17023SJohn Marino
3130*e4b17023SJohn Marino case DEFINE_ASM_ATTRIBUTES:
3131*e4b17023SJohn Marino id->insn_code = -1;
3132*e4b17023SJohn Marino id->insn_index = -1;
3133*e4b17023SJohn Marino id->num_alternatives = 1;
3134*e4b17023SJohn Marino id->vec_idx = 0;
3135*e4b17023SJohn Marino got_define_asm_attributes = 1;
3136*e4b17023SJohn Marino break;
3137*e4b17023SJohn Marino
3138*e4b17023SJohn Marino default:
3139*e4b17023SJohn Marino gcc_unreachable ();
3140*e4b17023SJohn Marino }
3141*e4b17023SJohn Marino }
3142*e4b17023SJohn Marino
3143*e4b17023SJohn Marino /* Process a DEFINE_DELAY. Validate the vector length, check if annul
3144*e4b17023SJohn Marino true or annul false is specified, and make a `struct delay_desc'. */
3145*e4b17023SJohn Marino
3146*e4b17023SJohn Marino static void
gen_delay(rtx def,int lineno)3147*e4b17023SJohn Marino gen_delay (rtx def, int lineno)
3148*e4b17023SJohn Marino {
3149*e4b17023SJohn Marino struct delay_desc *delay;
3150*e4b17023SJohn Marino int i;
3151*e4b17023SJohn Marino
3152*e4b17023SJohn Marino if (XVECLEN (def, 1) % 3 != 0)
3153*e4b17023SJohn Marino {
3154*e4b17023SJohn Marino error_with_line (lineno,
3155*e4b17023SJohn Marino "number of elements in DEFINE_DELAY must"
3156*e4b17023SJohn Marino " be multiple of three");
3157*e4b17023SJohn Marino return;
3158*e4b17023SJohn Marino }
3159*e4b17023SJohn Marino
3160*e4b17023SJohn Marino for (i = 0; i < XVECLEN (def, 1); i += 3)
3161*e4b17023SJohn Marino {
3162*e4b17023SJohn Marino if (XVECEXP (def, 1, i + 1))
3163*e4b17023SJohn Marino have_annul_true = 1;
3164*e4b17023SJohn Marino if (XVECEXP (def, 1, i + 2))
3165*e4b17023SJohn Marino have_annul_false = 1;
3166*e4b17023SJohn Marino }
3167*e4b17023SJohn Marino
3168*e4b17023SJohn Marino delay = oballoc (struct delay_desc);
3169*e4b17023SJohn Marino delay->def = def;
3170*e4b17023SJohn Marino delay->num = ++num_delays;
3171*e4b17023SJohn Marino delay->next = delays;
3172*e4b17023SJohn Marino delay->lineno = lineno;
3173*e4b17023SJohn Marino delays = delay;
3174*e4b17023SJohn Marino }
3175*e4b17023SJohn Marino
3176*e4b17023SJohn Marino /* Names of attributes that could be possibly cached. */
3177*e4b17023SJohn Marino static const char *cached_attrs[32];
3178*e4b17023SJohn Marino /* Number of such attributes. */
3179*e4b17023SJohn Marino static int cached_attr_count;
3180*e4b17023SJohn Marino /* Bitmasks of possibly cached attributes. */
3181*e4b17023SJohn Marino static unsigned int attrs_seen_once, attrs_seen_more_than_once;
3182*e4b17023SJohn Marino static unsigned int attrs_to_cache;
3183*e4b17023SJohn Marino static unsigned int attrs_cached_inside, attrs_cached_after;
3184*e4b17023SJohn Marino
3185*e4b17023SJohn Marino /* Finds non-const attributes that could be possibly cached.
3186*e4b17023SJohn Marino When create is TRUE, fills in cached_attrs array.
3187*e4b17023SJohn Marino Computes ATTRS_SEEN_ONCE and ATTRS_SEEN_MORE_THAN_ONCE
3188*e4b17023SJohn Marino bitmasks. */
3189*e4b17023SJohn Marino
3190*e4b17023SJohn Marino static void
find_attrs_to_cache(rtx exp,bool create)3191*e4b17023SJohn Marino find_attrs_to_cache (rtx exp, bool create)
3192*e4b17023SJohn Marino {
3193*e4b17023SJohn Marino int i;
3194*e4b17023SJohn Marino const char *name;
3195*e4b17023SJohn Marino struct attr_desc *attr;
3196*e4b17023SJohn Marino
3197*e4b17023SJohn Marino if (exp == NULL)
3198*e4b17023SJohn Marino return;
3199*e4b17023SJohn Marino
3200*e4b17023SJohn Marino switch (GET_CODE (exp))
3201*e4b17023SJohn Marino {
3202*e4b17023SJohn Marino case NOT:
3203*e4b17023SJohn Marino if (GET_CODE (XEXP (exp, 0)) == EQ_ATTR)
3204*e4b17023SJohn Marino find_attrs_to_cache (XEXP (exp, 0), create);
3205*e4b17023SJohn Marino return;
3206*e4b17023SJohn Marino
3207*e4b17023SJohn Marino case EQ_ATTR:
3208*e4b17023SJohn Marino name = XSTR (exp, 0);
3209*e4b17023SJohn Marino if (name == alternative_name)
3210*e4b17023SJohn Marino return;
3211*e4b17023SJohn Marino for (i = 0; i < cached_attr_count; i++)
3212*e4b17023SJohn Marino if (name == cached_attrs[i])
3213*e4b17023SJohn Marino {
3214*e4b17023SJohn Marino if ((attrs_seen_once & (1U << i)) != 0)
3215*e4b17023SJohn Marino attrs_seen_more_than_once |= (1U << i);
3216*e4b17023SJohn Marino else
3217*e4b17023SJohn Marino attrs_seen_once |= (1U << i);
3218*e4b17023SJohn Marino return;
3219*e4b17023SJohn Marino }
3220*e4b17023SJohn Marino if (!create)
3221*e4b17023SJohn Marino return;
3222*e4b17023SJohn Marino attr = find_attr (&name, 0);
3223*e4b17023SJohn Marino gcc_assert (attr);
3224*e4b17023SJohn Marino if (attr->is_const)
3225*e4b17023SJohn Marino return;
3226*e4b17023SJohn Marino if (cached_attr_count == 32)
3227*e4b17023SJohn Marino return;
3228*e4b17023SJohn Marino cached_attrs[cached_attr_count] = XSTR (exp, 0);
3229*e4b17023SJohn Marino attrs_seen_once |= (1U << cached_attr_count);
3230*e4b17023SJohn Marino cached_attr_count++;
3231*e4b17023SJohn Marino return;
3232*e4b17023SJohn Marino
3233*e4b17023SJohn Marino case AND:
3234*e4b17023SJohn Marino case IOR:
3235*e4b17023SJohn Marino find_attrs_to_cache (XEXP (exp, 0), create);
3236*e4b17023SJohn Marino find_attrs_to_cache (XEXP (exp, 1), create);
3237*e4b17023SJohn Marino return;
3238*e4b17023SJohn Marino
3239*e4b17023SJohn Marino case COND:
3240*e4b17023SJohn Marino for (i = 0; i < XVECLEN (exp, 0); i += 2)
3241*e4b17023SJohn Marino find_attrs_to_cache (XVECEXP (exp, 0, i), create);
3242*e4b17023SJohn Marino return;
3243*e4b17023SJohn Marino
3244*e4b17023SJohn Marino default:
3245*e4b17023SJohn Marino return;
3246*e4b17023SJohn Marino }
3247*e4b17023SJohn Marino }
3248*e4b17023SJohn Marino
3249*e4b17023SJohn Marino /* Given a piece of RTX, print a C expression to test its truth value.
3250*e4b17023SJohn Marino We use AND and IOR both for logical and bit-wise operations, so
3251*e4b17023SJohn Marino interpret them as logical unless they are inside a comparison expression. */
3252*e4b17023SJohn Marino
3253*e4b17023SJohn Marino /* Interpret AND/IOR as bit-wise operations instead of logical. */
3254*e4b17023SJohn Marino #define FLG_BITWISE 1
3255*e4b17023SJohn Marino /* Set if cached attribute will be known initialized in else block after
3256*e4b17023SJohn Marino this condition. This is true for LHS of toplevel && and || and
3257*e4b17023SJohn Marino even for RHS of ||, but not for RHS of &&. */
3258*e4b17023SJohn Marino #define FLG_AFTER 2
3259*e4b17023SJohn Marino /* Set if cached attribute will be known initialized in then block after
3260*e4b17023SJohn Marino this condition. This is true for LHS of toplevel && and || and
3261*e4b17023SJohn Marino even for RHS of &&, but not for RHS of ||. */
3262*e4b17023SJohn Marino #define FLG_INSIDE 4
3263*e4b17023SJohn Marino /* Cleared when an operand of &&. */
3264*e4b17023SJohn Marino #define FLG_OUTSIDE_AND 8
3265*e4b17023SJohn Marino
3266*e4b17023SJohn Marino static unsigned int
write_test_expr(rtx exp,unsigned int attrs_cached,int flags)3267*e4b17023SJohn Marino write_test_expr (rtx exp, unsigned int attrs_cached, int flags)
3268*e4b17023SJohn Marino {
3269*e4b17023SJohn Marino int comparison_operator = 0;
3270*e4b17023SJohn Marino RTX_CODE code;
3271*e4b17023SJohn Marino struct attr_desc *attr;
3272*e4b17023SJohn Marino
3273*e4b17023SJohn Marino /* In order not to worry about operator precedence, surround our part of
3274*e4b17023SJohn Marino the expression with parentheses. */
3275*e4b17023SJohn Marino
3276*e4b17023SJohn Marino printf ("(");
3277*e4b17023SJohn Marino code = GET_CODE (exp);
3278*e4b17023SJohn Marino switch (code)
3279*e4b17023SJohn Marino {
3280*e4b17023SJohn Marino /* Binary operators. */
3281*e4b17023SJohn Marino case GEU: case GTU:
3282*e4b17023SJohn Marino case LEU: case LTU:
3283*e4b17023SJohn Marino printf ("(unsigned) ");
3284*e4b17023SJohn Marino /* Fall through. */
3285*e4b17023SJohn Marino
3286*e4b17023SJohn Marino case EQ: case NE:
3287*e4b17023SJohn Marino case GE: case GT:
3288*e4b17023SJohn Marino case LE: case LT:
3289*e4b17023SJohn Marino comparison_operator = FLG_BITWISE;
3290*e4b17023SJohn Marino
3291*e4b17023SJohn Marino case PLUS: case MINUS: case MULT: case DIV: case MOD:
3292*e4b17023SJohn Marino case AND: case IOR: case XOR:
3293*e4b17023SJohn Marino case ASHIFT: case LSHIFTRT: case ASHIFTRT:
3294*e4b17023SJohn Marino if ((code != AND && code != IOR) || (flags & FLG_BITWISE))
3295*e4b17023SJohn Marino {
3296*e4b17023SJohn Marino flags &= ~(FLG_AFTER | FLG_INSIDE | FLG_OUTSIDE_AND);
3297*e4b17023SJohn Marino write_test_expr (XEXP (exp, 0), attrs_cached,
3298*e4b17023SJohn Marino flags | comparison_operator);
3299*e4b17023SJohn Marino }
3300*e4b17023SJohn Marino else
3301*e4b17023SJohn Marino {
3302*e4b17023SJohn Marino if (code == AND)
3303*e4b17023SJohn Marino flags &= ~FLG_OUTSIDE_AND;
3304*e4b17023SJohn Marino if (GET_CODE (XEXP (exp, 0)) == code
3305*e4b17023SJohn Marino || GET_CODE (XEXP (exp, 0)) == EQ_ATTR
3306*e4b17023SJohn Marino || (GET_CODE (XEXP (exp, 0)) == NOT
3307*e4b17023SJohn Marino && GET_CODE (XEXP (XEXP (exp, 0), 0)) == EQ_ATTR))
3308*e4b17023SJohn Marino attrs_cached
3309*e4b17023SJohn Marino = write_test_expr (XEXP (exp, 0), attrs_cached, flags);
3310*e4b17023SJohn Marino else
3311*e4b17023SJohn Marino write_test_expr (XEXP (exp, 0), attrs_cached, flags);
3312*e4b17023SJohn Marino }
3313*e4b17023SJohn Marino switch (code)
3314*e4b17023SJohn Marino {
3315*e4b17023SJohn Marino case EQ:
3316*e4b17023SJohn Marino printf (" == ");
3317*e4b17023SJohn Marino break;
3318*e4b17023SJohn Marino case NE:
3319*e4b17023SJohn Marino printf (" != ");
3320*e4b17023SJohn Marino break;
3321*e4b17023SJohn Marino case GE:
3322*e4b17023SJohn Marino printf (" >= ");
3323*e4b17023SJohn Marino break;
3324*e4b17023SJohn Marino case GT:
3325*e4b17023SJohn Marino printf (" > ");
3326*e4b17023SJohn Marino break;
3327*e4b17023SJohn Marino case GEU:
3328*e4b17023SJohn Marino printf (" >= (unsigned) ");
3329*e4b17023SJohn Marino break;
3330*e4b17023SJohn Marino case GTU:
3331*e4b17023SJohn Marino printf (" > (unsigned) ");
3332*e4b17023SJohn Marino break;
3333*e4b17023SJohn Marino case LE:
3334*e4b17023SJohn Marino printf (" <= ");
3335*e4b17023SJohn Marino break;
3336*e4b17023SJohn Marino case LT:
3337*e4b17023SJohn Marino printf (" < ");
3338*e4b17023SJohn Marino break;
3339*e4b17023SJohn Marino case LEU:
3340*e4b17023SJohn Marino printf (" <= (unsigned) ");
3341*e4b17023SJohn Marino break;
3342*e4b17023SJohn Marino case LTU:
3343*e4b17023SJohn Marino printf (" < (unsigned) ");
3344*e4b17023SJohn Marino break;
3345*e4b17023SJohn Marino case PLUS:
3346*e4b17023SJohn Marino printf (" + ");
3347*e4b17023SJohn Marino break;
3348*e4b17023SJohn Marino case MINUS:
3349*e4b17023SJohn Marino printf (" - ");
3350*e4b17023SJohn Marino break;
3351*e4b17023SJohn Marino case MULT:
3352*e4b17023SJohn Marino printf (" * ");
3353*e4b17023SJohn Marino break;
3354*e4b17023SJohn Marino case DIV:
3355*e4b17023SJohn Marino printf (" / ");
3356*e4b17023SJohn Marino break;
3357*e4b17023SJohn Marino case MOD:
3358*e4b17023SJohn Marino printf (" %% ");
3359*e4b17023SJohn Marino break;
3360*e4b17023SJohn Marino case AND:
3361*e4b17023SJohn Marino if (flags & FLG_BITWISE)
3362*e4b17023SJohn Marino printf (" & ");
3363*e4b17023SJohn Marino else
3364*e4b17023SJohn Marino printf (" && ");
3365*e4b17023SJohn Marino break;
3366*e4b17023SJohn Marino case IOR:
3367*e4b17023SJohn Marino if (flags & FLG_BITWISE)
3368*e4b17023SJohn Marino printf (" | ");
3369*e4b17023SJohn Marino else
3370*e4b17023SJohn Marino printf (" || ");
3371*e4b17023SJohn Marino break;
3372*e4b17023SJohn Marino case XOR:
3373*e4b17023SJohn Marino printf (" ^ ");
3374*e4b17023SJohn Marino break;
3375*e4b17023SJohn Marino case ASHIFT:
3376*e4b17023SJohn Marino printf (" << ");
3377*e4b17023SJohn Marino break;
3378*e4b17023SJohn Marino case LSHIFTRT:
3379*e4b17023SJohn Marino case ASHIFTRT:
3380*e4b17023SJohn Marino printf (" >> ");
3381*e4b17023SJohn Marino break;
3382*e4b17023SJohn Marino default:
3383*e4b17023SJohn Marino gcc_unreachable ();
3384*e4b17023SJohn Marino }
3385*e4b17023SJohn Marino
3386*e4b17023SJohn Marino if (code == AND)
3387*e4b17023SJohn Marino {
3388*e4b17023SJohn Marino /* For if (something && (cached_x = get_attr_x (insn)) == X)
3389*e4b17023SJohn Marino cached_x is only known to be initialized in then block. */
3390*e4b17023SJohn Marino flags &= ~FLG_AFTER;
3391*e4b17023SJohn Marino }
3392*e4b17023SJohn Marino else if (code == IOR)
3393*e4b17023SJohn Marino {
3394*e4b17023SJohn Marino if (flags & FLG_OUTSIDE_AND)
3395*e4b17023SJohn Marino /* For if (something || (cached_x = get_attr_x (insn)) == X)
3396*e4b17023SJohn Marino cached_x is only known to be initialized in else block
3397*e4b17023SJohn Marino and else if conditions. */
3398*e4b17023SJohn Marino flags &= ~FLG_INSIDE;
3399*e4b17023SJohn Marino else
3400*e4b17023SJohn Marino /* For if ((something || (cached_x = get_attr_x (insn)) == X)
3401*e4b17023SJohn Marino && something_else)
3402*e4b17023SJohn Marino cached_x is not know to be initialized anywhere. */
3403*e4b17023SJohn Marino flags &= ~(FLG_AFTER | FLG_INSIDE);
3404*e4b17023SJohn Marino }
3405*e4b17023SJohn Marino if ((code == AND || code == IOR)
3406*e4b17023SJohn Marino && (GET_CODE (XEXP (exp, 1)) == code
3407*e4b17023SJohn Marino || GET_CODE (XEXP (exp, 1)) == EQ_ATTR
3408*e4b17023SJohn Marino || (GET_CODE (XEXP (exp, 1)) == NOT
3409*e4b17023SJohn Marino && GET_CODE (XEXP (XEXP (exp, 1), 0)) == EQ_ATTR)))
3410*e4b17023SJohn Marino attrs_cached
3411*e4b17023SJohn Marino = write_test_expr (XEXP (exp, 1), attrs_cached, flags);
3412*e4b17023SJohn Marino else
3413*e4b17023SJohn Marino write_test_expr (XEXP (exp, 1), attrs_cached,
3414*e4b17023SJohn Marino flags | comparison_operator);
3415*e4b17023SJohn Marino break;
3416*e4b17023SJohn Marino
3417*e4b17023SJohn Marino case NOT:
3418*e4b17023SJohn Marino /* Special-case (not (eq_attrq "alternative" "x")) */
3419*e4b17023SJohn Marino if (! (flags & FLG_BITWISE) && GET_CODE (XEXP (exp, 0)) == EQ_ATTR)
3420*e4b17023SJohn Marino {
3421*e4b17023SJohn Marino if (XSTR (XEXP (exp, 0), 0) == alternative_name)
3422*e4b17023SJohn Marino {
3423*e4b17023SJohn Marino printf ("which_alternative != %s", XSTR (XEXP (exp, 0), 1));
3424*e4b17023SJohn Marino break;
3425*e4b17023SJohn Marino }
3426*e4b17023SJohn Marino
3427*e4b17023SJohn Marino printf ("! ");
3428*e4b17023SJohn Marino attrs_cached = write_test_expr (XEXP (exp, 0), attrs_cached, flags);
3429*e4b17023SJohn Marino break;
3430*e4b17023SJohn Marino }
3431*e4b17023SJohn Marino
3432*e4b17023SJohn Marino /* Otherwise, fall through to normal unary operator. */
3433*e4b17023SJohn Marino
3434*e4b17023SJohn Marino /* Unary operators. */
3435*e4b17023SJohn Marino case ABS: case NEG:
3436*e4b17023SJohn Marino switch (code)
3437*e4b17023SJohn Marino {
3438*e4b17023SJohn Marino case NOT:
3439*e4b17023SJohn Marino if (flags & FLG_BITWISE)
3440*e4b17023SJohn Marino printf ("~ ");
3441*e4b17023SJohn Marino else
3442*e4b17023SJohn Marino printf ("! ");
3443*e4b17023SJohn Marino break;
3444*e4b17023SJohn Marino case ABS:
3445*e4b17023SJohn Marino printf ("abs ");
3446*e4b17023SJohn Marino break;
3447*e4b17023SJohn Marino case NEG:
3448*e4b17023SJohn Marino printf ("-");
3449*e4b17023SJohn Marino break;
3450*e4b17023SJohn Marino default:
3451*e4b17023SJohn Marino gcc_unreachable ();
3452*e4b17023SJohn Marino }
3453*e4b17023SJohn Marino
3454*e4b17023SJohn Marino flags &= ~(FLG_AFTER | FLG_INSIDE | FLG_OUTSIDE_AND);
3455*e4b17023SJohn Marino write_test_expr (XEXP (exp, 0), attrs_cached, flags);
3456*e4b17023SJohn Marino break;
3457*e4b17023SJohn Marino
3458*e4b17023SJohn Marino case EQ_ATTR_ALT:
3459*e4b17023SJohn Marino {
3460*e4b17023SJohn Marino int set = XINT (exp, 0), bit = 0;
3461*e4b17023SJohn Marino
3462*e4b17023SJohn Marino if (flags & FLG_BITWISE)
3463*e4b17023SJohn Marino fatal ("EQ_ATTR_ALT not valid inside comparison");
3464*e4b17023SJohn Marino
3465*e4b17023SJohn Marino if (!set)
3466*e4b17023SJohn Marino fatal ("Empty EQ_ATTR_ALT should be optimized out");
3467*e4b17023SJohn Marino
3468*e4b17023SJohn Marino if (!(set & (set - 1)))
3469*e4b17023SJohn Marino {
3470*e4b17023SJohn Marino if (!(set & 0xffff))
3471*e4b17023SJohn Marino {
3472*e4b17023SJohn Marino bit += 16;
3473*e4b17023SJohn Marino set >>= 16;
3474*e4b17023SJohn Marino }
3475*e4b17023SJohn Marino if (!(set & 0xff))
3476*e4b17023SJohn Marino {
3477*e4b17023SJohn Marino bit += 8;
3478*e4b17023SJohn Marino set >>= 8;
3479*e4b17023SJohn Marino }
3480*e4b17023SJohn Marino if (!(set & 0xf))
3481*e4b17023SJohn Marino {
3482*e4b17023SJohn Marino bit += 4;
3483*e4b17023SJohn Marino set >>= 4;
3484*e4b17023SJohn Marino }
3485*e4b17023SJohn Marino if (!(set & 0x3))
3486*e4b17023SJohn Marino {
3487*e4b17023SJohn Marino bit += 2;
3488*e4b17023SJohn Marino set >>= 2;
3489*e4b17023SJohn Marino }
3490*e4b17023SJohn Marino if (!(set & 1))
3491*e4b17023SJohn Marino bit++;
3492*e4b17023SJohn Marino
3493*e4b17023SJohn Marino printf ("which_alternative %s= %d",
3494*e4b17023SJohn Marino XINT (exp, 1) ? "!" : "=", bit);
3495*e4b17023SJohn Marino }
3496*e4b17023SJohn Marino else
3497*e4b17023SJohn Marino {
3498*e4b17023SJohn Marino printf ("%s((1 << which_alternative) & %#x)",
3499*e4b17023SJohn Marino XINT (exp, 1) ? "!" : "", set);
3500*e4b17023SJohn Marino }
3501*e4b17023SJohn Marino }
3502*e4b17023SJohn Marino break;
3503*e4b17023SJohn Marino
3504*e4b17023SJohn Marino /* Comparison test of an attribute with a value. Most of these will
3505*e4b17023SJohn Marino have been removed by optimization. Handle "alternative"
3506*e4b17023SJohn Marino specially and give error if EQ_ATTR present inside a comparison. */
3507*e4b17023SJohn Marino case EQ_ATTR:
3508*e4b17023SJohn Marino if (flags & FLG_BITWISE)
3509*e4b17023SJohn Marino fatal ("EQ_ATTR not valid inside comparison");
3510*e4b17023SJohn Marino
3511*e4b17023SJohn Marino if (XSTR (exp, 0) == alternative_name)
3512*e4b17023SJohn Marino {
3513*e4b17023SJohn Marino printf ("which_alternative == %s", XSTR (exp, 1));
3514*e4b17023SJohn Marino break;
3515*e4b17023SJohn Marino }
3516*e4b17023SJohn Marino
3517*e4b17023SJohn Marino attr = find_attr (&XSTR (exp, 0), 0);
3518*e4b17023SJohn Marino gcc_assert (attr);
3519*e4b17023SJohn Marino
3520*e4b17023SJohn Marino /* Now is the time to expand the value of a constant attribute. */
3521*e4b17023SJohn Marino if (attr->is_const)
3522*e4b17023SJohn Marino {
3523*e4b17023SJohn Marino write_test_expr (evaluate_eq_attr (exp, attr,
3524*e4b17023SJohn Marino attr->default_val->value, -2, -2),
3525*e4b17023SJohn Marino attrs_cached, 0);
3526*e4b17023SJohn Marino }
3527*e4b17023SJohn Marino else
3528*e4b17023SJohn Marino {
3529*e4b17023SJohn Marino int i;
3530*e4b17023SJohn Marino for (i = 0; i < cached_attr_count; i++)
3531*e4b17023SJohn Marino if (attr->name == cached_attrs[i])
3532*e4b17023SJohn Marino break;
3533*e4b17023SJohn Marino if (i < cached_attr_count && (attrs_cached & (1U << i)) != 0)
3534*e4b17023SJohn Marino printf ("cached_%s", attr->name);
3535*e4b17023SJohn Marino else if (i < cached_attr_count && (attrs_to_cache & (1U << i)) != 0)
3536*e4b17023SJohn Marino {
3537*e4b17023SJohn Marino printf ("(cached_%s = get_attr_%s (insn))",
3538*e4b17023SJohn Marino attr->name, attr->name);
3539*e4b17023SJohn Marino if (flags & FLG_AFTER)
3540*e4b17023SJohn Marino attrs_cached_after |= (1U << i);
3541*e4b17023SJohn Marino if (flags & FLG_INSIDE)
3542*e4b17023SJohn Marino attrs_cached_inside |= (1U << i);
3543*e4b17023SJohn Marino attrs_cached |= (1U << i);
3544*e4b17023SJohn Marino }
3545*e4b17023SJohn Marino else
3546*e4b17023SJohn Marino printf ("get_attr_%s (insn)", attr->name);
3547*e4b17023SJohn Marino printf (" == ");
3548*e4b17023SJohn Marino write_attr_valueq (attr, XSTR (exp, 1));
3549*e4b17023SJohn Marino }
3550*e4b17023SJohn Marino break;
3551*e4b17023SJohn Marino
3552*e4b17023SJohn Marino /* Comparison test of flags for define_delays. */
3553*e4b17023SJohn Marino case ATTR_FLAG:
3554*e4b17023SJohn Marino if (flags & FLG_BITWISE)
3555*e4b17023SJohn Marino fatal ("ATTR_FLAG not valid inside comparison");
3556*e4b17023SJohn Marino printf ("(flags & ATTR_FLAG_%s) != 0", XSTR (exp, 0));
3557*e4b17023SJohn Marino break;
3558*e4b17023SJohn Marino
3559*e4b17023SJohn Marino /* See if an operand matches a predicate. */
3560*e4b17023SJohn Marino case MATCH_OPERAND:
3561*e4b17023SJohn Marino /* If only a mode is given, just ensure the mode matches the operand.
3562*e4b17023SJohn Marino If neither a mode nor predicate is given, error. */
3563*e4b17023SJohn Marino if (XSTR (exp, 1) == NULL || *XSTR (exp, 1) == '\0')
3564*e4b17023SJohn Marino {
3565*e4b17023SJohn Marino if (GET_MODE (exp) == VOIDmode)
3566*e4b17023SJohn Marino fatal ("null MATCH_OPERAND specified as test");
3567*e4b17023SJohn Marino else
3568*e4b17023SJohn Marino printf ("GET_MODE (operands[%d]) == %smode",
3569*e4b17023SJohn Marino XINT (exp, 0), GET_MODE_NAME (GET_MODE (exp)));
3570*e4b17023SJohn Marino }
3571*e4b17023SJohn Marino else
3572*e4b17023SJohn Marino printf ("%s (operands[%d], %smode)",
3573*e4b17023SJohn Marino XSTR (exp, 1), XINT (exp, 0), GET_MODE_NAME (GET_MODE (exp)));
3574*e4b17023SJohn Marino break;
3575*e4b17023SJohn Marino
3576*e4b17023SJohn Marino /* Constant integer. */
3577*e4b17023SJohn Marino case CONST_INT:
3578*e4b17023SJohn Marino printf (HOST_WIDE_INT_PRINT_DEC, XWINT (exp, 0));
3579*e4b17023SJohn Marino break;
3580*e4b17023SJohn Marino
3581*e4b17023SJohn Marino case MATCH_TEST:
3582*e4b17023SJohn Marino print_c_condition (XSTR (exp, 0));
3583*e4b17023SJohn Marino if (flags & FLG_BITWISE)
3584*e4b17023SJohn Marino printf (" != 0");
3585*e4b17023SJohn Marino break;
3586*e4b17023SJohn Marino
3587*e4b17023SJohn Marino /* A random C expression. */
3588*e4b17023SJohn Marino case SYMBOL_REF:
3589*e4b17023SJohn Marino print_c_condition (XSTR (exp, 0));
3590*e4b17023SJohn Marino break;
3591*e4b17023SJohn Marino
3592*e4b17023SJohn Marino /* The address of the branch target. */
3593*e4b17023SJohn Marino case MATCH_DUP:
3594*e4b17023SJohn Marino printf ("INSN_ADDRESSES_SET_P () ? INSN_ADDRESSES (INSN_UID (GET_CODE (operands[%d]) == LABEL_REF ? XEXP (operands[%d], 0) : operands[%d])) : 0",
3595*e4b17023SJohn Marino XINT (exp, 0), XINT (exp, 0), XINT (exp, 0));
3596*e4b17023SJohn Marino break;
3597*e4b17023SJohn Marino
3598*e4b17023SJohn Marino case PC:
3599*e4b17023SJohn Marino /* The address of the current insn. We implement this actually as the
3600*e4b17023SJohn Marino address of the current insn for backward branches, but the last
3601*e4b17023SJohn Marino address of the next insn for forward branches, and both with
3602*e4b17023SJohn Marino adjustments that account for the worst-case possible stretching of
3603*e4b17023SJohn Marino intervening alignments between this insn and its destination. */
3604*e4b17023SJohn Marino printf ("insn_current_reference_address (insn)");
3605*e4b17023SJohn Marino break;
3606*e4b17023SJohn Marino
3607*e4b17023SJohn Marino case CONST_STRING:
3608*e4b17023SJohn Marino printf ("%s", XSTR (exp, 0));
3609*e4b17023SJohn Marino break;
3610*e4b17023SJohn Marino
3611*e4b17023SJohn Marino case IF_THEN_ELSE:
3612*e4b17023SJohn Marino write_test_expr (XEXP (exp, 0), attrs_cached, 0);
3613*e4b17023SJohn Marino printf (" ? ");
3614*e4b17023SJohn Marino write_test_expr (XEXP (exp, 1), attrs_cached, FLG_BITWISE);
3615*e4b17023SJohn Marino printf (" : ");
3616*e4b17023SJohn Marino write_test_expr (XEXP (exp, 2), attrs_cached, FLG_BITWISE);
3617*e4b17023SJohn Marino break;
3618*e4b17023SJohn Marino
3619*e4b17023SJohn Marino default:
3620*e4b17023SJohn Marino fatal ("bad RTX code `%s' in attribute calculation\n",
3621*e4b17023SJohn Marino GET_RTX_NAME (code));
3622*e4b17023SJohn Marino }
3623*e4b17023SJohn Marino
3624*e4b17023SJohn Marino printf (")");
3625*e4b17023SJohn Marino return attrs_cached;
3626*e4b17023SJohn Marino }
3627*e4b17023SJohn Marino
3628*e4b17023SJohn Marino /* Given an attribute value, return the maximum CONST_STRING argument
3629*e4b17023SJohn Marino encountered. Set *UNKNOWNP and return INT_MAX if the value is unknown. */
3630*e4b17023SJohn Marino
3631*e4b17023SJohn Marino static int
max_attr_value(rtx exp,int * unknownp)3632*e4b17023SJohn Marino max_attr_value (rtx exp, int *unknownp)
3633*e4b17023SJohn Marino {
3634*e4b17023SJohn Marino int current_max;
3635*e4b17023SJohn Marino int i, n;
3636*e4b17023SJohn Marino
3637*e4b17023SJohn Marino switch (GET_CODE (exp))
3638*e4b17023SJohn Marino {
3639*e4b17023SJohn Marino case CONST_STRING:
3640*e4b17023SJohn Marino current_max = atoi (XSTR (exp, 0));
3641*e4b17023SJohn Marino break;
3642*e4b17023SJohn Marino
3643*e4b17023SJohn Marino case COND:
3644*e4b17023SJohn Marino current_max = max_attr_value (XEXP (exp, 1), unknownp);
3645*e4b17023SJohn Marino for (i = 0; i < XVECLEN (exp, 0); i += 2)
3646*e4b17023SJohn Marino {
3647*e4b17023SJohn Marino n = max_attr_value (XVECEXP (exp, 0, i + 1), unknownp);
3648*e4b17023SJohn Marino if (n > current_max)
3649*e4b17023SJohn Marino current_max = n;
3650*e4b17023SJohn Marino }
3651*e4b17023SJohn Marino break;
3652*e4b17023SJohn Marino
3653*e4b17023SJohn Marino case IF_THEN_ELSE:
3654*e4b17023SJohn Marino current_max = max_attr_value (XEXP (exp, 1), unknownp);
3655*e4b17023SJohn Marino n = max_attr_value (XEXP (exp, 2), unknownp);
3656*e4b17023SJohn Marino if (n > current_max)
3657*e4b17023SJohn Marino current_max = n;
3658*e4b17023SJohn Marino break;
3659*e4b17023SJohn Marino
3660*e4b17023SJohn Marino default:
3661*e4b17023SJohn Marino *unknownp = 1;
3662*e4b17023SJohn Marino current_max = INT_MAX;
3663*e4b17023SJohn Marino break;
3664*e4b17023SJohn Marino }
3665*e4b17023SJohn Marino
3666*e4b17023SJohn Marino return current_max;
3667*e4b17023SJohn Marino }
3668*e4b17023SJohn Marino
3669*e4b17023SJohn Marino /* Given an attribute value, return the minimum CONST_STRING argument
3670*e4b17023SJohn Marino encountered. Set *UNKNOWNP and return 0 if the value is unknown. */
3671*e4b17023SJohn Marino
3672*e4b17023SJohn Marino static int
min_attr_value(rtx exp,int * unknownp)3673*e4b17023SJohn Marino min_attr_value (rtx exp, int *unknownp)
3674*e4b17023SJohn Marino {
3675*e4b17023SJohn Marino int current_min;
3676*e4b17023SJohn Marino int i, n;
3677*e4b17023SJohn Marino
3678*e4b17023SJohn Marino switch (GET_CODE (exp))
3679*e4b17023SJohn Marino {
3680*e4b17023SJohn Marino case CONST_STRING:
3681*e4b17023SJohn Marino current_min = atoi (XSTR (exp, 0));
3682*e4b17023SJohn Marino break;
3683*e4b17023SJohn Marino
3684*e4b17023SJohn Marino case COND:
3685*e4b17023SJohn Marino current_min = min_attr_value (XEXP (exp, 1), unknownp);
3686*e4b17023SJohn Marino for (i = 0; i < XVECLEN (exp, 0); i += 2)
3687*e4b17023SJohn Marino {
3688*e4b17023SJohn Marino n = min_attr_value (XVECEXP (exp, 0, i + 1), unknownp);
3689*e4b17023SJohn Marino if (n < current_min)
3690*e4b17023SJohn Marino current_min = n;
3691*e4b17023SJohn Marino }
3692*e4b17023SJohn Marino break;
3693*e4b17023SJohn Marino
3694*e4b17023SJohn Marino case IF_THEN_ELSE:
3695*e4b17023SJohn Marino current_min = min_attr_value (XEXP (exp, 1), unknownp);
3696*e4b17023SJohn Marino n = min_attr_value (XEXP (exp, 2), unknownp);
3697*e4b17023SJohn Marino if (n < current_min)
3698*e4b17023SJohn Marino current_min = n;
3699*e4b17023SJohn Marino break;
3700*e4b17023SJohn Marino
3701*e4b17023SJohn Marino default:
3702*e4b17023SJohn Marino *unknownp = 1;
3703*e4b17023SJohn Marino current_min = INT_MAX;
3704*e4b17023SJohn Marino break;
3705*e4b17023SJohn Marino }
3706*e4b17023SJohn Marino
3707*e4b17023SJohn Marino return current_min;
3708*e4b17023SJohn Marino }
3709*e4b17023SJohn Marino
3710*e4b17023SJohn Marino /* Given an attribute value, return the result of ORing together all
3711*e4b17023SJohn Marino CONST_STRING arguments encountered. Set *UNKNOWNP and return -1
3712*e4b17023SJohn Marino if the numeric value is not known. */
3713*e4b17023SJohn Marino
3714*e4b17023SJohn Marino static int
or_attr_value(rtx exp,int * unknownp)3715*e4b17023SJohn Marino or_attr_value (rtx exp, int *unknownp)
3716*e4b17023SJohn Marino {
3717*e4b17023SJohn Marino int current_or;
3718*e4b17023SJohn Marino int i;
3719*e4b17023SJohn Marino
3720*e4b17023SJohn Marino switch (GET_CODE (exp))
3721*e4b17023SJohn Marino {
3722*e4b17023SJohn Marino case CONST_STRING:
3723*e4b17023SJohn Marino current_or = atoi (XSTR (exp, 0));
3724*e4b17023SJohn Marino break;
3725*e4b17023SJohn Marino
3726*e4b17023SJohn Marino case COND:
3727*e4b17023SJohn Marino current_or = or_attr_value (XEXP (exp, 1), unknownp);
3728*e4b17023SJohn Marino for (i = 0; i < XVECLEN (exp, 0); i += 2)
3729*e4b17023SJohn Marino current_or |= or_attr_value (XVECEXP (exp, 0, i + 1), unknownp);
3730*e4b17023SJohn Marino break;
3731*e4b17023SJohn Marino
3732*e4b17023SJohn Marino case IF_THEN_ELSE:
3733*e4b17023SJohn Marino current_or = or_attr_value (XEXP (exp, 1), unknownp);
3734*e4b17023SJohn Marino current_or |= or_attr_value (XEXP (exp, 2), unknownp);
3735*e4b17023SJohn Marino break;
3736*e4b17023SJohn Marino
3737*e4b17023SJohn Marino default:
3738*e4b17023SJohn Marino *unknownp = 1;
3739*e4b17023SJohn Marino current_or = -1;
3740*e4b17023SJohn Marino break;
3741*e4b17023SJohn Marino }
3742*e4b17023SJohn Marino
3743*e4b17023SJohn Marino return current_or;
3744*e4b17023SJohn Marino }
3745*e4b17023SJohn Marino
3746*e4b17023SJohn Marino /* Scan an attribute value, possibly a conditional, and record what actions
3747*e4b17023SJohn Marino will be required to do any conditional tests in it.
3748*e4b17023SJohn Marino
3749*e4b17023SJohn Marino Specifically, set
3750*e4b17023SJohn Marino `must_extract' if we need to extract the insn operands
3751*e4b17023SJohn Marino `must_constrain' if we must compute `which_alternative'
3752*e4b17023SJohn Marino `address_used' if an address expression was used
3753*e4b17023SJohn Marino `length_used' if an (eq_attr "length" ...) was used
3754*e4b17023SJohn Marino */
3755*e4b17023SJohn Marino
3756*e4b17023SJohn Marino static void
walk_attr_value(rtx exp)3757*e4b17023SJohn Marino walk_attr_value (rtx exp)
3758*e4b17023SJohn Marino {
3759*e4b17023SJohn Marino int i, j;
3760*e4b17023SJohn Marino const char *fmt;
3761*e4b17023SJohn Marino RTX_CODE code;
3762*e4b17023SJohn Marino
3763*e4b17023SJohn Marino if (exp == NULL)
3764*e4b17023SJohn Marino return;
3765*e4b17023SJohn Marino
3766*e4b17023SJohn Marino code = GET_CODE (exp);
3767*e4b17023SJohn Marino switch (code)
3768*e4b17023SJohn Marino {
3769*e4b17023SJohn Marino case SYMBOL_REF:
3770*e4b17023SJohn Marino if (! ATTR_IND_SIMPLIFIED_P (exp))
3771*e4b17023SJohn Marino /* Since this is an arbitrary expression, it can look at anything.
3772*e4b17023SJohn Marino However, constant expressions do not depend on any particular
3773*e4b17023SJohn Marino insn. */
3774*e4b17023SJohn Marino must_extract = must_constrain = 1;
3775*e4b17023SJohn Marino return;
3776*e4b17023SJohn Marino
3777*e4b17023SJohn Marino case MATCH_OPERAND:
3778*e4b17023SJohn Marino must_extract = 1;
3779*e4b17023SJohn Marino return;
3780*e4b17023SJohn Marino
3781*e4b17023SJohn Marino case MATCH_TEST:
3782*e4b17023SJohn Marino case EQ_ATTR_ALT:
3783*e4b17023SJohn Marino must_extract = must_constrain = 1;
3784*e4b17023SJohn Marino break;
3785*e4b17023SJohn Marino
3786*e4b17023SJohn Marino case EQ_ATTR:
3787*e4b17023SJohn Marino if (XSTR (exp, 0) == alternative_name)
3788*e4b17023SJohn Marino must_extract = must_constrain = 1;
3789*e4b17023SJohn Marino else if (strcmp_check (XSTR (exp, 0), length_str) == 0)
3790*e4b17023SJohn Marino length_used = 1;
3791*e4b17023SJohn Marino return;
3792*e4b17023SJohn Marino
3793*e4b17023SJohn Marino case MATCH_DUP:
3794*e4b17023SJohn Marino must_extract = 1;
3795*e4b17023SJohn Marino address_used = 1;
3796*e4b17023SJohn Marino return;
3797*e4b17023SJohn Marino
3798*e4b17023SJohn Marino case PC:
3799*e4b17023SJohn Marino address_used = 1;
3800*e4b17023SJohn Marino return;
3801*e4b17023SJohn Marino
3802*e4b17023SJohn Marino case ATTR_FLAG:
3803*e4b17023SJohn Marino return;
3804*e4b17023SJohn Marino
3805*e4b17023SJohn Marino default:
3806*e4b17023SJohn Marino break;
3807*e4b17023SJohn Marino }
3808*e4b17023SJohn Marino
3809*e4b17023SJohn Marino for (i = 0, fmt = GET_RTX_FORMAT (code); i < GET_RTX_LENGTH (code); i++)
3810*e4b17023SJohn Marino switch (*fmt++)
3811*e4b17023SJohn Marino {
3812*e4b17023SJohn Marino case 'e':
3813*e4b17023SJohn Marino case 'u':
3814*e4b17023SJohn Marino walk_attr_value (XEXP (exp, i));
3815*e4b17023SJohn Marino break;
3816*e4b17023SJohn Marino
3817*e4b17023SJohn Marino case 'E':
3818*e4b17023SJohn Marino if (XVEC (exp, i) != NULL)
3819*e4b17023SJohn Marino for (j = 0; j < XVECLEN (exp, i); j++)
3820*e4b17023SJohn Marino walk_attr_value (XVECEXP (exp, i, j));
3821*e4b17023SJohn Marino break;
3822*e4b17023SJohn Marino }
3823*e4b17023SJohn Marino }
3824*e4b17023SJohn Marino
3825*e4b17023SJohn Marino /* Write out a function to obtain the attribute for a given INSN. */
3826*e4b17023SJohn Marino
3827*e4b17023SJohn Marino static void
write_attr_get(struct attr_desc * attr)3828*e4b17023SJohn Marino write_attr_get (struct attr_desc *attr)
3829*e4b17023SJohn Marino {
3830*e4b17023SJohn Marino struct attr_value *av, *common_av;
3831*e4b17023SJohn Marino int i, j;
3832*e4b17023SJohn Marino
3833*e4b17023SJohn Marino /* Find the most used attribute value. Handle that as the `default' of the
3834*e4b17023SJohn Marino switch we will generate. */
3835*e4b17023SJohn Marino common_av = find_most_used (attr);
3836*e4b17023SJohn Marino
3837*e4b17023SJohn Marino /* Write out start of function, then all values with explicit `case' lines,
3838*e4b17023SJohn Marino then a `default', then the value with the most uses. */
3839*e4b17023SJohn Marino if (attr->enum_name)
3840*e4b17023SJohn Marino printf ("enum %s\n", attr->enum_name);
3841*e4b17023SJohn Marino else if (!attr->is_numeric)
3842*e4b17023SJohn Marino printf ("enum attr_%s\n", attr->name);
3843*e4b17023SJohn Marino else
3844*e4b17023SJohn Marino printf ("int\n");
3845*e4b17023SJohn Marino
3846*e4b17023SJohn Marino /* If the attribute name starts with a star, the remainder is the name of
3847*e4b17023SJohn Marino the subroutine to use, instead of `get_attr_...'. */
3848*e4b17023SJohn Marino if (attr->name[0] == '*')
3849*e4b17023SJohn Marino printf ("%s (rtx insn ATTRIBUTE_UNUSED)\n", &attr->name[1]);
3850*e4b17023SJohn Marino else if (attr->is_const == 0)
3851*e4b17023SJohn Marino printf ("get_attr_%s (rtx insn ATTRIBUTE_UNUSED)\n", attr->name);
3852*e4b17023SJohn Marino else
3853*e4b17023SJohn Marino {
3854*e4b17023SJohn Marino printf ("get_attr_%s (void)\n", attr->name);
3855*e4b17023SJohn Marino printf ("{\n");
3856*e4b17023SJohn Marino
3857*e4b17023SJohn Marino for (av = attr->first_value; av; av = av->next)
3858*e4b17023SJohn Marino if (av->num_insns == 1)
3859*e4b17023SJohn Marino write_attr_set (attr, 2, av->value, "return", ";",
3860*e4b17023SJohn Marino true_rtx, av->first_insn->def->insn_code,
3861*e4b17023SJohn Marino av->first_insn->def->insn_index, 0);
3862*e4b17023SJohn Marino else if (av->num_insns != 0)
3863*e4b17023SJohn Marino write_attr_set (attr, 2, av->value, "return", ";",
3864*e4b17023SJohn Marino true_rtx, -2, 0, 0);
3865*e4b17023SJohn Marino
3866*e4b17023SJohn Marino printf ("}\n\n");
3867*e4b17023SJohn Marino return;
3868*e4b17023SJohn Marino }
3869*e4b17023SJohn Marino
3870*e4b17023SJohn Marino printf ("{\n");
3871*e4b17023SJohn Marino
3872*e4b17023SJohn Marino /* Find attributes that are worth caching in the conditions. */
3873*e4b17023SJohn Marino cached_attr_count = 0;
3874*e4b17023SJohn Marino attrs_seen_more_than_once = 0;
3875*e4b17023SJohn Marino for (av = attr->first_value; av; av = av->next)
3876*e4b17023SJohn Marino {
3877*e4b17023SJohn Marino attrs_seen_once = 0;
3878*e4b17023SJohn Marino find_attrs_to_cache (av->value, true);
3879*e4b17023SJohn Marino }
3880*e4b17023SJohn Marino /* Remove those that aren't worth caching from the array. */
3881*e4b17023SJohn Marino for (i = 0, j = 0; i < cached_attr_count; i++)
3882*e4b17023SJohn Marino if ((attrs_seen_more_than_once & (1U << i)) != 0)
3883*e4b17023SJohn Marino {
3884*e4b17023SJohn Marino const char *name = cached_attrs[i];
3885*e4b17023SJohn Marino struct attr_desc *cached_attr;
3886*e4b17023SJohn Marino if (i != j)
3887*e4b17023SJohn Marino cached_attrs[j] = name;
3888*e4b17023SJohn Marino cached_attr = find_attr (&name, 0);
3889*e4b17023SJohn Marino gcc_assert (cached_attr && cached_attr->is_const == 0);
3890*e4b17023SJohn Marino if (cached_attr->enum_name)
3891*e4b17023SJohn Marino printf (" enum %s", cached_attr->enum_name);
3892*e4b17023SJohn Marino else if (!cached_attr->is_numeric)
3893*e4b17023SJohn Marino printf (" enum attr_%s", cached_attr->name);
3894*e4b17023SJohn Marino else
3895*e4b17023SJohn Marino printf (" int");
3896*e4b17023SJohn Marino printf (" cached_%s ATTRIBUTE_UNUSED;\n", name);
3897*e4b17023SJohn Marino j++;
3898*e4b17023SJohn Marino }
3899*e4b17023SJohn Marino cached_attr_count = j;
3900*e4b17023SJohn Marino if (cached_attr_count)
3901*e4b17023SJohn Marino printf ("\n");
3902*e4b17023SJohn Marino
3903*e4b17023SJohn Marino printf (" switch (recog_memoized (insn))\n");
3904*e4b17023SJohn Marino printf (" {\n");
3905*e4b17023SJohn Marino
3906*e4b17023SJohn Marino for (av = attr->first_value; av; av = av->next)
3907*e4b17023SJohn Marino if (av != common_av)
3908*e4b17023SJohn Marino write_attr_case (attr, av, 1, "return", ";", 4, true_rtx);
3909*e4b17023SJohn Marino
3910*e4b17023SJohn Marino write_attr_case (attr, common_av, 0, "return", ";", 4, true_rtx);
3911*e4b17023SJohn Marino printf (" }\n}\n\n");
3912*e4b17023SJohn Marino cached_attr_count = 0;
3913*e4b17023SJohn Marino }
3914*e4b17023SJohn Marino
3915*e4b17023SJohn Marino /* Given an AND tree of known true terms (because we are inside an `if' with
3916*e4b17023SJohn Marino that as the condition or are in an `else' clause) and an expression,
3917*e4b17023SJohn Marino replace any known true terms with TRUE. Use `simplify_and_tree' to do
3918*e4b17023SJohn Marino the bulk of the work. */
3919*e4b17023SJohn Marino
3920*e4b17023SJohn Marino static rtx
eliminate_known_true(rtx known_true,rtx exp,int insn_code,int insn_index)3921*e4b17023SJohn Marino eliminate_known_true (rtx known_true, rtx exp, int insn_code, int insn_index)
3922*e4b17023SJohn Marino {
3923*e4b17023SJohn Marino rtx term;
3924*e4b17023SJohn Marino
3925*e4b17023SJohn Marino known_true = SIMPLIFY_TEST_EXP (known_true, insn_code, insn_index);
3926*e4b17023SJohn Marino
3927*e4b17023SJohn Marino if (GET_CODE (known_true) == AND)
3928*e4b17023SJohn Marino {
3929*e4b17023SJohn Marino exp = eliminate_known_true (XEXP (known_true, 0), exp,
3930*e4b17023SJohn Marino insn_code, insn_index);
3931*e4b17023SJohn Marino exp = eliminate_known_true (XEXP (known_true, 1), exp,
3932*e4b17023SJohn Marino insn_code, insn_index);
3933*e4b17023SJohn Marino }
3934*e4b17023SJohn Marino else
3935*e4b17023SJohn Marino {
3936*e4b17023SJohn Marino term = known_true;
3937*e4b17023SJohn Marino exp = simplify_and_tree (exp, &term, insn_code, insn_index);
3938*e4b17023SJohn Marino }
3939*e4b17023SJohn Marino
3940*e4b17023SJohn Marino return exp;
3941*e4b17023SJohn Marino }
3942*e4b17023SJohn Marino
3943*e4b17023SJohn Marino /* Write out a series of tests and assignment statements to perform tests and
3944*e4b17023SJohn Marino sets of an attribute value. We are passed an indentation amount and prefix
3945*e4b17023SJohn Marino and suffix strings to write around each attribute value (e.g., "return"
3946*e4b17023SJohn Marino and ";"). */
3947*e4b17023SJohn Marino
3948*e4b17023SJohn Marino static void
write_attr_set(struct attr_desc * attr,int indent,rtx value,const char * prefix,const char * suffix,rtx known_true,int insn_code,int insn_index,unsigned int attrs_cached)3949*e4b17023SJohn Marino write_attr_set (struct attr_desc *attr, int indent, rtx value,
3950*e4b17023SJohn Marino const char *prefix, const char *suffix, rtx known_true,
3951*e4b17023SJohn Marino int insn_code, int insn_index, unsigned int attrs_cached)
3952*e4b17023SJohn Marino {
3953*e4b17023SJohn Marino if (GET_CODE (value) == COND)
3954*e4b17023SJohn Marino {
3955*e4b17023SJohn Marino /* Assume the default value will be the default of the COND unless we
3956*e4b17023SJohn Marino find an always true expression. */
3957*e4b17023SJohn Marino rtx default_val = XEXP (value, 1);
3958*e4b17023SJohn Marino rtx our_known_true = known_true;
3959*e4b17023SJohn Marino rtx newexp;
3960*e4b17023SJohn Marino int first_if = 1;
3961*e4b17023SJohn Marino int i;
3962*e4b17023SJohn Marino
3963*e4b17023SJohn Marino if (cached_attr_count)
3964*e4b17023SJohn Marino {
3965*e4b17023SJohn Marino attrs_seen_once = 0;
3966*e4b17023SJohn Marino attrs_seen_more_than_once = 0;
3967*e4b17023SJohn Marino for (i = 0; i < XVECLEN (value, 0); i += 2)
3968*e4b17023SJohn Marino find_attrs_to_cache (XVECEXP (value, 0, i), false);
3969*e4b17023SJohn Marino attrs_to_cache |= attrs_seen_more_than_once;
3970*e4b17023SJohn Marino }
3971*e4b17023SJohn Marino
3972*e4b17023SJohn Marino for (i = 0; i < XVECLEN (value, 0); i += 2)
3973*e4b17023SJohn Marino {
3974*e4b17023SJohn Marino rtx testexp;
3975*e4b17023SJohn Marino rtx inner_true;
3976*e4b17023SJohn Marino
3977*e4b17023SJohn Marino testexp = eliminate_known_true (our_known_true,
3978*e4b17023SJohn Marino XVECEXP (value, 0, i),
3979*e4b17023SJohn Marino insn_code, insn_index);
3980*e4b17023SJohn Marino newexp = attr_rtx (NOT, testexp);
3981*e4b17023SJohn Marino newexp = insert_right_side (AND, our_known_true, newexp,
3982*e4b17023SJohn Marino insn_code, insn_index);
3983*e4b17023SJohn Marino
3984*e4b17023SJohn Marino /* If the test expression is always true or if the next `known_true'
3985*e4b17023SJohn Marino expression is always false, this is the last case, so break
3986*e4b17023SJohn Marino out and let this value be the `else' case. */
3987*e4b17023SJohn Marino if (testexp == true_rtx || newexp == false_rtx)
3988*e4b17023SJohn Marino {
3989*e4b17023SJohn Marino default_val = XVECEXP (value, 0, i + 1);
3990*e4b17023SJohn Marino break;
3991*e4b17023SJohn Marino }
3992*e4b17023SJohn Marino
3993*e4b17023SJohn Marino /* Compute the expression to pass to our recursive call as being
3994*e4b17023SJohn Marino known true. */
3995*e4b17023SJohn Marino inner_true = insert_right_side (AND, our_known_true,
3996*e4b17023SJohn Marino testexp, insn_code, insn_index);
3997*e4b17023SJohn Marino
3998*e4b17023SJohn Marino /* If this is always false, skip it. */
3999*e4b17023SJohn Marino if (inner_true == false_rtx)
4000*e4b17023SJohn Marino continue;
4001*e4b17023SJohn Marino
4002*e4b17023SJohn Marino attrs_cached_inside = attrs_cached;
4003*e4b17023SJohn Marino attrs_cached_after = attrs_cached;
4004*e4b17023SJohn Marino write_indent (indent);
4005*e4b17023SJohn Marino printf ("%sif ", first_if ? "" : "else ");
4006*e4b17023SJohn Marino first_if = 0;
4007*e4b17023SJohn Marino write_test_expr (testexp, attrs_cached,
4008*e4b17023SJohn Marino (FLG_AFTER | FLG_INSIDE | FLG_OUTSIDE_AND));
4009*e4b17023SJohn Marino attrs_cached = attrs_cached_after;
4010*e4b17023SJohn Marino printf ("\n");
4011*e4b17023SJohn Marino write_indent (indent + 2);
4012*e4b17023SJohn Marino printf ("{\n");
4013*e4b17023SJohn Marino
4014*e4b17023SJohn Marino write_attr_set (attr, indent + 4,
4015*e4b17023SJohn Marino XVECEXP (value, 0, i + 1), prefix, suffix,
4016*e4b17023SJohn Marino inner_true, insn_code, insn_index,
4017*e4b17023SJohn Marino attrs_cached_inside);
4018*e4b17023SJohn Marino write_indent (indent + 2);
4019*e4b17023SJohn Marino printf ("}\n");
4020*e4b17023SJohn Marino our_known_true = newexp;
4021*e4b17023SJohn Marino }
4022*e4b17023SJohn Marino
4023*e4b17023SJohn Marino if (! first_if)
4024*e4b17023SJohn Marino {
4025*e4b17023SJohn Marino write_indent (indent);
4026*e4b17023SJohn Marino printf ("else\n");
4027*e4b17023SJohn Marino write_indent (indent + 2);
4028*e4b17023SJohn Marino printf ("{\n");
4029*e4b17023SJohn Marino }
4030*e4b17023SJohn Marino
4031*e4b17023SJohn Marino write_attr_set (attr, first_if ? indent : indent + 4, default_val,
4032*e4b17023SJohn Marino prefix, suffix, our_known_true, insn_code, insn_index,
4033*e4b17023SJohn Marino attrs_cached);
4034*e4b17023SJohn Marino
4035*e4b17023SJohn Marino if (! first_if)
4036*e4b17023SJohn Marino {
4037*e4b17023SJohn Marino write_indent (indent + 2);
4038*e4b17023SJohn Marino printf ("}\n");
4039*e4b17023SJohn Marino }
4040*e4b17023SJohn Marino }
4041*e4b17023SJohn Marino else
4042*e4b17023SJohn Marino {
4043*e4b17023SJohn Marino write_indent (indent);
4044*e4b17023SJohn Marino printf ("%s ", prefix);
4045*e4b17023SJohn Marino write_attr_value (attr, value);
4046*e4b17023SJohn Marino printf ("%s\n", suffix);
4047*e4b17023SJohn Marino }
4048*e4b17023SJohn Marino }
4049*e4b17023SJohn Marino
4050*e4b17023SJohn Marino /* Write a series of case statements for every instruction in list IE.
4051*e4b17023SJohn Marino INDENT is the amount of indentation to write before each case. */
4052*e4b17023SJohn Marino
4053*e4b17023SJohn Marino static void
write_insn_cases(struct insn_ent * ie,int indent)4054*e4b17023SJohn Marino write_insn_cases (struct insn_ent *ie, int indent)
4055*e4b17023SJohn Marino {
4056*e4b17023SJohn Marino for (; ie != 0; ie = ie->next)
4057*e4b17023SJohn Marino if (ie->def->insn_code != -1)
4058*e4b17023SJohn Marino {
4059*e4b17023SJohn Marino write_indent (indent);
4060*e4b17023SJohn Marino if (GET_CODE (ie->def->def) == DEFINE_PEEPHOLE)
4061*e4b17023SJohn Marino printf ("case %d: /* define_peephole, line %d */\n",
4062*e4b17023SJohn Marino ie->def->insn_code, ie->def->lineno);
4063*e4b17023SJohn Marino else
4064*e4b17023SJohn Marino printf ("case %d: /* %s */\n",
4065*e4b17023SJohn Marino ie->def->insn_code, XSTR (ie->def->def, 0));
4066*e4b17023SJohn Marino }
4067*e4b17023SJohn Marino }
4068*e4b17023SJohn Marino
4069*e4b17023SJohn Marino /* Write out the computation for one attribute value. */
4070*e4b17023SJohn Marino
4071*e4b17023SJohn Marino static void
write_attr_case(struct attr_desc * attr,struct attr_value * av,int write_case_lines,const char * prefix,const char * suffix,int indent,rtx known_true)4072*e4b17023SJohn Marino write_attr_case (struct attr_desc *attr, struct attr_value *av,
4073*e4b17023SJohn Marino int write_case_lines, const char *prefix, const char *suffix,
4074*e4b17023SJohn Marino int indent, rtx known_true)
4075*e4b17023SJohn Marino {
4076*e4b17023SJohn Marino if (av->num_insns == 0)
4077*e4b17023SJohn Marino return;
4078*e4b17023SJohn Marino
4079*e4b17023SJohn Marino if (av->has_asm_insn)
4080*e4b17023SJohn Marino {
4081*e4b17023SJohn Marino write_indent (indent);
4082*e4b17023SJohn Marino printf ("case -1:\n");
4083*e4b17023SJohn Marino write_indent (indent + 2);
4084*e4b17023SJohn Marino printf ("if (GET_CODE (PATTERN (insn)) != ASM_INPUT\n");
4085*e4b17023SJohn Marino write_indent (indent + 2);
4086*e4b17023SJohn Marino printf (" && asm_noperands (PATTERN (insn)) < 0)\n");
4087*e4b17023SJohn Marino write_indent (indent + 2);
4088*e4b17023SJohn Marino printf (" fatal_insn_not_found (insn);\n");
4089*e4b17023SJohn Marino }
4090*e4b17023SJohn Marino
4091*e4b17023SJohn Marino if (write_case_lines)
4092*e4b17023SJohn Marino write_insn_cases (av->first_insn, indent);
4093*e4b17023SJohn Marino else
4094*e4b17023SJohn Marino {
4095*e4b17023SJohn Marino write_indent (indent);
4096*e4b17023SJohn Marino printf ("default:\n");
4097*e4b17023SJohn Marino }
4098*e4b17023SJohn Marino
4099*e4b17023SJohn Marino /* See what we have to do to output this value. */
4100*e4b17023SJohn Marino must_extract = must_constrain = address_used = 0;
4101*e4b17023SJohn Marino walk_attr_value (av->value);
4102*e4b17023SJohn Marino
4103*e4b17023SJohn Marino if (must_constrain)
4104*e4b17023SJohn Marino {
4105*e4b17023SJohn Marino write_indent (indent + 2);
4106*e4b17023SJohn Marino printf ("extract_constrain_insn_cached (insn);\n");
4107*e4b17023SJohn Marino }
4108*e4b17023SJohn Marino else if (must_extract)
4109*e4b17023SJohn Marino {
4110*e4b17023SJohn Marino write_indent (indent + 2);
4111*e4b17023SJohn Marino printf ("extract_insn_cached (insn);\n");
4112*e4b17023SJohn Marino }
4113*e4b17023SJohn Marino
4114*e4b17023SJohn Marino attrs_to_cache = 0;
4115*e4b17023SJohn Marino if (av->num_insns == 1)
4116*e4b17023SJohn Marino write_attr_set (attr, indent + 2, av->value, prefix, suffix,
4117*e4b17023SJohn Marino known_true, av->first_insn->def->insn_code,
4118*e4b17023SJohn Marino av->first_insn->def->insn_index, 0);
4119*e4b17023SJohn Marino else
4120*e4b17023SJohn Marino write_attr_set (attr, indent + 2, av->value, prefix, suffix,
4121*e4b17023SJohn Marino known_true, -2, 0, 0);
4122*e4b17023SJohn Marino
4123*e4b17023SJohn Marino if (strncmp (prefix, "return", 6))
4124*e4b17023SJohn Marino {
4125*e4b17023SJohn Marino write_indent (indent + 2);
4126*e4b17023SJohn Marino printf ("break;\n");
4127*e4b17023SJohn Marino }
4128*e4b17023SJohn Marino printf ("\n");
4129*e4b17023SJohn Marino }
4130*e4b17023SJohn Marino
4131*e4b17023SJohn Marino /* Utilities to write in various forms. */
4132*e4b17023SJohn Marino
4133*e4b17023SJohn Marino static void
write_attr_valueq(struct attr_desc * attr,const char * s)4134*e4b17023SJohn Marino write_attr_valueq (struct attr_desc *attr, const char *s)
4135*e4b17023SJohn Marino {
4136*e4b17023SJohn Marino if (attr->is_numeric)
4137*e4b17023SJohn Marino {
4138*e4b17023SJohn Marino int num = atoi (s);
4139*e4b17023SJohn Marino
4140*e4b17023SJohn Marino printf ("%d", num);
4141*e4b17023SJohn Marino
4142*e4b17023SJohn Marino if (num > 9 || num < 0)
4143*e4b17023SJohn Marino printf (" /* %#x */", num);
4144*e4b17023SJohn Marino }
4145*e4b17023SJohn Marino else
4146*e4b17023SJohn Marino {
4147*e4b17023SJohn Marino write_upcase (attr->enum_name ? attr->enum_name : attr->name);
4148*e4b17023SJohn Marino printf ("_");
4149*e4b17023SJohn Marino write_upcase (s);
4150*e4b17023SJohn Marino }
4151*e4b17023SJohn Marino }
4152*e4b17023SJohn Marino
4153*e4b17023SJohn Marino static void
write_attr_value(struct attr_desc * attr,rtx value)4154*e4b17023SJohn Marino write_attr_value (struct attr_desc *attr, rtx value)
4155*e4b17023SJohn Marino {
4156*e4b17023SJohn Marino int op;
4157*e4b17023SJohn Marino
4158*e4b17023SJohn Marino switch (GET_CODE (value))
4159*e4b17023SJohn Marino {
4160*e4b17023SJohn Marino case CONST_STRING:
4161*e4b17023SJohn Marino write_attr_valueq (attr, XSTR (value, 0));
4162*e4b17023SJohn Marino break;
4163*e4b17023SJohn Marino
4164*e4b17023SJohn Marino case CONST_INT:
4165*e4b17023SJohn Marino printf (HOST_WIDE_INT_PRINT_DEC, INTVAL (value));
4166*e4b17023SJohn Marino break;
4167*e4b17023SJohn Marino
4168*e4b17023SJohn Marino case SYMBOL_REF:
4169*e4b17023SJohn Marino print_c_condition (XSTR (value, 0));
4170*e4b17023SJohn Marino break;
4171*e4b17023SJohn Marino
4172*e4b17023SJohn Marino case ATTR:
4173*e4b17023SJohn Marino {
4174*e4b17023SJohn Marino struct attr_desc *attr2 = find_attr (&XSTR (value, 0), 0);
4175*e4b17023SJohn Marino if (attr->enum_name)
4176*e4b17023SJohn Marino printf ("(enum %s)", attr->enum_name);
4177*e4b17023SJohn Marino else if (!attr->is_numeric)
4178*e4b17023SJohn Marino printf ("(enum attr_%s)", attr->name);
4179*e4b17023SJohn Marino else if (!attr2->is_numeric)
4180*e4b17023SJohn Marino printf ("(int)");
4181*e4b17023SJohn Marino
4182*e4b17023SJohn Marino printf ("get_attr_%s (%s)", attr2->name,
4183*e4b17023SJohn Marino (attr2->is_const ? "" : "insn"));
4184*e4b17023SJohn Marino }
4185*e4b17023SJohn Marino break;
4186*e4b17023SJohn Marino
4187*e4b17023SJohn Marino case PLUS:
4188*e4b17023SJohn Marino op = '+';
4189*e4b17023SJohn Marino goto do_operator;
4190*e4b17023SJohn Marino case MINUS:
4191*e4b17023SJohn Marino op = '-';
4192*e4b17023SJohn Marino goto do_operator;
4193*e4b17023SJohn Marino case MULT:
4194*e4b17023SJohn Marino op = '*';
4195*e4b17023SJohn Marino goto do_operator;
4196*e4b17023SJohn Marino case DIV:
4197*e4b17023SJohn Marino op = '/';
4198*e4b17023SJohn Marino goto do_operator;
4199*e4b17023SJohn Marino case MOD:
4200*e4b17023SJohn Marino op = '%';
4201*e4b17023SJohn Marino goto do_operator;
4202*e4b17023SJohn Marino
4203*e4b17023SJohn Marino do_operator:
4204*e4b17023SJohn Marino write_attr_value (attr, XEXP (value, 0));
4205*e4b17023SJohn Marino putchar (' ');
4206*e4b17023SJohn Marino putchar (op);
4207*e4b17023SJohn Marino putchar (' ');
4208*e4b17023SJohn Marino write_attr_value (attr, XEXP (value, 1));
4209*e4b17023SJohn Marino break;
4210*e4b17023SJohn Marino
4211*e4b17023SJohn Marino default:
4212*e4b17023SJohn Marino gcc_unreachable ();
4213*e4b17023SJohn Marino }
4214*e4b17023SJohn Marino }
4215*e4b17023SJohn Marino
4216*e4b17023SJohn Marino static void
write_upcase(const char * str)4217*e4b17023SJohn Marino write_upcase (const char *str)
4218*e4b17023SJohn Marino {
4219*e4b17023SJohn Marino while (*str)
4220*e4b17023SJohn Marino {
4221*e4b17023SJohn Marino /* The argument of TOUPPER should not have side effects. */
4222*e4b17023SJohn Marino putchar (TOUPPER(*str));
4223*e4b17023SJohn Marino str++;
4224*e4b17023SJohn Marino }
4225*e4b17023SJohn Marino }
4226*e4b17023SJohn Marino
4227*e4b17023SJohn Marino static void
write_indent(int indent)4228*e4b17023SJohn Marino write_indent (int indent)
4229*e4b17023SJohn Marino {
4230*e4b17023SJohn Marino for (; indent > 8; indent -= 8)
4231*e4b17023SJohn Marino printf ("\t");
4232*e4b17023SJohn Marino
4233*e4b17023SJohn Marino for (; indent; indent--)
4234*e4b17023SJohn Marino printf (" ");
4235*e4b17023SJohn Marino }
4236*e4b17023SJohn Marino
4237*e4b17023SJohn Marino /* Write a subroutine that is given an insn that requires a delay slot, a
4238*e4b17023SJohn Marino delay slot ordinal, and a candidate insn. It returns nonzero if the
4239*e4b17023SJohn Marino candidate can be placed in the specified delay slot of the insn.
4240*e4b17023SJohn Marino
4241*e4b17023SJohn Marino We can write as many as three subroutines. `eligible_for_delay'
4242*e4b17023SJohn Marino handles normal delay slots, `eligible_for_annul_true' indicates that
4243*e4b17023SJohn Marino the specified insn can be annulled if the branch is true, and likewise
4244*e4b17023SJohn Marino for `eligible_for_annul_false'.
4245*e4b17023SJohn Marino
4246*e4b17023SJohn Marino KIND is a string distinguishing these three cases ("delay", "annul_true",
4247*e4b17023SJohn Marino or "annul_false"). */
4248*e4b17023SJohn Marino
4249*e4b17023SJohn Marino static void
write_eligible_delay(const char * kind)4250*e4b17023SJohn Marino write_eligible_delay (const char *kind)
4251*e4b17023SJohn Marino {
4252*e4b17023SJohn Marino struct delay_desc *delay;
4253*e4b17023SJohn Marino int max_slots;
4254*e4b17023SJohn Marino char str[50];
4255*e4b17023SJohn Marino const char *pstr;
4256*e4b17023SJohn Marino struct attr_desc *attr;
4257*e4b17023SJohn Marino struct attr_value *av, *common_av;
4258*e4b17023SJohn Marino int i;
4259*e4b17023SJohn Marino
4260*e4b17023SJohn Marino /* Compute the maximum number of delay slots required. We use the delay
4261*e4b17023SJohn Marino ordinal times this number plus one, plus the slot number as an index into
4262*e4b17023SJohn Marino the appropriate predicate to test. */
4263*e4b17023SJohn Marino
4264*e4b17023SJohn Marino for (delay = delays, max_slots = 0; delay; delay = delay->next)
4265*e4b17023SJohn Marino if (XVECLEN (delay->def, 1) / 3 > max_slots)
4266*e4b17023SJohn Marino max_slots = XVECLEN (delay->def, 1) / 3;
4267*e4b17023SJohn Marino
4268*e4b17023SJohn Marino /* Write function prelude. */
4269*e4b17023SJohn Marino
4270*e4b17023SJohn Marino printf ("int\n");
4271*e4b17023SJohn Marino printf ("eligible_for_%s (rtx delay_insn ATTRIBUTE_UNUSED, int slot, rtx candidate_insn, int flags ATTRIBUTE_UNUSED)\n",
4272*e4b17023SJohn Marino kind);
4273*e4b17023SJohn Marino printf ("{\n");
4274*e4b17023SJohn Marino printf (" rtx insn;\n");
4275*e4b17023SJohn Marino printf ("\n");
4276*e4b17023SJohn Marino printf (" gcc_assert (slot < %d);\n", max_slots);
4277*e4b17023SJohn Marino printf ("\n");
4278*e4b17023SJohn Marino /* Allow dbr_schedule to pass labels, etc. This can happen if try_split
4279*e4b17023SJohn Marino converts a compound instruction into a loop. */
4280*e4b17023SJohn Marino printf (" if (!INSN_P (candidate_insn))\n");
4281*e4b17023SJohn Marino printf (" return 0;\n");
4282*e4b17023SJohn Marino printf ("\n");
4283*e4b17023SJohn Marino
4284*e4b17023SJohn Marino /* If more than one delay type, find out which type the delay insn is. */
4285*e4b17023SJohn Marino
4286*e4b17023SJohn Marino if (num_delays > 1)
4287*e4b17023SJohn Marino {
4288*e4b17023SJohn Marino attr = find_attr (&delay_type_str, 0);
4289*e4b17023SJohn Marino gcc_assert (attr);
4290*e4b17023SJohn Marino common_av = find_most_used (attr);
4291*e4b17023SJohn Marino
4292*e4b17023SJohn Marino printf (" insn = delay_insn;\n");
4293*e4b17023SJohn Marino printf (" switch (recog_memoized (insn))\n");
4294*e4b17023SJohn Marino printf (" {\n");
4295*e4b17023SJohn Marino
4296*e4b17023SJohn Marino sprintf (str, " * %d;\n break;", max_slots);
4297*e4b17023SJohn Marino for (av = attr->first_value; av; av = av->next)
4298*e4b17023SJohn Marino if (av != common_av)
4299*e4b17023SJohn Marino write_attr_case (attr, av, 1, "slot +=", str, 4, true_rtx);
4300*e4b17023SJohn Marino
4301*e4b17023SJohn Marino write_attr_case (attr, common_av, 0, "slot +=", str, 4, true_rtx);
4302*e4b17023SJohn Marino printf (" }\n\n");
4303*e4b17023SJohn Marino
4304*e4b17023SJohn Marino /* Ensure matched. Otherwise, shouldn't have been called. */
4305*e4b17023SJohn Marino printf (" gcc_assert (slot >= %d);\n\n", max_slots);
4306*e4b17023SJohn Marino }
4307*e4b17023SJohn Marino
4308*e4b17023SJohn Marino /* If just one type of delay slot, write simple switch. */
4309*e4b17023SJohn Marino if (num_delays == 1 && max_slots == 1)
4310*e4b17023SJohn Marino {
4311*e4b17023SJohn Marino printf (" insn = candidate_insn;\n");
4312*e4b17023SJohn Marino printf (" switch (recog_memoized (insn))\n");
4313*e4b17023SJohn Marino printf (" {\n");
4314*e4b17023SJohn Marino
4315*e4b17023SJohn Marino attr = find_attr (&delay_1_0_str, 0);
4316*e4b17023SJohn Marino gcc_assert (attr);
4317*e4b17023SJohn Marino common_av = find_most_used (attr);
4318*e4b17023SJohn Marino
4319*e4b17023SJohn Marino for (av = attr->first_value; av; av = av->next)
4320*e4b17023SJohn Marino if (av != common_av)
4321*e4b17023SJohn Marino write_attr_case (attr, av, 1, "return", ";", 4, true_rtx);
4322*e4b17023SJohn Marino
4323*e4b17023SJohn Marino write_attr_case (attr, common_av, 0, "return", ";", 4, true_rtx);
4324*e4b17023SJohn Marino printf (" }\n");
4325*e4b17023SJohn Marino }
4326*e4b17023SJohn Marino
4327*e4b17023SJohn Marino else
4328*e4b17023SJohn Marino {
4329*e4b17023SJohn Marino /* Write a nested CASE. The first indicates which condition we need to
4330*e4b17023SJohn Marino test, and the inner CASE tests the condition. */
4331*e4b17023SJohn Marino printf (" insn = candidate_insn;\n");
4332*e4b17023SJohn Marino printf (" switch (slot)\n");
4333*e4b17023SJohn Marino printf (" {\n");
4334*e4b17023SJohn Marino
4335*e4b17023SJohn Marino for (delay = delays; delay; delay = delay->next)
4336*e4b17023SJohn Marino for (i = 0; i < XVECLEN (delay->def, 1); i += 3)
4337*e4b17023SJohn Marino {
4338*e4b17023SJohn Marino printf (" case %d:\n",
4339*e4b17023SJohn Marino (i / 3) + (num_delays == 1 ? 0 : delay->num * max_slots));
4340*e4b17023SJohn Marino printf (" switch (recog_memoized (insn))\n");
4341*e4b17023SJohn Marino printf ("\t{\n");
4342*e4b17023SJohn Marino
4343*e4b17023SJohn Marino sprintf (str, "*%s_%d_%d", kind, delay->num, i / 3);
4344*e4b17023SJohn Marino pstr = str;
4345*e4b17023SJohn Marino attr = find_attr (&pstr, 0);
4346*e4b17023SJohn Marino gcc_assert (attr);
4347*e4b17023SJohn Marino common_av = find_most_used (attr);
4348*e4b17023SJohn Marino
4349*e4b17023SJohn Marino for (av = attr->first_value; av; av = av->next)
4350*e4b17023SJohn Marino if (av != common_av)
4351*e4b17023SJohn Marino write_attr_case (attr, av, 1, "return", ";", 8, true_rtx);
4352*e4b17023SJohn Marino
4353*e4b17023SJohn Marino write_attr_case (attr, common_av, 0, "return", ";", 8, true_rtx);
4354*e4b17023SJohn Marino printf (" }\n");
4355*e4b17023SJohn Marino }
4356*e4b17023SJohn Marino
4357*e4b17023SJohn Marino printf (" default:\n");
4358*e4b17023SJohn Marino printf (" gcc_unreachable ();\n");
4359*e4b17023SJohn Marino printf (" }\n");
4360*e4b17023SJohn Marino }
4361*e4b17023SJohn Marino
4362*e4b17023SJohn Marino printf ("}\n\n");
4363*e4b17023SJohn Marino }
4364*e4b17023SJohn Marino
4365*e4b17023SJohn Marino /* This page contains miscellaneous utility routines. */
4366*e4b17023SJohn Marino
4367*e4b17023SJohn Marino /* Given a pointer to a (char *), return a malloc'ed string containing the
4368*e4b17023SJohn Marino next comma-separated element. Advance the pointer to after the string
4369*e4b17023SJohn Marino scanned, or the end-of-string. Return NULL if at end of string. */
4370*e4b17023SJohn Marino
4371*e4b17023SJohn Marino static char *
next_comma_elt(const char ** pstr)4372*e4b17023SJohn Marino next_comma_elt (const char **pstr)
4373*e4b17023SJohn Marino {
4374*e4b17023SJohn Marino const char *start;
4375*e4b17023SJohn Marino
4376*e4b17023SJohn Marino start = scan_comma_elt (pstr);
4377*e4b17023SJohn Marino
4378*e4b17023SJohn Marino if (start == NULL)
4379*e4b17023SJohn Marino return NULL;
4380*e4b17023SJohn Marino
4381*e4b17023SJohn Marino return attr_string (start, *pstr - start);
4382*e4b17023SJohn Marino }
4383*e4b17023SJohn Marino
4384*e4b17023SJohn Marino /* Return a `struct attr_desc' pointer for a given named attribute. If CREATE
4385*e4b17023SJohn Marino is nonzero, build a new attribute, if one does not exist. *NAME_P is
4386*e4b17023SJohn Marino replaced by a pointer to a canonical copy of the string. */
4387*e4b17023SJohn Marino
4388*e4b17023SJohn Marino static struct attr_desc *
find_attr(const char ** name_p,int create)4389*e4b17023SJohn Marino find_attr (const char **name_p, int create)
4390*e4b17023SJohn Marino {
4391*e4b17023SJohn Marino struct attr_desc *attr;
4392*e4b17023SJohn Marino int index;
4393*e4b17023SJohn Marino const char *name = *name_p;
4394*e4b17023SJohn Marino
4395*e4b17023SJohn Marino /* Before we resort to using `strcmp', see if the string address matches
4396*e4b17023SJohn Marino anywhere. In most cases, it should have been canonicalized to do so. */
4397*e4b17023SJohn Marino if (name == alternative_name)
4398*e4b17023SJohn Marino return NULL;
4399*e4b17023SJohn Marino
4400*e4b17023SJohn Marino index = name[0] & (MAX_ATTRS_INDEX - 1);
4401*e4b17023SJohn Marino for (attr = attrs[index]; attr; attr = attr->next)
4402*e4b17023SJohn Marino if (name == attr->name)
4403*e4b17023SJohn Marino return attr;
4404*e4b17023SJohn Marino
4405*e4b17023SJohn Marino /* Otherwise, do it the slow way. */
4406*e4b17023SJohn Marino for (attr = attrs[index]; attr; attr = attr->next)
4407*e4b17023SJohn Marino if (name[0] == attr->name[0] && ! strcmp (name, attr->name))
4408*e4b17023SJohn Marino {
4409*e4b17023SJohn Marino *name_p = attr->name;
4410*e4b17023SJohn Marino return attr;
4411*e4b17023SJohn Marino }
4412*e4b17023SJohn Marino
4413*e4b17023SJohn Marino if (! create)
4414*e4b17023SJohn Marino return NULL;
4415*e4b17023SJohn Marino
4416*e4b17023SJohn Marino attr = oballoc (struct attr_desc);
4417*e4b17023SJohn Marino attr->name = DEF_ATTR_STRING (name);
4418*e4b17023SJohn Marino attr->enum_name = 0;
4419*e4b17023SJohn Marino attr->first_value = attr->default_val = NULL;
4420*e4b17023SJohn Marino attr->is_numeric = attr->is_const = attr->is_special = 0;
4421*e4b17023SJohn Marino attr->next = attrs[index];
4422*e4b17023SJohn Marino attrs[index] = attr;
4423*e4b17023SJohn Marino
4424*e4b17023SJohn Marino *name_p = attr->name;
4425*e4b17023SJohn Marino
4426*e4b17023SJohn Marino return attr;
4427*e4b17023SJohn Marino }
4428*e4b17023SJohn Marino
4429*e4b17023SJohn Marino /* Create internal attribute with the given default value. */
4430*e4b17023SJohn Marino
4431*e4b17023SJohn Marino static void
make_internal_attr(const char * name,rtx value,int special)4432*e4b17023SJohn Marino make_internal_attr (const char *name, rtx value, int special)
4433*e4b17023SJohn Marino {
4434*e4b17023SJohn Marino struct attr_desc *attr;
4435*e4b17023SJohn Marino
4436*e4b17023SJohn Marino attr = find_attr (&name, 1);
4437*e4b17023SJohn Marino gcc_assert (!attr->default_val);
4438*e4b17023SJohn Marino
4439*e4b17023SJohn Marino attr->is_numeric = 1;
4440*e4b17023SJohn Marino attr->is_const = 0;
4441*e4b17023SJohn Marino attr->is_special = (special & ATTR_SPECIAL) != 0;
4442*e4b17023SJohn Marino attr->default_val = get_attr_value (value, attr, -2);
4443*e4b17023SJohn Marino }
4444*e4b17023SJohn Marino
4445*e4b17023SJohn Marino /* Find the most used value of an attribute. */
4446*e4b17023SJohn Marino
4447*e4b17023SJohn Marino static struct attr_value *
find_most_used(struct attr_desc * attr)4448*e4b17023SJohn Marino find_most_used (struct attr_desc *attr)
4449*e4b17023SJohn Marino {
4450*e4b17023SJohn Marino struct attr_value *av;
4451*e4b17023SJohn Marino struct attr_value *most_used;
4452*e4b17023SJohn Marino int nuses;
4453*e4b17023SJohn Marino
4454*e4b17023SJohn Marino most_used = NULL;
4455*e4b17023SJohn Marino nuses = -1;
4456*e4b17023SJohn Marino
4457*e4b17023SJohn Marino for (av = attr->first_value; av; av = av->next)
4458*e4b17023SJohn Marino if (av->num_insns > nuses)
4459*e4b17023SJohn Marino nuses = av->num_insns, most_used = av;
4460*e4b17023SJohn Marino
4461*e4b17023SJohn Marino return most_used;
4462*e4b17023SJohn Marino }
4463*e4b17023SJohn Marino
4464*e4b17023SJohn Marino /* Return (attr_value "n") */
4465*e4b17023SJohn Marino
4466*e4b17023SJohn Marino static rtx
make_numeric_value(int n)4467*e4b17023SJohn Marino make_numeric_value (int n)
4468*e4b17023SJohn Marino {
4469*e4b17023SJohn Marino static rtx int_values[20];
4470*e4b17023SJohn Marino rtx exp;
4471*e4b17023SJohn Marino char *p;
4472*e4b17023SJohn Marino
4473*e4b17023SJohn Marino gcc_assert (n >= 0);
4474*e4b17023SJohn Marino
4475*e4b17023SJohn Marino if (n < 20 && int_values[n])
4476*e4b17023SJohn Marino return int_values[n];
4477*e4b17023SJohn Marino
4478*e4b17023SJohn Marino p = attr_printf (MAX_DIGITS, "%d", n);
4479*e4b17023SJohn Marino exp = attr_rtx (CONST_STRING, p);
4480*e4b17023SJohn Marino
4481*e4b17023SJohn Marino if (n < 20)
4482*e4b17023SJohn Marino int_values[n] = exp;
4483*e4b17023SJohn Marino
4484*e4b17023SJohn Marino return exp;
4485*e4b17023SJohn Marino }
4486*e4b17023SJohn Marino
4487*e4b17023SJohn Marino static rtx
copy_rtx_unchanging(rtx orig)4488*e4b17023SJohn Marino copy_rtx_unchanging (rtx orig)
4489*e4b17023SJohn Marino {
4490*e4b17023SJohn Marino if (ATTR_IND_SIMPLIFIED_P (orig) || ATTR_CURR_SIMPLIFIED_P (orig))
4491*e4b17023SJohn Marino return orig;
4492*e4b17023SJohn Marino
4493*e4b17023SJohn Marino ATTR_CURR_SIMPLIFIED_P (orig) = 1;
4494*e4b17023SJohn Marino return orig;
4495*e4b17023SJohn Marino }
4496*e4b17023SJohn Marino
4497*e4b17023SJohn Marino /* Determine if an insn has a constant number of delay slots, i.e., the
4498*e4b17023SJohn Marino number of delay slots is not a function of the length of the insn. */
4499*e4b17023SJohn Marino
4500*e4b17023SJohn Marino static void
write_const_num_delay_slots(void)4501*e4b17023SJohn Marino write_const_num_delay_slots (void)
4502*e4b17023SJohn Marino {
4503*e4b17023SJohn Marino struct attr_desc *attr = find_attr (&num_delay_slots_str, 0);
4504*e4b17023SJohn Marino struct attr_value *av;
4505*e4b17023SJohn Marino
4506*e4b17023SJohn Marino if (attr)
4507*e4b17023SJohn Marino {
4508*e4b17023SJohn Marino printf ("int\nconst_num_delay_slots (rtx insn)\n");
4509*e4b17023SJohn Marino printf ("{\n");
4510*e4b17023SJohn Marino printf (" switch (recog_memoized (insn))\n");
4511*e4b17023SJohn Marino printf (" {\n");
4512*e4b17023SJohn Marino
4513*e4b17023SJohn Marino for (av = attr->first_value; av; av = av->next)
4514*e4b17023SJohn Marino {
4515*e4b17023SJohn Marino length_used = 0;
4516*e4b17023SJohn Marino walk_attr_value (av->value);
4517*e4b17023SJohn Marino if (length_used)
4518*e4b17023SJohn Marino write_insn_cases (av->first_insn, 4);
4519*e4b17023SJohn Marino }
4520*e4b17023SJohn Marino
4521*e4b17023SJohn Marino printf (" default:\n");
4522*e4b17023SJohn Marino printf (" return 1;\n");
4523*e4b17023SJohn Marino printf (" }\n}\n\n");
4524*e4b17023SJohn Marino }
4525*e4b17023SJohn Marino }
4526*e4b17023SJohn Marino
4527*e4b17023SJohn Marino /* Synthetic attributes used by insn-automata.c and the scheduler.
4528*e4b17023SJohn Marino These are primarily concerned with (define_insn_reservation)
4529*e4b17023SJohn Marino patterns. */
4530*e4b17023SJohn Marino
4531*e4b17023SJohn Marino struct insn_reserv
4532*e4b17023SJohn Marino {
4533*e4b17023SJohn Marino struct insn_reserv *next;
4534*e4b17023SJohn Marino
4535*e4b17023SJohn Marino const char *name;
4536*e4b17023SJohn Marino int default_latency;
4537*e4b17023SJohn Marino rtx condexp;
4538*e4b17023SJohn Marino
4539*e4b17023SJohn Marino /* Sequence number of this insn. */
4540*e4b17023SJohn Marino int insn_num;
4541*e4b17023SJohn Marino
4542*e4b17023SJohn Marino /* Whether a (define_bypass) construct names this insn in its
4543*e4b17023SJohn Marino output list. */
4544*e4b17023SJohn Marino bool bypassed;
4545*e4b17023SJohn Marino };
4546*e4b17023SJohn Marino
4547*e4b17023SJohn Marino static struct insn_reserv *all_insn_reservs = 0;
4548*e4b17023SJohn Marino static struct insn_reserv **last_insn_reserv_p = &all_insn_reservs;
4549*e4b17023SJohn Marino static size_t n_insn_reservs;
4550*e4b17023SJohn Marino
4551*e4b17023SJohn Marino /* Store information from a DEFINE_INSN_RESERVATION for future
4552*e4b17023SJohn Marino attribute generation. */
4553*e4b17023SJohn Marino static void
gen_insn_reserv(rtx def)4554*e4b17023SJohn Marino gen_insn_reserv (rtx def)
4555*e4b17023SJohn Marino {
4556*e4b17023SJohn Marino struct insn_reserv *decl = oballoc (struct insn_reserv);
4557*e4b17023SJohn Marino
4558*e4b17023SJohn Marino decl->name = DEF_ATTR_STRING (XSTR (def, 0));
4559*e4b17023SJohn Marino decl->default_latency = XINT (def, 1);
4560*e4b17023SJohn Marino decl->condexp = check_attr_test (XEXP (def, 2), 0, 0);
4561*e4b17023SJohn Marino decl->insn_num = n_insn_reservs;
4562*e4b17023SJohn Marino decl->bypassed = false;
4563*e4b17023SJohn Marino decl->next = 0;
4564*e4b17023SJohn Marino
4565*e4b17023SJohn Marino *last_insn_reserv_p = decl;
4566*e4b17023SJohn Marino last_insn_reserv_p = &decl->next;
4567*e4b17023SJohn Marino n_insn_reservs++;
4568*e4b17023SJohn Marino }
4569*e4b17023SJohn Marino
4570*e4b17023SJohn Marino /* Store information from a DEFINE_BYPASS for future attribute
4571*e4b17023SJohn Marino generation. The only thing we care about is the list of output
4572*e4b17023SJohn Marino insns, which will later be used to tag reservation structures with
4573*e4b17023SJohn Marino a 'bypassed' bit. */
4574*e4b17023SJohn Marino
4575*e4b17023SJohn Marino struct bypass_list
4576*e4b17023SJohn Marino {
4577*e4b17023SJohn Marino struct bypass_list *next;
4578*e4b17023SJohn Marino const char *pattern;
4579*e4b17023SJohn Marino };
4580*e4b17023SJohn Marino
4581*e4b17023SJohn Marino static struct bypass_list *all_bypasses;
4582*e4b17023SJohn Marino static size_t n_bypasses;
4583*e4b17023SJohn Marino
4584*e4b17023SJohn Marino static void
gen_bypass_1(const char * s,size_t len)4585*e4b17023SJohn Marino gen_bypass_1 (const char *s, size_t len)
4586*e4b17023SJohn Marino {
4587*e4b17023SJohn Marino struct bypass_list *b;
4588*e4b17023SJohn Marino
4589*e4b17023SJohn Marino if (len == 0)
4590*e4b17023SJohn Marino return;
4591*e4b17023SJohn Marino
4592*e4b17023SJohn Marino s = attr_string (s, len);
4593*e4b17023SJohn Marino for (b = all_bypasses; b; b = b->next)
4594*e4b17023SJohn Marino if (s == b->pattern)
4595*e4b17023SJohn Marino return; /* already got that one */
4596*e4b17023SJohn Marino
4597*e4b17023SJohn Marino b = oballoc (struct bypass_list);
4598*e4b17023SJohn Marino b->pattern = s;
4599*e4b17023SJohn Marino b->next = all_bypasses;
4600*e4b17023SJohn Marino all_bypasses = b;
4601*e4b17023SJohn Marino n_bypasses++;
4602*e4b17023SJohn Marino }
4603*e4b17023SJohn Marino
4604*e4b17023SJohn Marino static void
gen_bypass(rtx def)4605*e4b17023SJohn Marino gen_bypass (rtx def)
4606*e4b17023SJohn Marino {
4607*e4b17023SJohn Marino const char *p, *base;
4608*e4b17023SJohn Marino
4609*e4b17023SJohn Marino for (p = base = XSTR (def, 1); *p; p++)
4610*e4b17023SJohn Marino if (*p == ',')
4611*e4b17023SJohn Marino {
4612*e4b17023SJohn Marino gen_bypass_1 (base, p - base);
4613*e4b17023SJohn Marino do
4614*e4b17023SJohn Marino p++;
4615*e4b17023SJohn Marino while (ISSPACE (*p));
4616*e4b17023SJohn Marino base = p;
4617*e4b17023SJohn Marino }
4618*e4b17023SJohn Marino gen_bypass_1 (base, p - base);
4619*e4b17023SJohn Marino }
4620*e4b17023SJohn Marino
4621*e4b17023SJohn Marino /* Find and mark all of the bypassed insns. */
4622*e4b17023SJohn Marino static void
process_bypasses(void)4623*e4b17023SJohn Marino process_bypasses (void)
4624*e4b17023SJohn Marino {
4625*e4b17023SJohn Marino struct bypass_list *b;
4626*e4b17023SJohn Marino struct insn_reserv *r;
4627*e4b17023SJohn Marino
4628*e4b17023SJohn Marino /* The reservation list is likely to be much longer than the bypass
4629*e4b17023SJohn Marino list. */
4630*e4b17023SJohn Marino for (r = all_insn_reservs; r; r = r->next)
4631*e4b17023SJohn Marino for (b = all_bypasses; b; b = b->next)
4632*e4b17023SJohn Marino if (fnmatch (b->pattern, r->name, 0) == 0)
4633*e4b17023SJohn Marino r->bypassed = true;
4634*e4b17023SJohn Marino }
4635*e4b17023SJohn Marino
4636*e4b17023SJohn Marino /* Check that attribute NAME is used in define_insn_reservation condition
4637*e4b17023SJohn Marino EXP. Return true if it is. */
4638*e4b17023SJohn Marino static bool
check_tune_attr(const char * name,rtx exp)4639*e4b17023SJohn Marino check_tune_attr (const char *name, rtx exp)
4640*e4b17023SJohn Marino {
4641*e4b17023SJohn Marino switch (GET_CODE (exp))
4642*e4b17023SJohn Marino {
4643*e4b17023SJohn Marino case AND:
4644*e4b17023SJohn Marino if (check_tune_attr (name, XEXP (exp, 0)))
4645*e4b17023SJohn Marino return true;
4646*e4b17023SJohn Marino return check_tune_attr (name, XEXP (exp, 1));
4647*e4b17023SJohn Marino
4648*e4b17023SJohn Marino case IOR:
4649*e4b17023SJohn Marino return (check_tune_attr (name, XEXP (exp, 0))
4650*e4b17023SJohn Marino && check_tune_attr (name, XEXP (exp, 1)));
4651*e4b17023SJohn Marino
4652*e4b17023SJohn Marino case EQ_ATTR:
4653*e4b17023SJohn Marino return XSTR (exp, 0) == name;
4654*e4b17023SJohn Marino
4655*e4b17023SJohn Marino default:
4656*e4b17023SJohn Marino return false;
4657*e4b17023SJohn Marino }
4658*e4b17023SJohn Marino }
4659*e4b17023SJohn Marino
4660*e4b17023SJohn Marino /* Try to find a const attribute (usually cpu or tune) that is used
4661*e4b17023SJohn Marino in all define_insn_reservation conditions. */
4662*e4b17023SJohn Marino static struct attr_desc *
find_tune_attr(rtx exp)4663*e4b17023SJohn Marino find_tune_attr (rtx exp)
4664*e4b17023SJohn Marino {
4665*e4b17023SJohn Marino struct attr_desc *attr;
4666*e4b17023SJohn Marino
4667*e4b17023SJohn Marino switch (GET_CODE (exp))
4668*e4b17023SJohn Marino {
4669*e4b17023SJohn Marino case AND:
4670*e4b17023SJohn Marino case IOR:
4671*e4b17023SJohn Marino attr = find_tune_attr (XEXP (exp, 0));
4672*e4b17023SJohn Marino if (attr)
4673*e4b17023SJohn Marino return attr;
4674*e4b17023SJohn Marino return find_tune_attr (XEXP (exp, 1));
4675*e4b17023SJohn Marino
4676*e4b17023SJohn Marino case EQ_ATTR:
4677*e4b17023SJohn Marino if (XSTR (exp, 0) == alternative_name)
4678*e4b17023SJohn Marino return NULL;
4679*e4b17023SJohn Marino
4680*e4b17023SJohn Marino attr = find_attr (&XSTR (exp, 0), 0);
4681*e4b17023SJohn Marino gcc_assert (attr);
4682*e4b17023SJohn Marino
4683*e4b17023SJohn Marino if (attr->is_const && !attr->is_special)
4684*e4b17023SJohn Marino {
4685*e4b17023SJohn Marino struct insn_reserv *decl;
4686*e4b17023SJohn Marino
4687*e4b17023SJohn Marino for (decl = all_insn_reservs; decl; decl = decl->next)
4688*e4b17023SJohn Marino if (! check_tune_attr (attr->name, decl->condexp))
4689*e4b17023SJohn Marino return NULL;
4690*e4b17023SJohn Marino return attr;
4691*e4b17023SJohn Marino }
4692*e4b17023SJohn Marino return NULL;
4693*e4b17023SJohn Marino
4694*e4b17023SJohn Marino default:
4695*e4b17023SJohn Marino return NULL;
4696*e4b17023SJohn Marino }
4697*e4b17023SJohn Marino }
4698*e4b17023SJohn Marino
4699*e4b17023SJohn Marino /* Create all of the attributes that describe automaton properties. */
4700*e4b17023SJohn Marino static void
make_automaton_attrs(void)4701*e4b17023SJohn Marino make_automaton_attrs (void)
4702*e4b17023SJohn Marino {
4703*e4b17023SJohn Marino int i;
4704*e4b17023SJohn Marino struct insn_reserv *decl;
4705*e4b17023SJohn Marino rtx code_exp, lats_exp, byps_exp;
4706*e4b17023SJohn Marino struct attr_desc *tune_attr;
4707*e4b17023SJohn Marino
4708*e4b17023SJohn Marino if (n_insn_reservs == 0)
4709*e4b17023SJohn Marino return;
4710*e4b17023SJohn Marino
4711*e4b17023SJohn Marino tune_attr = find_tune_attr (all_insn_reservs->condexp);
4712*e4b17023SJohn Marino if (tune_attr != NULL)
4713*e4b17023SJohn Marino {
4714*e4b17023SJohn Marino rtx *condexps = XNEWVEC (rtx, n_insn_reservs * 3);
4715*e4b17023SJohn Marino struct attr_value *val;
4716*e4b17023SJohn Marino bool first = true;
4717*e4b17023SJohn Marino
4718*e4b17023SJohn Marino gcc_assert (tune_attr->is_const
4719*e4b17023SJohn Marino && !tune_attr->is_special
4720*e4b17023SJohn Marino && !tune_attr->is_numeric);
4721*e4b17023SJohn Marino for (val = tune_attr->first_value; val; val = val->next)
4722*e4b17023SJohn Marino {
4723*e4b17023SJohn Marino if (val == tune_attr->default_val)
4724*e4b17023SJohn Marino continue;
4725*e4b17023SJohn Marino gcc_assert (GET_CODE (val->value) == CONST_STRING);
4726*e4b17023SJohn Marino printf ("static int internal_dfa_insn_code_%s (rtx);\n"
4727*e4b17023SJohn Marino "static int insn_default_latency_%s (rtx);\n",
4728*e4b17023SJohn Marino XSTR (val->value, 0), XSTR (val->value, 0));
4729*e4b17023SJohn Marino }
4730*e4b17023SJohn Marino
4731*e4b17023SJohn Marino printf ("\n");
4732*e4b17023SJohn Marino printf ("int (*internal_dfa_insn_code) (rtx);\n");
4733*e4b17023SJohn Marino printf ("int (*insn_default_latency) (rtx);\n");
4734*e4b17023SJohn Marino printf ("\n");
4735*e4b17023SJohn Marino printf ("void\n");
4736*e4b17023SJohn Marino printf ("init_sched_attrs (void)\n");
4737*e4b17023SJohn Marino printf ("{\n");
4738*e4b17023SJohn Marino
4739*e4b17023SJohn Marino for (val = tune_attr->first_value; val; val = val->next)
4740*e4b17023SJohn Marino {
4741*e4b17023SJohn Marino int j;
4742*e4b17023SJohn Marino char *name;
4743*e4b17023SJohn Marino rtx test = attr_rtx (EQ_ATTR, tune_attr->name, XSTR (val->value, 0));
4744*e4b17023SJohn Marino
4745*e4b17023SJohn Marino if (val == tune_attr->default_val)
4746*e4b17023SJohn Marino continue;
4747*e4b17023SJohn Marino for (decl = all_insn_reservs, i = 0;
4748*e4b17023SJohn Marino decl;
4749*e4b17023SJohn Marino decl = decl->next)
4750*e4b17023SJohn Marino {
4751*e4b17023SJohn Marino rtx ctest = test;
4752*e4b17023SJohn Marino rtx condexp
4753*e4b17023SJohn Marino = simplify_and_tree (decl->condexp, &ctest, -2, 0);
4754*e4b17023SJohn Marino if (condexp == false_rtx)
4755*e4b17023SJohn Marino continue;
4756*e4b17023SJohn Marino if (condexp == true_rtx)
4757*e4b17023SJohn Marino break;
4758*e4b17023SJohn Marino condexps[i] = condexp;
4759*e4b17023SJohn Marino condexps[i + 1] = make_numeric_value (decl->insn_num);
4760*e4b17023SJohn Marino condexps[i + 2] = make_numeric_value (decl->default_latency);
4761*e4b17023SJohn Marino i += 3;
4762*e4b17023SJohn Marino }
4763*e4b17023SJohn Marino
4764*e4b17023SJohn Marino code_exp = rtx_alloc (COND);
4765*e4b17023SJohn Marino lats_exp = rtx_alloc (COND);
4766*e4b17023SJohn Marino
4767*e4b17023SJohn Marino j = i / 3 * 2;
4768*e4b17023SJohn Marino XVEC (code_exp, 0) = rtvec_alloc (j);
4769*e4b17023SJohn Marino XVEC (lats_exp, 0) = rtvec_alloc (j);
4770*e4b17023SJohn Marino
4771*e4b17023SJohn Marino if (decl)
4772*e4b17023SJohn Marino {
4773*e4b17023SJohn Marino XEXP (code_exp, 1) = make_numeric_value (decl->insn_num);
4774*e4b17023SJohn Marino XEXP (lats_exp, 1) = make_numeric_value (decl->default_latency);
4775*e4b17023SJohn Marino }
4776*e4b17023SJohn Marino else
4777*e4b17023SJohn Marino {
4778*e4b17023SJohn Marino XEXP (code_exp, 1) = make_numeric_value (n_insn_reservs + 1);
4779*e4b17023SJohn Marino XEXP (lats_exp, 1) = make_numeric_value (0);
4780*e4b17023SJohn Marino }
4781*e4b17023SJohn Marino
4782*e4b17023SJohn Marino while (i > 0)
4783*e4b17023SJohn Marino {
4784*e4b17023SJohn Marino i -= 3;
4785*e4b17023SJohn Marino j -= 2;
4786*e4b17023SJohn Marino XVECEXP (code_exp, 0, j) = condexps[i];
4787*e4b17023SJohn Marino XVECEXP (lats_exp, 0, j) = condexps[i];
4788*e4b17023SJohn Marino
4789*e4b17023SJohn Marino XVECEXP (code_exp, 0, j + 1) = condexps[i + 1];
4790*e4b17023SJohn Marino XVECEXP (lats_exp, 0, j + 1) = condexps[i + 2];
4791*e4b17023SJohn Marino }
4792*e4b17023SJohn Marino
4793*e4b17023SJohn Marino name = XNEWVEC (char,
4794*e4b17023SJohn Marino sizeof ("*internal_dfa_insn_code_")
4795*e4b17023SJohn Marino + strlen (XSTR (val->value, 0)));
4796*e4b17023SJohn Marino strcpy (name, "*internal_dfa_insn_code_");
4797*e4b17023SJohn Marino strcat (name, XSTR (val->value, 0));
4798*e4b17023SJohn Marino make_internal_attr (name, code_exp, ATTR_NONE);
4799*e4b17023SJohn Marino strcpy (name, "*insn_default_latency_");
4800*e4b17023SJohn Marino strcat (name, XSTR (val->value, 0));
4801*e4b17023SJohn Marino make_internal_attr (name, lats_exp, ATTR_NONE);
4802*e4b17023SJohn Marino XDELETEVEC (name);
4803*e4b17023SJohn Marino
4804*e4b17023SJohn Marino if (first)
4805*e4b17023SJohn Marino {
4806*e4b17023SJohn Marino printf (" if (");
4807*e4b17023SJohn Marino first = false;
4808*e4b17023SJohn Marino }
4809*e4b17023SJohn Marino else
4810*e4b17023SJohn Marino printf (" else if (");
4811*e4b17023SJohn Marino write_test_expr (test, 0, 0);
4812*e4b17023SJohn Marino printf (")\n");
4813*e4b17023SJohn Marino printf (" {\n");
4814*e4b17023SJohn Marino printf (" internal_dfa_insn_code\n");
4815*e4b17023SJohn Marino printf (" = internal_dfa_insn_code_%s;\n",
4816*e4b17023SJohn Marino XSTR (val->value, 0));
4817*e4b17023SJohn Marino printf (" insn_default_latency\n");
4818*e4b17023SJohn Marino printf (" = insn_default_latency_%s;\n",
4819*e4b17023SJohn Marino XSTR (val->value, 0));
4820*e4b17023SJohn Marino printf (" }\n");
4821*e4b17023SJohn Marino }
4822*e4b17023SJohn Marino
4823*e4b17023SJohn Marino printf (" else\n");
4824*e4b17023SJohn Marino printf (" gcc_unreachable ();\n");
4825*e4b17023SJohn Marino printf ("}\n");
4826*e4b17023SJohn Marino printf ("\n");
4827*e4b17023SJohn Marino
4828*e4b17023SJohn Marino XDELETEVEC (condexps);
4829*e4b17023SJohn Marino }
4830*e4b17023SJohn Marino else
4831*e4b17023SJohn Marino {
4832*e4b17023SJohn Marino code_exp = rtx_alloc (COND);
4833*e4b17023SJohn Marino lats_exp = rtx_alloc (COND);
4834*e4b17023SJohn Marino
4835*e4b17023SJohn Marino XVEC (code_exp, 0) = rtvec_alloc (n_insn_reservs * 2);
4836*e4b17023SJohn Marino XVEC (lats_exp, 0) = rtvec_alloc (n_insn_reservs * 2);
4837*e4b17023SJohn Marino
4838*e4b17023SJohn Marino XEXP (code_exp, 1) = make_numeric_value (n_insn_reservs + 1);
4839*e4b17023SJohn Marino XEXP (lats_exp, 1) = make_numeric_value (0);
4840*e4b17023SJohn Marino
4841*e4b17023SJohn Marino for (decl = all_insn_reservs, i = 0;
4842*e4b17023SJohn Marino decl;
4843*e4b17023SJohn Marino decl = decl->next, i += 2)
4844*e4b17023SJohn Marino {
4845*e4b17023SJohn Marino XVECEXP (code_exp, 0, i) = decl->condexp;
4846*e4b17023SJohn Marino XVECEXP (lats_exp, 0, i) = decl->condexp;
4847*e4b17023SJohn Marino
4848*e4b17023SJohn Marino XVECEXP (code_exp, 0, i+1) = make_numeric_value (decl->insn_num);
4849*e4b17023SJohn Marino XVECEXP (lats_exp, 0, i+1)
4850*e4b17023SJohn Marino = make_numeric_value (decl->default_latency);
4851*e4b17023SJohn Marino }
4852*e4b17023SJohn Marino make_internal_attr ("*internal_dfa_insn_code", code_exp, ATTR_NONE);
4853*e4b17023SJohn Marino make_internal_attr ("*insn_default_latency", lats_exp, ATTR_NONE);
4854*e4b17023SJohn Marino }
4855*e4b17023SJohn Marino
4856*e4b17023SJohn Marino if (n_bypasses == 0)
4857*e4b17023SJohn Marino byps_exp = make_numeric_value (0);
4858*e4b17023SJohn Marino else
4859*e4b17023SJohn Marino {
4860*e4b17023SJohn Marino process_bypasses ();
4861*e4b17023SJohn Marino
4862*e4b17023SJohn Marino byps_exp = rtx_alloc (COND);
4863*e4b17023SJohn Marino XVEC (byps_exp, 0) = rtvec_alloc (n_bypasses * 2);
4864*e4b17023SJohn Marino XEXP (byps_exp, 1) = make_numeric_value (0);
4865*e4b17023SJohn Marino for (decl = all_insn_reservs, i = 0;
4866*e4b17023SJohn Marino decl;
4867*e4b17023SJohn Marino decl = decl->next)
4868*e4b17023SJohn Marino if (decl->bypassed)
4869*e4b17023SJohn Marino {
4870*e4b17023SJohn Marino XVECEXP (byps_exp, 0, i) = decl->condexp;
4871*e4b17023SJohn Marino XVECEXP (byps_exp, 0, i+1) = make_numeric_value (1);
4872*e4b17023SJohn Marino i += 2;
4873*e4b17023SJohn Marino }
4874*e4b17023SJohn Marino }
4875*e4b17023SJohn Marino
4876*e4b17023SJohn Marino make_internal_attr ("*bypass_p", byps_exp, ATTR_NONE);
4877*e4b17023SJohn Marino }
4878*e4b17023SJohn Marino
4879*e4b17023SJohn Marino int
main(int argc,char ** argv)4880*e4b17023SJohn Marino main (int argc, char **argv)
4881*e4b17023SJohn Marino {
4882*e4b17023SJohn Marino rtx desc;
4883*e4b17023SJohn Marino struct attr_desc *attr;
4884*e4b17023SJohn Marino struct insn_def *id;
4885*e4b17023SJohn Marino rtx tem;
4886*e4b17023SJohn Marino int i;
4887*e4b17023SJohn Marino
4888*e4b17023SJohn Marino progname = "genattrtab";
4889*e4b17023SJohn Marino
4890*e4b17023SJohn Marino if (!init_rtx_reader_args (argc, argv))
4891*e4b17023SJohn Marino return (FATAL_EXIT_CODE);
4892*e4b17023SJohn Marino
4893*e4b17023SJohn Marino obstack_init (hash_obstack);
4894*e4b17023SJohn Marino obstack_init (temp_obstack);
4895*e4b17023SJohn Marino
4896*e4b17023SJohn Marino /* Set up true and false rtx's */
4897*e4b17023SJohn Marino true_rtx = rtx_alloc (CONST_INT);
4898*e4b17023SJohn Marino XWINT (true_rtx, 0) = 1;
4899*e4b17023SJohn Marino false_rtx = rtx_alloc (CONST_INT);
4900*e4b17023SJohn Marino XWINT (false_rtx, 0) = 0;
4901*e4b17023SJohn Marino ATTR_IND_SIMPLIFIED_P (true_rtx) = ATTR_IND_SIMPLIFIED_P (false_rtx) = 1;
4902*e4b17023SJohn Marino ATTR_PERMANENT_P (true_rtx) = ATTR_PERMANENT_P (false_rtx) = 1;
4903*e4b17023SJohn Marino
4904*e4b17023SJohn Marino alternative_name = DEF_ATTR_STRING ("alternative");
4905*e4b17023SJohn Marino length_str = DEF_ATTR_STRING ("length");
4906*e4b17023SJohn Marino delay_type_str = DEF_ATTR_STRING ("*delay_type");
4907*e4b17023SJohn Marino delay_1_0_str = DEF_ATTR_STRING ("*delay_1_0");
4908*e4b17023SJohn Marino num_delay_slots_str = DEF_ATTR_STRING ("*num_delay_slots");
4909*e4b17023SJohn Marino
4910*e4b17023SJohn Marino printf ("/* Generated automatically by the program `genattrtab'\n\
4911*e4b17023SJohn Marino from the machine description file `md'. */\n\n");
4912*e4b17023SJohn Marino
4913*e4b17023SJohn Marino /* Read the machine description. */
4914*e4b17023SJohn Marino
4915*e4b17023SJohn Marino while (1)
4916*e4b17023SJohn Marino {
4917*e4b17023SJohn Marino int lineno;
4918*e4b17023SJohn Marino
4919*e4b17023SJohn Marino desc = read_md_rtx (&lineno, &insn_code_number);
4920*e4b17023SJohn Marino if (desc == NULL)
4921*e4b17023SJohn Marino break;
4922*e4b17023SJohn Marino
4923*e4b17023SJohn Marino switch (GET_CODE (desc))
4924*e4b17023SJohn Marino {
4925*e4b17023SJohn Marino case DEFINE_INSN:
4926*e4b17023SJohn Marino case DEFINE_PEEPHOLE:
4927*e4b17023SJohn Marino case DEFINE_ASM_ATTRIBUTES:
4928*e4b17023SJohn Marino gen_insn (desc, lineno);
4929*e4b17023SJohn Marino break;
4930*e4b17023SJohn Marino
4931*e4b17023SJohn Marino case DEFINE_ATTR:
4932*e4b17023SJohn Marino case DEFINE_ENUM_ATTR:
4933*e4b17023SJohn Marino gen_attr (desc, lineno);
4934*e4b17023SJohn Marino break;
4935*e4b17023SJohn Marino
4936*e4b17023SJohn Marino case DEFINE_DELAY:
4937*e4b17023SJohn Marino gen_delay (desc, lineno);
4938*e4b17023SJohn Marino break;
4939*e4b17023SJohn Marino
4940*e4b17023SJohn Marino case DEFINE_INSN_RESERVATION:
4941*e4b17023SJohn Marino gen_insn_reserv (desc);
4942*e4b17023SJohn Marino break;
4943*e4b17023SJohn Marino
4944*e4b17023SJohn Marino case DEFINE_BYPASS:
4945*e4b17023SJohn Marino gen_bypass (desc);
4946*e4b17023SJohn Marino break;
4947*e4b17023SJohn Marino
4948*e4b17023SJohn Marino default:
4949*e4b17023SJohn Marino break;
4950*e4b17023SJohn Marino }
4951*e4b17023SJohn Marino if (GET_CODE (desc) != DEFINE_ASM_ATTRIBUTES)
4952*e4b17023SJohn Marino insn_index_number++;
4953*e4b17023SJohn Marino }
4954*e4b17023SJohn Marino
4955*e4b17023SJohn Marino if (have_error)
4956*e4b17023SJohn Marino return FATAL_EXIT_CODE;
4957*e4b17023SJohn Marino
4958*e4b17023SJohn Marino insn_code_number++;
4959*e4b17023SJohn Marino
4960*e4b17023SJohn Marino /* If we didn't have a DEFINE_ASM_ATTRIBUTES, make a null one. */
4961*e4b17023SJohn Marino if (! got_define_asm_attributes)
4962*e4b17023SJohn Marino {
4963*e4b17023SJohn Marino tem = rtx_alloc (DEFINE_ASM_ATTRIBUTES);
4964*e4b17023SJohn Marino XVEC (tem, 0) = rtvec_alloc (0);
4965*e4b17023SJohn Marino gen_insn (tem, 0);
4966*e4b17023SJohn Marino }
4967*e4b17023SJohn Marino
4968*e4b17023SJohn Marino /* Expand DEFINE_DELAY information into new attribute. */
4969*e4b17023SJohn Marino if (num_delays)
4970*e4b17023SJohn Marino expand_delays ();
4971*e4b17023SJohn Marino
4972*e4b17023SJohn Marino printf ("#include \"config.h\"\n");
4973*e4b17023SJohn Marino printf ("#include \"system.h\"\n");
4974*e4b17023SJohn Marino printf ("#include \"coretypes.h\"\n");
4975*e4b17023SJohn Marino printf ("#include \"tm.h\"\n");
4976*e4b17023SJohn Marino printf ("#include \"rtl.h\"\n");
4977*e4b17023SJohn Marino printf ("#include \"insn-attr.h\"\n");
4978*e4b17023SJohn Marino printf ("#include \"tm_p.h\"\n");
4979*e4b17023SJohn Marino printf ("#include \"insn-config.h\"\n");
4980*e4b17023SJohn Marino printf ("#include \"recog.h\"\n");
4981*e4b17023SJohn Marino printf ("#include \"regs.h\"\n");
4982*e4b17023SJohn Marino printf ("#include \"output.h\"\n");
4983*e4b17023SJohn Marino printf ("#include \"diagnostic-core.h\"\n");
4984*e4b17023SJohn Marino printf ("#include \"flags.h\"\n");
4985*e4b17023SJohn Marino printf ("#include \"function.h\"\n");
4986*e4b17023SJohn Marino printf ("\n");
4987*e4b17023SJohn Marino printf ("#define operands recog_data.operand\n\n");
4988*e4b17023SJohn Marino
4989*e4b17023SJohn Marino /* Make `insn_alternatives'. */
4990*e4b17023SJohn Marino insn_alternatives = oballocvec (int, insn_code_number);
4991*e4b17023SJohn Marino for (id = defs; id; id = id->next)
4992*e4b17023SJohn Marino if (id->insn_code >= 0)
4993*e4b17023SJohn Marino insn_alternatives[id->insn_code] = (1 << id->num_alternatives) - 1;
4994*e4b17023SJohn Marino
4995*e4b17023SJohn Marino /* Make `insn_n_alternatives'. */
4996*e4b17023SJohn Marino insn_n_alternatives = oballocvec (int, insn_code_number);
4997*e4b17023SJohn Marino for (id = defs; id; id = id->next)
4998*e4b17023SJohn Marino if (id->insn_code >= 0)
4999*e4b17023SJohn Marino insn_n_alternatives[id->insn_code] = id->num_alternatives;
5000*e4b17023SJohn Marino
5001*e4b17023SJohn Marino /* Construct extra attributes for automata. */
5002*e4b17023SJohn Marino make_automaton_attrs ();
5003*e4b17023SJohn Marino
5004*e4b17023SJohn Marino /* Prepare to write out attribute subroutines by checking everything stored
5005*e4b17023SJohn Marino away and building the attribute cases. */
5006*e4b17023SJohn Marino
5007*e4b17023SJohn Marino check_defs ();
5008*e4b17023SJohn Marino
5009*e4b17023SJohn Marino for (i = 0; i < MAX_ATTRS_INDEX; i++)
5010*e4b17023SJohn Marino for (attr = attrs[i]; attr; attr = attr->next)
5011*e4b17023SJohn Marino attr->default_val->value
5012*e4b17023SJohn Marino = check_attr_value (attr->default_val->value, attr);
5013*e4b17023SJohn Marino
5014*e4b17023SJohn Marino if (have_error)
5015*e4b17023SJohn Marino return FATAL_EXIT_CODE;
5016*e4b17023SJohn Marino
5017*e4b17023SJohn Marino for (i = 0; i < MAX_ATTRS_INDEX; i++)
5018*e4b17023SJohn Marino for (attr = attrs[i]; attr; attr = attr->next)
5019*e4b17023SJohn Marino fill_attr (attr);
5020*e4b17023SJohn Marino
5021*e4b17023SJohn Marino /* Construct extra attributes for `length'. */
5022*e4b17023SJohn Marino make_length_attrs ();
5023*e4b17023SJohn Marino
5024*e4b17023SJohn Marino /* Perform any possible optimizations to speed up compilation. */
5025*e4b17023SJohn Marino optimize_attrs ();
5026*e4b17023SJohn Marino
5027*e4b17023SJohn Marino /* Now write out all the `gen_attr_...' routines. Do these before the
5028*e4b17023SJohn Marino special routines so that they get defined before they are used. */
5029*e4b17023SJohn Marino
5030*e4b17023SJohn Marino for (i = 0; i < MAX_ATTRS_INDEX; i++)
5031*e4b17023SJohn Marino for (attr = attrs[i]; attr; attr = attr->next)
5032*e4b17023SJohn Marino {
5033*e4b17023SJohn Marino if (! attr->is_special && ! attr->is_const)
5034*e4b17023SJohn Marino write_attr_get (attr);
5035*e4b17023SJohn Marino }
5036*e4b17023SJohn Marino
5037*e4b17023SJohn Marino /* Write out delay eligibility information, if DEFINE_DELAY present.
5038*e4b17023SJohn Marino (The function to compute the number of delay slots will be written
5039*e4b17023SJohn Marino below.) */
5040*e4b17023SJohn Marino if (num_delays)
5041*e4b17023SJohn Marino {
5042*e4b17023SJohn Marino write_eligible_delay ("delay");
5043*e4b17023SJohn Marino if (have_annul_true)
5044*e4b17023SJohn Marino write_eligible_delay ("annul_true");
5045*e4b17023SJohn Marino if (have_annul_false)
5046*e4b17023SJohn Marino write_eligible_delay ("annul_false");
5047*e4b17023SJohn Marino }
5048*e4b17023SJohn Marino
5049*e4b17023SJohn Marino /* Write out constant delay slot info. */
5050*e4b17023SJohn Marino write_const_num_delay_slots ();
5051*e4b17023SJohn Marino
5052*e4b17023SJohn Marino write_length_unit_log ();
5053*e4b17023SJohn Marino
5054*e4b17023SJohn Marino fflush (stdout);
5055*e4b17023SJohn Marino return (ferror (stdout) != 0 ? FATAL_EXIT_CODE : SUCCESS_EXIT_CODE);
5056*e4b17023SJohn Marino }
5057