Daily bump.
[official-gcc.git] / gcc / genattrtab.c
blob99b1b83f4cbdd1ad9952bad73874a474bb19fae5
1 /* Generate code from machine description to compute values of attributes.
2 Copyright (C) 1991-2014 Free Software Foundation, Inc.
3 Contributed by Richard Kenner (kenner@vlsi1.ultra.nyu.edu)
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 3, or (at your option) any later
10 version.
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
15 for more details.
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
21 /* This program handles insn attributes and the DEFINE_DELAY and
22 DEFINE_INSN_RESERVATION definitions.
24 It produces a series of functions named `get_attr_...', one for each insn
25 attribute. Each of these is given the rtx for an insn and returns a member
26 of the enum for the attribute.
28 These subroutines have the form of a `switch' on the INSN_CODE (via
29 `recog_memoized'). Each case either returns a constant attribute value
30 or a value that depends on tests on other attributes, the form of
31 operands, or some random C expression (encoded with a SYMBOL_REF
32 expression).
34 If the attribute `alternative', or a random C expression is present,
35 `constrain_operands' is called. If either of these cases of a reference to
36 an operand is found, `extract_insn' is called.
38 The special attribute `length' is also recognized. For this operand,
39 expressions involving the address of an operand or the current insn,
40 (address (pc)), are valid. In this case, an initial pass is made to
41 set all lengths that do not depend on address. Those that do are set to
42 the maximum length. Then each insn that depends on an address is checked
43 and possibly has its length changed. The process repeats until no further
44 changed are made. The resulting lengths are saved for use by
45 `get_attr_length'.
47 A special form of DEFINE_ATTR, where the expression for default value is a
48 CONST expression, indicates an attribute that is constant for a given run
49 of the compiler. The subroutine generated for these attributes has no
50 parameters as it does not depend on any particular insn. Constant
51 attributes are typically used to specify which variety of processor is
52 used.
54 Internal attributes are defined to handle DEFINE_DELAY and
55 DEFINE_INSN_RESERVATION. Special routines are output for these cases.
57 This program works by keeping a list of possible values for each attribute.
58 These include the basic attribute choices, default values for attribute, and
59 all derived quantities.
61 As the description file is read, the definition for each insn is saved in a
62 `struct insn_def'. When the file reading is complete, a `struct insn_ent'
63 is created for each insn and chained to the corresponding attribute value,
64 either that specified, or the default.
66 An optimization phase is then run. This simplifies expressions for each
67 insn. EQ_ATTR tests are resolved, whenever possible, to a test that
68 indicates when the attribute has the specified value for the insn. This
69 avoids recursive calls during compilation.
71 The strategy used when processing DEFINE_DELAY definitions is to create
72 arbitrarily complex expressions and have the optimization simplify them.
74 Once optimization is complete, any required routines and definitions
75 will be written.
77 An optimization that is not yet implemented is to hoist the constant
78 expressions entirely out of the routines and definitions that are written.
79 A way to do this is to iterate over all possible combinations of values
80 for constant attributes and generate a set of functions for that given
81 combination. An initialization function would be written that evaluates
82 the attributes and installs the corresponding set of routines and
83 definitions (each would be accessed through a pointer).
85 We use the flags in an RTX as follows:
86 `unchanging' (ATTR_IND_SIMPLIFIED_P): This rtx is fully simplified
87 independent of the insn code.
88 `in_struct' (ATTR_CURR_SIMPLIFIED_P): This rtx is fully simplified
89 for the insn code currently being processed (see optimize_attrs).
90 `return_val' (ATTR_PERMANENT_P): This rtx is permanent and unique
91 (see attr_rtx). */
93 #define ATTR_IND_SIMPLIFIED_P(RTX) (RTX_FLAG ((RTX), unchanging))
94 #define ATTR_CURR_SIMPLIFIED_P(RTX) (RTX_FLAG ((RTX), in_struct))
95 #define ATTR_PERMANENT_P(RTX) (RTX_FLAG ((RTX), return_val))
97 #if 0
98 #define strcmp_check(S1, S2) ((S1) == (S2) \
99 ? 0 \
100 : (gcc_assert (strcmp ((S1), (S2))), 1))
101 #else
102 #define strcmp_check(S1, S2) ((S1) != (S2))
103 #endif
105 #include "bconfig.h"
106 #include "system.h"
107 #include "coretypes.h"
108 #include "tm.h"
109 #include "rtl.h"
110 #include "obstack.h"
111 #include "errors.h"
112 #include "read-md.h"
113 #include "gensupport.h"
114 #include "fnmatch.h"
116 #define DEBUG 0
118 /* Flags for make_internal_attr's `special' parameter. */
119 #define ATTR_NONE 0
120 #define ATTR_SPECIAL (1 << 0)
122 static struct obstack obstack1, obstack2;
123 static struct obstack *hash_obstack = &obstack1;
124 static struct obstack *temp_obstack = &obstack2;
126 /* enough space to reserve for printing out ints */
127 #define MAX_DIGITS (HOST_BITS_PER_INT * 3 / 10 + 3)
129 /* Define structures used to record attributes and values. */
131 /* As each DEFINE_INSN, DEFINE_PEEPHOLE, or DEFINE_ASM_ATTRIBUTES is
132 encountered, we store all the relevant information into a
133 `struct insn_def'. This is done to allow attribute definitions to occur
134 anywhere in the file. */
136 struct insn_def
138 struct insn_def *next; /* Next insn in chain. */
139 rtx def; /* The DEFINE_... */
140 int insn_code; /* Instruction number. */
141 int insn_index; /* Expression number in file, for errors. */
142 int lineno; /* Line number. */
143 int num_alternatives; /* Number of alternatives. */
144 int vec_idx; /* Index of attribute vector in `def'. */
147 /* Once everything has been read in, we store in each attribute value a list
148 of insn codes that have that value. Here is the structure used for the
149 list. */
151 struct insn_ent
153 struct insn_ent *next; /* Next in chain. */
154 struct insn_def *def; /* Instruction definition. */
157 /* Each value of an attribute (either constant or computed) is assigned a
158 structure which is used as the listhead of the insns that have that
159 value. */
161 struct attr_value
163 rtx value; /* Value of attribute. */
164 struct attr_value *next; /* Next attribute value in chain. */
165 struct insn_ent *first_insn; /* First insn with this value. */
166 int num_insns; /* Number of insns with this value. */
167 int has_asm_insn; /* True if this value used for `asm' insns */
170 /* Structure for each attribute. */
172 struct attr_desc
174 char *name; /* Name of attribute. */
175 const char *enum_name; /* Enum name for DEFINE_ENUM_NAME. */
176 struct attr_desc *next; /* Next attribute. */
177 struct attr_value *first_value; /* First value of this attribute. */
178 struct attr_value *default_val; /* Default value for this attribute. */
179 int lineno : 24; /* Line number. */
180 unsigned is_numeric : 1; /* Values of this attribute are numeric. */
181 unsigned is_const : 1; /* Attribute value constant for each run. */
182 unsigned is_special : 1; /* Don't call `write_attr_set'. */
185 /* Structure for each DEFINE_DELAY. */
187 struct delay_desc
189 rtx def; /* DEFINE_DELAY expression. */
190 struct delay_desc *next; /* Next DEFINE_DELAY. */
191 int num; /* Number of DEFINE_DELAY, starting at 1. */
192 int lineno; /* Line number. */
195 struct attr_value_list
197 struct attr_value *av;
198 struct insn_ent *ie;
199 struct attr_desc *attr;
200 struct attr_value_list *next;
203 /* Listheads of above structures. */
205 /* This one is indexed by the first character of the attribute name. */
206 #define MAX_ATTRS_INDEX 256
207 static struct attr_desc *attrs[MAX_ATTRS_INDEX];
208 static struct insn_def *defs;
209 static struct delay_desc *delays;
210 struct attr_value_list **insn_code_values;
212 /* Other variables. */
214 static int insn_code_number;
215 static int insn_index_number;
216 static int got_define_asm_attributes;
217 static int must_extract;
218 static int must_constrain;
219 static int address_used;
220 static int length_used;
221 static int num_delays;
222 static int have_annul_true, have_annul_false;
223 static int num_insn_ents;
225 /* Stores, for each insn code, the number of constraint alternatives. */
227 static int *insn_n_alternatives;
229 /* Stores, for each insn code, a bitmap that has bits on for each possible
230 alternative. */
232 static int *insn_alternatives;
234 /* Used to simplify expressions. */
236 static rtx true_rtx, false_rtx;
238 /* Used to reduce calls to `strcmp' */
240 static const char *alternative_name;
241 static const char *length_str;
242 static const char *delay_type_str;
243 static const char *delay_1_0_str;
244 static const char *num_delay_slots_str;
246 /* Simplify an expression. Only call the routine if there is something to
247 simplify. */
248 #define SIMPLIFY_TEST_EXP(EXP,INSN_CODE,INSN_INDEX) \
249 (ATTR_IND_SIMPLIFIED_P (EXP) || ATTR_CURR_SIMPLIFIED_P (EXP) ? (EXP) \
250 : simplify_test_exp (EXP, INSN_CODE, INSN_INDEX))
252 #define DEF_ATTR_STRING(S) (attr_string ((S), strlen (S)))
254 /* Forward declarations of functions used before their definitions, only. */
255 static char *attr_string (const char *, int);
256 static char *attr_printf (unsigned int, const char *, ...)
257 ATTRIBUTE_PRINTF_2;
258 static rtx make_numeric_value (int);
259 static struct attr_desc *find_attr (const char **, int);
260 static rtx mk_attr_alt (int);
261 static char *next_comma_elt (const char **);
262 static rtx insert_right_side (enum rtx_code, rtx, rtx, int, int);
263 static rtx copy_boolean (rtx);
264 static int compares_alternatives_p (rtx);
265 static void make_internal_attr (const char *, rtx, int);
266 static void insert_insn_ent (struct attr_value *, struct insn_ent *);
267 static void walk_attr_value (rtx);
268 static int max_attr_value (rtx, int*);
269 static int min_attr_value (rtx, int*);
270 static int or_attr_value (rtx, int*);
271 static rtx simplify_test_exp (rtx, int, int);
272 static rtx simplify_test_exp_in_temp (rtx, int, int);
273 static rtx copy_rtx_unchanging (rtx);
274 static bool attr_alt_subset_p (rtx, rtx);
275 static bool attr_alt_subset_of_compl_p (rtx, rtx);
276 static void clear_struct_flag (rtx);
277 static void write_attr_valueq (FILE *, struct attr_desc *, const char *);
278 static struct attr_value *find_most_used (struct attr_desc *);
279 static void write_attr_set (FILE *, struct attr_desc *, int, rtx,
280 const char *, const char *, rtx,
281 int, int, unsigned int);
282 static void write_attr_case (FILE *, struct attr_desc *,
283 struct attr_value *,
284 int, const char *, const char *, int, rtx);
285 static void write_attr_value (FILE *, struct attr_desc *, rtx);
286 static void write_upcase (FILE *, const char *);
287 static void write_indent (FILE *, int);
288 static rtx identity_fn (rtx);
289 static rtx zero_fn (rtx);
290 static rtx one_fn (rtx);
291 static rtx max_fn (rtx);
292 static rtx min_fn (rtx);
294 #define oballoc(T) XOBNEW (hash_obstack, T)
295 #define oballocvec(T, N) XOBNEWVEC (hash_obstack, T, (N))
297 /* This gen* file is unique, in that it writes out multiple files.
299 Before GCC 4.8, insn-attrtab.c was written out containing many large
300 functions and tables. This made insn-attrtab.c _the_ bottle-neck in
301 a parallel build, and even made it impossible to build GCC on machines
302 with relatively small RAM space (PR other/29442). Therefore, the
303 atrribute functions/tables are now written out to three separate
304 files: all "*insn_default_latency" functions go to LATENCY_FILE_NAME,
305 all "*internal_dfa_insn_code" functions go to DFA_FILE_NAME, and the
306 rest goes to ATTR_FILE_NAME. */
308 static const char *attr_file_name = NULL;
309 static const char *dfa_file_name = NULL;
310 static const char *latency_file_name = NULL;
312 static FILE *attr_file, *dfa_file, *latency_file;
314 /* Hash table for sharing RTL and strings. */
316 /* Each hash table slot is a bucket containing a chain of these structures.
317 Strings are given negative hash codes; RTL expressions are given positive
318 hash codes. */
320 struct attr_hash
322 struct attr_hash *next; /* Next structure in the bucket. */
323 unsigned int hashcode; /* Hash code of this rtx or string. */
324 union
326 char *str; /* The string (negative hash codes) */
327 rtx rtl; /* or the RTL recorded here. */
328 } u;
331 /* Now here is the hash table. When recording an RTL, it is added to
332 the slot whose index is the hash code mod the table size. Note
333 that the hash table is used for several kinds of RTL (see attr_rtx)
334 and for strings. While all these live in the same table, they are
335 completely independent, and the hash code is computed differently
336 for each. */
338 #define RTL_HASH_SIZE 4093
339 static struct attr_hash *attr_hash_table[RTL_HASH_SIZE];
341 /* Here is how primitive or already-shared RTL's hash
342 codes are made. */
343 #define RTL_HASH(RTL) ((intptr_t) (RTL) & 0777777)
345 /* Add an entry to the hash table for RTL with hash code HASHCODE. */
347 static void
348 attr_hash_add_rtx (unsigned int hashcode, rtx rtl)
350 struct attr_hash *h;
352 h = XOBNEW (hash_obstack, struct attr_hash);
353 h->hashcode = hashcode;
354 h->u.rtl = rtl;
355 h->next = attr_hash_table[hashcode % RTL_HASH_SIZE];
356 attr_hash_table[hashcode % RTL_HASH_SIZE] = h;
359 /* Add an entry to the hash table for STRING with hash code HASHCODE. */
361 static void
362 attr_hash_add_string (unsigned int hashcode, char *str)
364 struct attr_hash *h;
366 h = XOBNEW (hash_obstack, struct attr_hash);
367 h->hashcode = -hashcode;
368 h->u.str = str;
369 h->next = attr_hash_table[hashcode % RTL_HASH_SIZE];
370 attr_hash_table[hashcode % RTL_HASH_SIZE] = h;
373 /* Generate an RTL expression, but avoid duplicates.
374 Set the ATTR_PERMANENT_P flag for these permanent objects.
376 In some cases we cannot uniquify; then we return an ordinary
377 impermanent rtx with ATTR_PERMANENT_P clear.
379 Args are as follows:
381 rtx attr_rtx (code, [element1, ..., elementn]) */
383 static rtx
384 attr_rtx_1 (enum rtx_code code, va_list p)
386 rtx rt_val = NULL_RTX;/* RTX to return to caller... */
387 unsigned int hashcode;
388 struct attr_hash *h;
389 struct obstack *old_obstack = rtl_obstack;
391 /* For each of several cases, search the hash table for an existing entry.
392 Use that entry if one is found; otherwise create a new RTL and add it
393 to the table. */
395 if (GET_RTX_CLASS (code) == RTX_UNARY)
397 rtx arg0 = va_arg (p, rtx);
399 /* A permanent object cannot point to impermanent ones. */
400 if (! ATTR_PERMANENT_P (arg0))
402 rt_val = rtx_alloc (code);
403 XEXP (rt_val, 0) = arg0;
404 return rt_val;
407 hashcode = ((HOST_WIDE_INT) code + RTL_HASH (arg0));
408 for (h = attr_hash_table[hashcode % RTL_HASH_SIZE]; h; h = h->next)
409 if (h->hashcode == hashcode
410 && GET_CODE (h->u.rtl) == code
411 && XEXP (h->u.rtl, 0) == arg0)
412 return h->u.rtl;
414 if (h == 0)
416 rtl_obstack = hash_obstack;
417 rt_val = rtx_alloc (code);
418 XEXP (rt_val, 0) = arg0;
421 else if (GET_RTX_CLASS (code) == RTX_BIN_ARITH
422 || GET_RTX_CLASS (code) == RTX_COMM_ARITH
423 || GET_RTX_CLASS (code) == RTX_COMPARE
424 || GET_RTX_CLASS (code) == RTX_COMM_COMPARE)
426 rtx arg0 = va_arg (p, rtx);
427 rtx arg1 = va_arg (p, rtx);
429 /* A permanent object cannot point to impermanent ones. */
430 if (! ATTR_PERMANENT_P (arg0) || ! ATTR_PERMANENT_P (arg1))
432 rt_val = rtx_alloc (code);
433 XEXP (rt_val, 0) = arg0;
434 XEXP (rt_val, 1) = arg1;
435 return rt_val;
438 hashcode = ((HOST_WIDE_INT) code + RTL_HASH (arg0) + RTL_HASH (arg1));
439 for (h = attr_hash_table[hashcode % RTL_HASH_SIZE]; h; h = h->next)
440 if (h->hashcode == hashcode
441 && GET_CODE (h->u.rtl) == code
442 && XEXP (h->u.rtl, 0) == arg0
443 && XEXP (h->u.rtl, 1) == arg1)
444 return h->u.rtl;
446 if (h == 0)
448 rtl_obstack = hash_obstack;
449 rt_val = rtx_alloc (code);
450 XEXP (rt_val, 0) = arg0;
451 XEXP (rt_val, 1) = arg1;
454 else if (code == SYMBOL_REF
455 || (GET_RTX_LENGTH (code) == 1
456 && GET_RTX_FORMAT (code)[0] == 's'))
458 char *arg0 = va_arg (p, char *);
460 arg0 = DEF_ATTR_STRING (arg0);
462 hashcode = ((HOST_WIDE_INT) code + RTL_HASH (arg0));
463 for (h = attr_hash_table[hashcode % RTL_HASH_SIZE]; h; h = h->next)
464 if (h->hashcode == hashcode
465 && GET_CODE (h->u.rtl) == code
466 && XSTR (h->u.rtl, 0) == arg0)
467 return h->u.rtl;
469 if (h == 0)
471 rtl_obstack = hash_obstack;
472 rt_val = rtx_alloc (code);
473 XSTR (rt_val, 0) = arg0;
474 if (code == SYMBOL_REF)
476 X0EXP (rt_val, 1) = NULL_RTX;
477 X0EXP (rt_val, 2) = NULL_RTX;
481 else if (GET_RTX_LENGTH (code) == 2
482 && GET_RTX_FORMAT (code)[0] == 's'
483 && GET_RTX_FORMAT (code)[1] == 's')
485 char *arg0 = va_arg (p, char *);
486 char *arg1 = va_arg (p, char *);
488 hashcode = ((HOST_WIDE_INT) code + RTL_HASH (arg0) + RTL_HASH (arg1));
489 for (h = attr_hash_table[hashcode % RTL_HASH_SIZE]; h; h = h->next)
490 if (h->hashcode == hashcode
491 && GET_CODE (h->u.rtl) == code
492 && XSTR (h->u.rtl, 0) == arg0
493 && XSTR (h->u.rtl, 1) == arg1)
494 return h->u.rtl;
496 if (h == 0)
498 rtl_obstack = hash_obstack;
499 rt_val = rtx_alloc (code);
500 XSTR (rt_val, 0) = arg0;
501 XSTR (rt_val, 1) = arg1;
504 else if (code == CONST_INT)
506 HOST_WIDE_INT arg0 = va_arg (p, HOST_WIDE_INT);
507 if (arg0 == 0)
508 return false_rtx;
509 else if (arg0 == 1)
510 return true_rtx;
511 else
512 goto nohash;
514 else
516 int i; /* Array indices... */
517 const char *fmt; /* Current rtx's format... */
518 nohash:
519 rt_val = rtx_alloc (code); /* Allocate the storage space. */
521 fmt = GET_RTX_FORMAT (code); /* Find the right format... */
522 for (i = 0; i < GET_RTX_LENGTH (code); i++)
524 switch (*fmt++)
526 case '0': /* Unused field. */
527 break;
529 case 'i': /* An integer? */
530 XINT (rt_val, i) = va_arg (p, int);
531 break;
533 case 'w': /* A wide integer? */
534 XWINT (rt_val, i) = va_arg (p, HOST_WIDE_INT);
535 break;
537 case 's': /* A string? */
538 XSTR (rt_val, i) = va_arg (p, char *);
539 break;
541 case 'e': /* An expression? */
542 case 'u': /* An insn? Same except when printing. */
543 XEXP (rt_val, i) = va_arg (p, rtx);
544 break;
546 case 'E': /* An RTX vector? */
547 XVEC (rt_val, i) = va_arg (p, rtvec);
548 break;
550 default:
551 gcc_unreachable ();
554 return rt_val;
557 rtl_obstack = old_obstack;
558 attr_hash_add_rtx (hashcode, rt_val);
559 ATTR_PERMANENT_P (rt_val) = 1;
560 return rt_val;
563 static rtx
564 attr_rtx (enum rtx_code code, ...)
566 rtx result;
567 va_list p;
569 va_start (p, code);
570 result = attr_rtx_1 (code, p);
571 va_end (p);
572 return result;
575 /* Create a new string printed with the printf line arguments into a space
576 of at most LEN bytes:
578 rtx attr_printf (len, format, [arg1, ..., argn]) */
580 static char *
581 attr_printf (unsigned int len, const char *fmt, ...)
583 char str[256];
584 va_list p;
586 va_start (p, fmt);
588 gcc_assert (len < sizeof str); /* Leave room for \0. */
590 vsprintf (str, fmt, p);
591 va_end (p);
593 return DEF_ATTR_STRING (str);
596 static rtx
597 attr_eq (const char *name, const char *value)
599 return attr_rtx (EQ_ATTR, DEF_ATTR_STRING (name), DEF_ATTR_STRING (value));
602 static const char *
603 attr_numeral (int n)
605 return XSTR (make_numeric_value (n), 0);
608 /* Return a permanent (possibly shared) copy of a string STR (not assumed
609 to be null terminated) with LEN bytes. */
611 static char *
612 attr_string (const char *str, int len)
614 struct attr_hash *h;
615 unsigned int hashcode;
616 int i;
617 char *new_str;
619 /* Compute the hash code. */
620 hashcode = (len + 1) * 613U + (unsigned) str[0];
621 for (i = 1; i < len; i += 2)
622 hashcode = ((hashcode * 613) + (unsigned) str[i]);
623 if ((int) hashcode < 0)
624 hashcode = -hashcode;
626 /* Search the table for the string. */
627 for (h = attr_hash_table[hashcode % RTL_HASH_SIZE]; h; h = h->next)
628 if (h->hashcode == -hashcode && h->u.str[0] == str[0]
629 && !strncmp (h->u.str, str, len))
630 return h->u.str; /* <-- return if found. */
632 /* Not found; create a permanent copy and add it to the hash table. */
633 new_str = XOBNEWVAR (hash_obstack, char, len + 1);
634 memcpy (new_str, str, len);
635 new_str[len] = '\0';
636 attr_hash_add_string (hashcode, new_str);
637 copy_md_ptr_loc (new_str, str);
639 return new_str; /* Return the new string. */
642 /* Check two rtx's for equality of contents,
643 taking advantage of the fact that if both are hashed
644 then they can't be equal unless they are the same object. */
646 static int
647 attr_equal_p (rtx x, rtx y)
649 return (x == y || (! (ATTR_PERMANENT_P (x) && ATTR_PERMANENT_P (y))
650 && rtx_equal_p (x, y)));
653 /* Copy an attribute value expression,
654 descending to all depths, but not copying any
655 permanent hashed subexpressions. */
657 static rtx
658 attr_copy_rtx (rtx orig)
660 rtx copy;
661 int i, j;
662 RTX_CODE code;
663 const char *format_ptr;
665 /* No need to copy a permanent object. */
666 if (ATTR_PERMANENT_P (orig))
667 return orig;
669 code = GET_CODE (orig);
671 switch (code)
673 case REG:
674 CASE_CONST_ANY:
675 case SYMBOL_REF:
676 case MATCH_TEST:
677 case CODE_LABEL:
678 case PC:
679 case CC0:
680 return orig;
682 default:
683 break;
686 copy = rtx_alloc (code);
687 PUT_MODE (copy, GET_MODE (orig));
688 ATTR_IND_SIMPLIFIED_P (copy) = ATTR_IND_SIMPLIFIED_P (orig);
689 ATTR_CURR_SIMPLIFIED_P (copy) = ATTR_CURR_SIMPLIFIED_P (orig);
690 ATTR_PERMANENT_P (copy) = ATTR_PERMANENT_P (orig);
692 format_ptr = GET_RTX_FORMAT (GET_CODE (copy));
694 for (i = 0; i < GET_RTX_LENGTH (GET_CODE (copy)); i++)
696 switch (*format_ptr++)
698 case 'e':
699 XEXP (copy, i) = XEXP (orig, i);
700 if (XEXP (orig, i) != NULL)
701 XEXP (copy, i) = attr_copy_rtx (XEXP (orig, i));
702 break;
704 case 'E':
705 case 'V':
706 XVEC (copy, i) = XVEC (orig, i);
707 if (XVEC (orig, i) != NULL)
709 XVEC (copy, i) = rtvec_alloc (XVECLEN (orig, i));
710 for (j = 0; j < XVECLEN (copy, i); j++)
711 XVECEXP (copy, i, j) = attr_copy_rtx (XVECEXP (orig, i, j));
713 break;
715 case 'n':
716 case 'i':
717 XINT (copy, i) = XINT (orig, i);
718 break;
720 case 'w':
721 XWINT (copy, i) = XWINT (orig, i);
722 break;
724 case 's':
725 case 'S':
726 XSTR (copy, i) = XSTR (orig, i);
727 break;
729 default:
730 gcc_unreachable ();
733 return copy;
736 /* Given a test expression for an attribute, ensure it is validly formed.
737 IS_CONST indicates whether the expression is constant for each compiler
738 run (a constant expression may not test any particular insn).
740 Convert (eq_attr "att" "a1,a2") to (ior (eq_attr ... ) (eq_attrq ..))
741 and (eq_attr "att" "!a1") to (not (eq_attr "att" "a1")). Do the latter
742 test first so that (eq_attr "att" "!a1,a2,a3") works as expected.
744 Update the string address in EQ_ATTR expression to be the same used
745 in the attribute (or `alternative_name') to speed up subsequent
746 `find_attr' calls and eliminate most `strcmp' calls.
748 Return the new expression, if any. */
750 static rtx
751 check_attr_test (rtx exp, int is_const, int lineno)
753 struct attr_desc *attr;
754 struct attr_value *av;
755 const char *name_ptr, *p;
756 rtx orexp, newexp;
758 switch (GET_CODE (exp))
760 case EQ_ATTR:
761 /* Handle negation test. */
762 if (XSTR (exp, 1)[0] == '!')
763 return check_attr_test (attr_rtx (NOT,
764 attr_eq (XSTR (exp, 0),
765 &XSTR (exp, 1)[1])),
766 is_const, lineno);
768 else if (n_comma_elts (XSTR (exp, 1)) == 1)
770 attr = find_attr (&XSTR (exp, 0), 0);
771 if (attr == NULL)
773 if (! strcmp (XSTR (exp, 0), "alternative"))
774 return mk_attr_alt (1 << atoi (XSTR (exp, 1)));
775 else
776 fatal ("unknown attribute `%s' in EQ_ATTR", XSTR (exp, 0));
779 if (is_const && ! attr->is_const)
780 fatal ("constant expression uses insn attribute `%s' in EQ_ATTR",
781 XSTR (exp, 0));
783 /* Copy this just to make it permanent,
784 so expressions using it can be permanent too. */
785 exp = attr_eq (XSTR (exp, 0), XSTR (exp, 1));
787 /* It shouldn't be possible to simplify the value given to a
788 constant attribute, so don't expand this until it's time to
789 write the test expression. */
790 if (attr->is_const)
791 ATTR_IND_SIMPLIFIED_P (exp) = 1;
793 if (attr->is_numeric)
795 for (p = XSTR (exp, 1); *p; p++)
796 if (! ISDIGIT (*p))
797 fatal ("attribute `%s' takes only numeric values",
798 XSTR (exp, 0));
800 else
802 for (av = attr->first_value; av; av = av->next)
803 if (GET_CODE (av->value) == CONST_STRING
804 && ! strcmp (XSTR (exp, 1), XSTR (av->value, 0)))
805 break;
807 if (av == NULL)
808 fatal ("unknown value `%s' for `%s' attribute",
809 XSTR (exp, 1), XSTR (exp, 0));
812 else
814 if (! strcmp (XSTR (exp, 0), "alternative"))
816 int set = 0;
818 name_ptr = XSTR (exp, 1);
819 while ((p = next_comma_elt (&name_ptr)) != NULL)
820 set |= 1 << atoi (p);
822 return mk_attr_alt (set);
824 else
826 /* Make an IOR tree of the possible values. */
827 orexp = false_rtx;
828 name_ptr = XSTR (exp, 1);
829 while ((p = next_comma_elt (&name_ptr)) != NULL)
831 newexp = attr_eq (XSTR (exp, 0), p);
832 orexp = insert_right_side (IOR, orexp, newexp, -2, -2);
835 return check_attr_test (orexp, is_const, lineno);
838 break;
840 case ATTR_FLAG:
841 break;
843 case CONST_INT:
844 /* Either TRUE or FALSE. */
845 if (XWINT (exp, 0))
846 return true_rtx;
847 else
848 return false_rtx;
850 case IOR:
851 case AND:
852 XEXP (exp, 0) = check_attr_test (XEXP (exp, 0), is_const, lineno);
853 XEXP (exp, 1) = check_attr_test (XEXP (exp, 1), is_const, lineno);
854 break;
856 case NOT:
857 XEXP (exp, 0) = check_attr_test (XEXP (exp, 0), is_const, lineno);
858 break;
860 case MATCH_TEST:
861 exp = attr_rtx (MATCH_TEST, XSTR (exp, 0));
862 ATTR_IND_SIMPLIFIED_P (exp) = 1;
863 break;
865 case MATCH_OPERAND:
866 if (is_const)
867 fatal ("RTL operator \"%s\" not valid in constant attribute test",
868 GET_RTX_NAME (GET_CODE (exp)));
869 /* These cases can't be simplified. */
870 ATTR_IND_SIMPLIFIED_P (exp) = 1;
871 break;
873 case LE: case LT: case GT: case GE:
874 case LEU: case LTU: case GTU: case GEU:
875 case NE: case EQ:
876 if (GET_CODE (XEXP (exp, 0)) == SYMBOL_REF
877 && GET_CODE (XEXP (exp, 1)) == SYMBOL_REF)
878 exp = attr_rtx (GET_CODE (exp),
879 attr_rtx (SYMBOL_REF, XSTR (XEXP (exp, 0), 0)),
880 attr_rtx (SYMBOL_REF, XSTR (XEXP (exp, 1), 0)));
881 /* These cases can't be simplified. */
882 ATTR_IND_SIMPLIFIED_P (exp) = 1;
883 break;
885 case SYMBOL_REF:
886 if (is_const)
888 /* These cases are valid for constant attributes, but can't be
889 simplified. */
890 exp = attr_rtx (SYMBOL_REF, XSTR (exp, 0));
891 ATTR_IND_SIMPLIFIED_P (exp) = 1;
892 break;
894 default:
895 fatal ("RTL operator \"%s\" not valid in attribute test",
896 GET_RTX_NAME (GET_CODE (exp)));
899 return exp;
902 /* Given an expression, ensure that it is validly formed and that all named
903 attribute values are valid for the given attribute. Issue a fatal error
904 if not. If no attribute is specified, assume a numeric attribute.
906 Return a perhaps modified replacement expression for the value. */
908 static rtx
909 check_attr_value (rtx exp, struct attr_desc *attr)
911 struct attr_value *av;
912 const char *p;
913 int i;
915 switch (GET_CODE (exp))
917 case CONST_INT:
918 if (attr && ! attr->is_numeric)
920 error_with_line (attr->lineno,
921 "CONST_INT not valid for non-numeric attribute %s",
922 attr->name);
923 break;
926 if (INTVAL (exp) < 0)
928 error_with_line (attr->lineno,
929 "negative numeric value specified for attribute %s",
930 attr->name);
931 break;
933 break;
935 case CONST_STRING:
936 if (! strcmp (XSTR (exp, 0), "*"))
937 break;
939 if (attr == 0 || attr->is_numeric)
941 p = XSTR (exp, 0);
942 for (; *p; p++)
943 if (! ISDIGIT (*p))
945 error_with_line (attr ? attr->lineno : 0,
946 "non-numeric value for numeric attribute %s",
947 attr ? attr->name : "internal");
948 break;
950 break;
953 for (av = attr->first_value; av; av = av->next)
954 if (GET_CODE (av->value) == CONST_STRING
955 && ! strcmp (XSTR (av->value, 0), XSTR (exp, 0)))
956 break;
958 if (av == NULL)
959 error_with_line (attr->lineno,
960 "unknown value `%s' for `%s' attribute",
961 XSTR (exp, 0), attr ? attr->name : "internal");
962 break;
964 case IF_THEN_ELSE:
965 XEXP (exp, 0) = check_attr_test (XEXP (exp, 0),
966 attr ? attr->is_const : 0,
967 attr ? attr->lineno : 0);
968 XEXP (exp, 1) = check_attr_value (XEXP (exp, 1), attr);
969 XEXP (exp, 2) = check_attr_value (XEXP (exp, 2), attr);
970 break;
972 case PLUS:
973 case MINUS:
974 case MULT:
975 case DIV:
976 case MOD:
977 if (attr && !attr->is_numeric)
979 error_with_line (attr->lineno,
980 "invalid operation `%s' for non-numeric"
981 " attribute value", GET_RTX_NAME (GET_CODE (exp)));
982 break;
984 /* Fall through. */
986 case IOR:
987 case AND:
988 XEXP (exp, 0) = check_attr_value (XEXP (exp, 0), attr);
989 XEXP (exp, 1) = check_attr_value (XEXP (exp, 1), attr);
990 break;
992 case FFS:
993 case CLZ:
994 case CTZ:
995 case POPCOUNT:
996 case PARITY:
997 case BSWAP:
998 XEXP (exp, 0) = check_attr_value (XEXP (exp, 0), attr);
999 break;
1001 case COND:
1002 if (XVECLEN (exp, 0) % 2 != 0)
1004 error_with_line (attr->lineno,
1005 "first operand of COND must have even length");
1006 break;
1009 for (i = 0; i < XVECLEN (exp, 0); i += 2)
1011 XVECEXP (exp, 0, i) = check_attr_test (XVECEXP (exp, 0, i),
1012 attr ? attr->is_const : 0,
1013 attr ? attr->lineno : 0);
1014 XVECEXP (exp, 0, i + 1)
1015 = check_attr_value (XVECEXP (exp, 0, i + 1), attr);
1018 XEXP (exp, 1) = check_attr_value (XEXP (exp, 1), attr);
1019 break;
1021 case ATTR:
1023 struct attr_desc *attr2 = find_attr (&XSTR (exp, 0), 0);
1024 if (attr2 == NULL)
1025 error_with_line (attr ? attr->lineno : 0,
1026 "unknown attribute `%s' in ATTR",
1027 XSTR (exp, 0));
1028 else if (attr && attr->is_const && ! attr2->is_const)
1029 error_with_line (attr->lineno,
1030 "non-constant attribute `%s' referenced from `%s'",
1031 XSTR (exp, 0), attr->name);
1032 else if (attr
1033 && attr->is_numeric != attr2->is_numeric)
1034 error_with_line (attr->lineno,
1035 "numeric attribute mismatch calling `%s' from `%s'",
1036 XSTR (exp, 0), attr->name);
1038 break;
1040 case SYMBOL_REF:
1041 /* A constant SYMBOL_REF is valid as a constant attribute test and
1042 is expanded later by make_canonical into a COND. In a non-constant
1043 attribute test, it is left be. */
1044 return attr_rtx (SYMBOL_REF, XSTR (exp, 0));
1046 default:
1047 error_with_line (attr ? attr->lineno : 0,
1048 "invalid operation `%s' for attribute value",
1049 GET_RTX_NAME (GET_CODE (exp)));
1050 break;
1053 return exp;
1056 /* Given an SET_ATTR_ALTERNATIVE expression, convert to the canonical SET.
1057 It becomes a COND with each test being (eq_attr "alternative" "n") */
1059 static rtx
1060 convert_set_attr_alternative (rtx exp, struct insn_def *id)
1062 int num_alt = id->num_alternatives;
1063 rtx condexp;
1064 int i;
1066 if (XVECLEN (exp, 1) != num_alt)
1068 error_with_line (id->lineno,
1069 "bad number of entries in SET_ATTR_ALTERNATIVE");
1070 return NULL_RTX;
1073 /* Make a COND with all tests but the last. Select the last value via the
1074 default. */
1075 condexp = rtx_alloc (COND);
1076 XVEC (condexp, 0) = rtvec_alloc ((num_alt - 1) * 2);
1078 for (i = 0; i < num_alt - 1; i++)
1080 const char *p;
1081 p = attr_numeral (i);
1083 XVECEXP (condexp, 0, 2 * i) = attr_eq (alternative_name, p);
1084 XVECEXP (condexp, 0, 2 * i + 1) = XVECEXP (exp, 1, i);
1087 XEXP (condexp, 1) = XVECEXP (exp, 1, i);
1089 return attr_rtx (SET, attr_rtx (ATTR, XSTR (exp, 0)), condexp);
1092 /* Given a SET_ATTR, convert to the appropriate SET. If a comma-separated
1093 list of values is given, convert to SET_ATTR_ALTERNATIVE first. */
1095 static rtx
1096 convert_set_attr (rtx exp, struct insn_def *id)
1098 rtx newexp;
1099 const char *name_ptr;
1100 char *p;
1101 int n;
1103 /* See how many alternative specified. */
1104 n = n_comma_elts (XSTR (exp, 1));
1105 if (n == 1)
1106 return attr_rtx (SET,
1107 attr_rtx (ATTR, XSTR (exp, 0)),
1108 attr_rtx (CONST_STRING, XSTR (exp, 1)));
1110 newexp = rtx_alloc (SET_ATTR_ALTERNATIVE);
1111 XSTR (newexp, 0) = XSTR (exp, 0);
1112 XVEC (newexp, 1) = rtvec_alloc (n);
1114 /* Process each comma-separated name. */
1115 name_ptr = XSTR (exp, 1);
1116 n = 0;
1117 while ((p = next_comma_elt (&name_ptr)) != NULL)
1118 XVECEXP (newexp, 1, n++) = attr_rtx (CONST_STRING, p);
1120 return convert_set_attr_alternative (newexp, id);
1123 /* Scan all definitions, checking for validity. Also, convert any SET_ATTR
1124 and SET_ATTR_ALTERNATIVE expressions to the corresponding SET
1125 expressions. */
1127 static void
1128 check_defs (void)
1130 struct insn_def *id;
1131 struct attr_desc *attr;
1132 int i;
1133 rtx value;
1135 for (id = defs; id; id = id->next)
1137 if (XVEC (id->def, id->vec_idx) == NULL)
1138 continue;
1140 for (i = 0; i < XVECLEN (id->def, id->vec_idx); i++)
1142 value = XVECEXP (id->def, id->vec_idx, i);
1143 switch (GET_CODE (value))
1145 case SET:
1146 if (GET_CODE (XEXP (value, 0)) != ATTR)
1148 error_with_line (id->lineno, "bad attribute set");
1149 value = NULL_RTX;
1151 break;
1153 case SET_ATTR_ALTERNATIVE:
1154 value = convert_set_attr_alternative (value, id);
1155 break;
1157 case SET_ATTR:
1158 value = convert_set_attr (value, id);
1159 break;
1161 default:
1162 error_with_line (id->lineno, "invalid attribute code %s",
1163 GET_RTX_NAME (GET_CODE (value)));
1164 value = NULL_RTX;
1166 if (value == NULL_RTX)
1167 continue;
1169 if ((attr = find_attr (&XSTR (XEXP (value, 0), 0), 0)) == NULL)
1171 error_with_line (id->lineno, "unknown attribute %s",
1172 XSTR (XEXP (value, 0), 0));
1173 continue;
1176 XVECEXP (id->def, id->vec_idx, i) = value;
1177 XEXP (value, 1) = check_attr_value (XEXP (value, 1), attr);
1182 /* Given a valid expression for an attribute value, remove any IF_THEN_ELSE
1183 expressions by converting them into a COND. This removes cases from this
1184 program. Also, replace an attribute value of "*" with the default attribute
1185 value. */
1187 static rtx
1188 make_canonical (struct attr_desc *attr, rtx exp)
1190 int i;
1191 rtx newexp;
1193 switch (GET_CODE (exp))
1195 case CONST_INT:
1196 exp = make_numeric_value (INTVAL (exp));
1197 break;
1199 case CONST_STRING:
1200 if (! strcmp (XSTR (exp, 0), "*"))
1202 if (attr == 0 || attr->default_val == 0)
1203 fatal ("(attr_value \"*\") used in invalid context");
1204 exp = attr->default_val->value;
1206 else
1207 XSTR (exp, 0) = DEF_ATTR_STRING (XSTR (exp, 0));
1209 break;
1211 case SYMBOL_REF:
1212 if (!attr->is_const || ATTR_IND_SIMPLIFIED_P (exp))
1213 break;
1214 /* The SYMBOL_REF is constant for a given run, so mark it as unchanging.
1215 This makes the COND something that won't be considered an arbitrary
1216 expression by walk_attr_value. */
1217 ATTR_IND_SIMPLIFIED_P (exp) = 1;
1218 exp = check_attr_value (exp, attr);
1219 break;
1221 case IF_THEN_ELSE:
1222 newexp = rtx_alloc (COND);
1223 XVEC (newexp, 0) = rtvec_alloc (2);
1224 XVECEXP (newexp, 0, 0) = XEXP (exp, 0);
1225 XVECEXP (newexp, 0, 1) = XEXP (exp, 1);
1227 XEXP (newexp, 1) = XEXP (exp, 2);
1229 exp = newexp;
1230 /* Fall through to COND case since this is now a COND. */
1232 case COND:
1234 int allsame = 1;
1235 rtx defval;
1237 /* First, check for degenerate COND. */
1238 if (XVECLEN (exp, 0) == 0)
1239 return make_canonical (attr, XEXP (exp, 1));
1240 defval = XEXP (exp, 1) = make_canonical (attr, XEXP (exp, 1));
1242 for (i = 0; i < XVECLEN (exp, 0); i += 2)
1244 XVECEXP (exp, 0, i) = copy_boolean (XVECEXP (exp, 0, i));
1245 XVECEXP (exp, 0, i + 1)
1246 = make_canonical (attr, XVECEXP (exp, 0, i + 1));
1247 if (! rtx_equal_p (XVECEXP (exp, 0, i + 1), defval))
1248 allsame = 0;
1250 if (allsame)
1251 return defval;
1253 break;
1255 default:
1256 break;
1259 return exp;
1262 static rtx
1263 copy_boolean (rtx exp)
1265 if (GET_CODE (exp) == AND || GET_CODE (exp) == IOR)
1266 return attr_rtx (GET_CODE (exp), copy_boolean (XEXP (exp, 0)),
1267 copy_boolean (XEXP (exp, 1)));
1268 if (GET_CODE (exp) == MATCH_OPERAND)
1270 XSTR (exp, 1) = DEF_ATTR_STRING (XSTR (exp, 1));
1271 XSTR (exp, 2) = DEF_ATTR_STRING (XSTR (exp, 2));
1273 else if (GET_CODE (exp) == EQ_ATTR)
1275 XSTR (exp, 0) = DEF_ATTR_STRING (XSTR (exp, 0));
1276 XSTR (exp, 1) = DEF_ATTR_STRING (XSTR (exp, 1));
1279 return exp;
1282 /* Given a value and an attribute description, return a `struct attr_value *'
1283 that represents that value. This is either an existing structure, if the
1284 value has been previously encountered, or a newly-created structure.
1286 `insn_code' is the code of an insn whose attribute has the specified
1287 value (-2 if not processing an insn). We ensure that all insns for
1288 a given value have the same number of alternatives if the value checks
1289 alternatives. */
1291 static struct attr_value *
1292 get_attr_value (rtx value, struct attr_desc *attr, int insn_code)
1294 struct attr_value *av;
1295 int num_alt = 0;
1297 value = make_canonical (attr, value);
1298 if (compares_alternatives_p (value))
1300 if (insn_code < 0 || insn_alternatives == NULL)
1301 fatal ("(eq_attr \"alternatives\" ...) used in non-insn context");
1302 else
1303 num_alt = insn_alternatives[insn_code];
1306 for (av = attr->first_value; av; av = av->next)
1307 if (rtx_equal_p (value, av->value)
1308 && (num_alt == 0 || av->first_insn == NULL
1309 || insn_alternatives[av->first_insn->def->insn_code]))
1310 return av;
1312 av = oballoc (struct attr_value);
1313 av->value = value;
1314 av->next = attr->first_value;
1315 attr->first_value = av;
1316 av->first_insn = NULL;
1317 av->num_insns = 0;
1318 av->has_asm_insn = 0;
1320 return av;
1323 /* After all DEFINE_DELAYs have been read in, create internal attributes
1324 to generate the required routines.
1326 First, we compute the number of delay slots for each insn (as a COND of
1327 each of the test expressions in DEFINE_DELAYs). Then, if more than one
1328 delay type is specified, we compute a similar function giving the
1329 DEFINE_DELAY ordinal for each insn.
1331 Finally, for each [DEFINE_DELAY, slot #] pair, we compute an attribute that
1332 tells whether a given insn can be in that delay slot.
1334 Normal attribute filling and optimization expands these to contain the
1335 information needed to handle delay slots. */
1337 static void
1338 expand_delays (void)
1340 struct delay_desc *delay;
1341 rtx condexp;
1342 rtx newexp;
1343 int i;
1344 char *p;
1346 /* First, generate data for `num_delay_slots' function. */
1348 condexp = rtx_alloc (COND);
1349 XVEC (condexp, 0) = rtvec_alloc (num_delays * 2);
1350 XEXP (condexp, 1) = make_numeric_value (0);
1352 for (i = 0, delay = delays; delay; i += 2, delay = delay->next)
1354 XVECEXP (condexp, 0, i) = XEXP (delay->def, 0);
1355 XVECEXP (condexp, 0, i + 1)
1356 = make_numeric_value (XVECLEN (delay->def, 1) / 3);
1359 make_internal_attr (num_delay_slots_str, condexp, ATTR_NONE);
1361 /* If more than one delay type, do the same for computing the delay type. */
1362 if (num_delays > 1)
1364 condexp = rtx_alloc (COND);
1365 XVEC (condexp, 0) = rtvec_alloc (num_delays * 2);
1366 XEXP (condexp, 1) = make_numeric_value (0);
1368 for (i = 0, delay = delays; delay; i += 2, delay = delay->next)
1370 XVECEXP (condexp, 0, i) = XEXP (delay->def, 0);
1371 XVECEXP (condexp, 0, i + 1) = make_numeric_value (delay->num);
1374 make_internal_attr (delay_type_str, condexp, ATTR_SPECIAL);
1377 /* For each delay possibility and delay slot, compute an eligibility
1378 attribute for non-annulled insns and for each type of annulled (annul
1379 if true and annul if false). */
1380 for (delay = delays; delay; delay = delay->next)
1382 for (i = 0; i < XVECLEN (delay->def, 1); i += 3)
1384 condexp = XVECEXP (delay->def, 1, i);
1385 if (condexp == 0)
1386 condexp = false_rtx;
1387 newexp = attr_rtx (IF_THEN_ELSE, condexp,
1388 make_numeric_value (1), make_numeric_value (0));
1390 p = attr_printf (sizeof "*delay__" + MAX_DIGITS * 2,
1391 "*delay_%d_%d", delay->num, i / 3);
1392 make_internal_attr (p, newexp, ATTR_SPECIAL);
1394 if (have_annul_true)
1396 condexp = XVECEXP (delay->def, 1, i + 1);
1397 if (condexp == 0) condexp = false_rtx;
1398 newexp = attr_rtx (IF_THEN_ELSE, condexp,
1399 make_numeric_value (1),
1400 make_numeric_value (0));
1401 p = attr_printf (sizeof "*annul_true__" + MAX_DIGITS * 2,
1402 "*annul_true_%d_%d", delay->num, i / 3);
1403 make_internal_attr (p, newexp, ATTR_SPECIAL);
1406 if (have_annul_false)
1408 condexp = XVECEXP (delay->def, 1, i + 2);
1409 if (condexp == 0) condexp = false_rtx;
1410 newexp = attr_rtx (IF_THEN_ELSE, condexp,
1411 make_numeric_value (1),
1412 make_numeric_value (0));
1413 p = attr_printf (sizeof "*annul_false__" + MAX_DIGITS * 2,
1414 "*annul_false_%d_%d", delay->num, i / 3);
1415 make_internal_attr (p, newexp, ATTR_SPECIAL);
1421 /* Once all attributes and insns have been read and checked, we construct for
1422 each attribute value a list of all the insns that have that value for
1423 the attribute. */
1425 static void
1426 fill_attr (struct attr_desc *attr)
1428 struct attr_value *av;
1429 struct insn_ent *ie;
1430 struct insn_def *id;
1431 int i;
1432 rtx value;
1434 /* Don't fill constant attributes. The value is independent of
1435 any particular insn. */
1436 if (attr->is_const)
1437 return;
1439 for (id = defs; id; id = id->next)
1441 /* If no value is specified for this insn for this attribute, use the
1442 default. */
1443 value = NULL;
1444 if (XVEC (id->def, id->vec_idx))
1445 for (i = 0; i < XVECLEN (id->def, id->vec_idx); i++)
1446 if (! strcmp_check (XSTR (XEXP (XVECEXP (id->def, id->vec_idx, i), 0), 0),
1447 attr->name))
1448 value = XEXP (XVECEXP (id->def, id->vec_idx, i), 1);
1450 if (value == NULL)
1451 av = attr->default_val;
1452 else
1453 av = get_attr_value (value, attr, id->insn_code);
1455 ie = oballoc (struct insn_ent);
1456 ie->def = id;
1457 insert_insn_ent (av, ie);
1461 /* Given an expression EXP, see if it is a COND or IF_THEN_ELSE that has a
1462 test that checks relative positions of insns (uses MATCH_DUP or PC).
1463 If so, replace it with what is obtained by passing the expression to
1464 ADDRESS_FN. If not but it is a COND or IF_THEN_ELSE, call this routine
1465 recursively on each value (including the default value). Otherwise,
1466 return the value returned by NO_ADDRESS_FN applied to EXP. */
1468 static rtx
1469 substitute_address (rtx exp, rtx (*no_address_fn) (rtx),
1470 rtx (*address_fn) (rtx))
1472 int i;
1473 rtx newexp;
1475 if (GET_CODE (exp) == COND)
1477 /* See if any tests use addresses. */
1478 address_used = 0;
1479 for (i = 0; i < XVECLEN (exp, 0); i += 2)
1480 walk_attr_value (XVECEXP (exp, 0, i));
1482 if (address_used)
1483 return (*address_fn) (exp);
1485 /* Make a new copy of this COND, replacing each element. */
1486 newexp = rtx_alloc (COND);
1487 XVEC (newexp, 0) = rtvec_alloc (XVECLEN (exp, 0));
1488 for (i = 0; i < XVECLEN (exp, 0); i += 2)
1490 XVECEXP (newexp, 0, i) = XVECEXP (exp, 0, i);
1491 XVECEXP (newexp, 0, i + 1)
1492 = substitute_address (XVECEXP (exp, 0, i + 1),
1493 no_address_fn, address_fn);
1496 XEXP (newexp, 1) = substitute_address (XEXP (exp, 1),
1497 no_address_fn, address_fn);
1499 return newexp;
1502 else if (GET_CODE (exp) == IF_THEN_ELSE)
1504 address_used = 0;
1505 walk_attr_value (XEXP (exp, 0));
1506 if (address_used)
1507 return (*address_fn) (exp);
1509 return attr_rtx (IF_THEN_ELSE,
1510 substitute_address (XEXP (exp, 0),
1511 no_address_fn, address_fn),
1512 substitute_address (XEXP (exp, 1),
1513 no_address_fn, address_fn),
1514 substitute_address (XEXP (exp, 2),
1515 no_address_fn, address_fn));
1518 return (*no_address_fn) (exp);
1521 /* Make new attributes from the `length' attribute. The following are made,
1522 each corresponding to a function called from `shorten_branches' or
1523 `get_attr_length':
1525 *insn_default_length This is the length of the insn to be returned
1526 by `get_attr_length' before `shorten_branches'
1527 has been called. In each case where the length
1528 depends on relative addresses, the largest
1529 possible is used. This routine is also used
1530 to compute the initial size of the insn.
1532 *insn_variable_length_p This returns 1 if the insn's length depends
1533 on relative addresses, zero otherwise.
1535 *insn_current_length This is only called when it is known that the
1536 insn has a variable length and returns the
1537 current length, based on relative addresses.
1540 static void
1541 make_length_attrs (void)
1543 static const char *new_names[] =
1545 "*insn_default_length",
1546 "*insn_min_length",
1547 "*insn_variable_length_p",
1548 "*insn_current_length"
1550 static rtx (*const no_address_fn[]) (rtx)
1551 = {identity_fn,identity_fn, zero_fn, zero_fn};
1552 static rtx (*const address_fn[]) (rtx)
1553 = {max_fn, min_fn, one_fn, identity_fn};
1554 size_t i;
1555 struct attr_desc *length_attr, *new_attr;
1556 struct attr_value *av, *new_av;
1557 struct insn_ent *ie, *new_ie;
1559 /* See if length attribute is defined. If so, it must be numeric. Make
1560 it special so we don't output anything for it. */
1561 length_attr = find_attr (&length_str, 0);
1562 if (length_attr == 0)
1563 return;
1565 if (! length_attr->is_numeric)
1566 fatal ("length attribute must be numeric");
1568 length_attr->is_const = 0;
1569 length_attr->is_special = 1;
1571 /* Make each new attribute, in turn. */
1572 for (i = 0; i < ARRAY_SIZE (new_names); i++)
1574 make_internal_attr (new_names[i],
1575 substitute_address (length_attr->default_val->value,
1576 no_address_fn[i], address_fn[i]),
1577 ATTR_NONE);
1578 new_attr = find_attr (&new_names[i], 0);
1579 for (av = length_attr->first_value; av; av = av->next)
1580 for (ie = av->first_insn; ie; ie = ie->next)
1582 new_av = get_attr_value (substitute_address (av->value,
1583 no_address_fn[i],
1584 address_fn[i]),
1585 new_attr, ie->def->insn_code);
1586 new_ie = oballoc (struct insn_ent);
1587 new_ie->def = ie->def;
1588 insert_insn_ent (new_av, new_ie);
1593 /* Utility functions called from above routine. */
1595 static rtx
1596 identity_fn (rtx exp)
1598 return exp;
1601 static rtx
1602 zero_fn (rtx exp ATTRIBUTE_UNUSED)
1604 return make_numeric_value (0);
1607 static rtx
1608 one_fn (rtx exp ATTRIBUTE_UNUSED)
1610 return make_numeric_value (1);
1613 static rtx
1614 max_fn (rtx exp)
1616 int unknown;
1617 return make_numeric_value (max_attr_value (exp, &unknown));
1620 static rtx
1621 min_fn (rtx exp)
1623 int unknown;
1624 return make_numeric_value (min_attr_value (exp, &unknown));
1627 static void
1628 write_length_unit_log (FILE *outf)
1630 struct attr_desc *length_attr = find_attr (&length_str, 0);
1631 struct attr_value *av;
1632 struct insn_ent *ie;
1633 unsigned int length_unit_log, length_or;
1634 int unknown = 0;
1636 if (length_attr)
1638 length_or = or_attr_value (length_attr->default_val->value, &unknown);
1639 for (av = length_attr->first_value; av; av = av->next)
1640 for (ie = av->first_insn; ie; ie = ie->next)
1641 length_or |= or_attr_value (av->value, &unknown);
1644 if (length_attr == NULL || unknown)
1645 length_unit_log = 0;
1646 else
1648 length_or = ~length_or;
1649 for (length_unit_log = 0; length_or & 1; length_or >>= 1)
1650 length_unit_log++;
1652 fprintf (outf, "EXPORTED_CONST int length_unit_log = %u;\n", length_unit_log);
1655 /* Compute approximate cost of the expression. Used to decide whether
1656 expression is cheap enough for inline. */
1657 static int
1658 attr_rtx_cost (rtx x)
1660 int cost = 1;
1661 enum rtx_code code;
1662 if (!x)
1663 return 0;
1664 code = GET_CODE (x);
1665 switch (code)
1667 case MATCH_OPERAND:
1668 if (XSTR (x, 1)[0])
1669 return 10;
1670 else
1671 return 1;
1673 case EQ_ATTR_ALT:
1674 return 1;
1676 case EQ_ATTR:
1677 /* Alternatives don't result into function call. */
1678 if (!strcmp_check (XSTR (x, 0), alternative_name))
1679 return 1;
1680 else
1681 return 5;
1682 default:
1684 int i, j;
1685 const char *fmt = GET_RTX_FORMAT (code);
1686 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
1688 switch (fmt[i])
1690 case 'V':
1691 case 'E':
1692 for (j = 0; j < XVECLEN (x, i); j++)
1693 cost += attr_rtx_cost (XVECEXP (x, i, j));
1694 break;
1695 case 'e':
1696 cost += attr_rtx_cost (XEXP (x, i));
1697 break;
1701 break;
1703 return cost;
1706 /* Take a COND expression and see if any of the conditions in it can be
1707 simplified. If any are known true or known false for the particular insn
1708 code, the COND can be further simplified.
1710 Also call ourselves on any COND operations that are values of this COND.
1712 We do not modify EXP; rather, we make and return a new rtx. */
1714 static rtx
1715 simplify_cond (rtx exp, int insn_code, int insn_index)
1717 int i, j;
1718 /* We store the desired contents here,
1719 then build a new expression if they don't match EXP. */
1720 rtx defval = XEXP (exp, 1);
1721 rtx new_defval = XEXP (exp, 1);
1722 int len = XVECLEN (exp, 0);
1723 rtx *tests = XNEWVEC (rtx, len);
1724 int allsame = 1;
1725 rtx ret;
1727 /* This lets us free all storage allocated below, if appropriate. */
1728 obstack_finish (rtl_obstack);
1730 memcpy (tests, XVEC (exp, 0)->elem, len * sizeof (rtx));
1732 /* See if default value needs simplification. */
1733 if (GET_CODE (defval) == COND)
1734 new_defval = simplify_cond (defval, insn_code, insn_index);
1736 /* Simplify the subexpressions, and see what tests we can get rid of. */
1738 for (i = 0; i < len; i += 2)
1740 rtx newtest, newval;
1742 /* Simplify this test. */
1743 newtest = simplify_test_exp_in_temp (tests[i], insn_code, insn_index);
1744 tests[i] = newtest;
1746 newval = tests[i + 1];
1747 /* See if this value may need simplification. */
1748 if (GET_CODE (newval) == COND)
1749 newval = simplify_cond (newval, insn_code, insn_index);
1751 /* Look for ways to delete or combine this test. */
1752 if (newtest == true_rtx)
1754 /* If test is true, make this value the default
1755 and discard this + any following tests. */
1756 len = i;
1757 defval = tests[i + 1];
1758 new_defval = newval;
1761 else if (newtest == false_rtx)
1763 /* If test is false, discard it and its value. */
1764 for (j = i; j < len - 2; j++)
1765 tests[j] = tests[j + 2];
1766 i -= 2;
1767 len -= 2;
1770 else if (i > 0 && attr_equal_p (newval, tests[i - 1]))
1772 /* If this value and the value for the prev test are the same,
1773 merge the tests. */
1775 tests[i - 2]
1776 = insert_right_side (IOR, tests[i - 2], newtest,
1777 insn_code, insn_index);
1779 /* Delete this test/value. */
1780 for (j = i; j < len - 2; j++)
1781 tests[j] = tests[j + 2];
1782 len -= 2;
1783 i -= 2;
1786 else
1787 tests[i + 1] = newval;
1790 /* If the last test in a COND has the same value
1791 as the default value, that test isn't needed. */
1793 while (len > 0 && attr_equal_p (tests[len - 1], new_defval))
1794 len -= 2;
1796 /* See if we changed anything. */
1797 if (len != XVECLEN (exp, 0) || new_defval != XEXP (exp, 1))
1798 allsame = 0;
1799 else
1800 for (i = 0; i < len; i++)
1801 if (! attr_equal_p (tests[i], XVECEXP (exp, 0, i)))
1803 allsame = 0;
1804 break;
1807 if (len == 0)
1809 if (GET_CODE (defval) == COND)
1810 ret = simplify_cond (defval, insn_code, insn_index);
1811 else
1812 ret = defval;
1814 else if (allsame)
1815 ret = exp;
1816 else
1818 rtx newexp = rtx_alloc (COND);
1820 XVEC (newexp, 0) = rtvec_alloc (len);
1821 memcpy (XVEC (newexp, 0)->elem, tests, len * sizeof (rtx));
1822 XEXP (newexp, 1) = new_defval;
1823 ret = newexp;
1825 free (tests);
1826 return ret;
1829 /* Remove an insn entry from an attribute value. */
1831 static void
1832 remove_insn_ent (struct attr_value *av, struct insn_ent *ie)
1834 struct insn_ent *previe;
1836 if (av->first_insn == ie)
1837 av->first_insn = ie->next;
1838 else
1840 for (previe = av->first_insn; previe->next != ie; previe = previe->next)
1842 previe->next = ie->next;
1845 av->num_insns--;
1846 if (ie->def->insn_code == -1)
1847 av->has_asm_insn = 0;
1849 num_insn_ents--;
1852 /* Insert an insn entry in an attribute value list. */
1854 static void
1855 insert_insn_ent (struct attr_value *av, struct insn_ent *ie)
1857 ie->next = av->first_insn;
1858 av->first_insn = ie;
1859 av->num_insns++;
1860 if (ie->def->insn_code == -1)
1861 av->has_asm_insn = 1;
1863 num_insn_ents++;
1866 /* This is a utility routine to take an expression that is a tree of either
1867 AND or IOR expressions and insert a new term. The new term will be
1868 inserted at the right side of the first node whose code does not match
1869 the root. A new node will be created with the root's code. Its left
1870 side will be the old right side and its right side will be the new
1871 term.
1873 If the `term' is itself a tree, all its leaves will be inserted. */
1875 static rtx
1876 insert_right_side (enum rtx_code code, rtx exp, rtx term, int insn_code, int insn_index)
1878 rtx newexp;
1880 /* Avoid consing in some special cases. */
1881 if (code == AND && term == true_rtx)
1882 return exp;
1883 if (code == AND && term == false_rtx)
1884 return false_rtx;
1885 if (code == AND && exp == true_rtx)
1886 return term;
1887 if (code == AND && exp == false_rtx)
1888 return false_rtx;
1889 if (code == IOR && term == true_rtx)
1890 return true_rtx;
1891 if (code == IOR && term == false_rtx)
1892 return exp;
1893 if (code == IOR && exp == true_rtx)
1894 return true_rtx;
1895 if (code == IOR && exp == false_rtx)
1896 return term;
1897 if (attr_equal_p (exp, term))
1898 return exp;
1900 if (GET_CODE (term) == code)
1902 exp = insert_right_side (code, exp, XEXP (term, 0),
1903 insn_code, insn_index);
1904 exp = insert_right_side (code, exp, XEXP (term, 1),
1905 insn_code, insn_index);
1907 return exp;
1910 if (GET_CODE (exp) == code)
1912 rtx new_rtx = insert_right_side (code, XEXP (exp, 1),
1913 term, insn_code, insn_index);
1914 if (new_rtx != XEXP (exp, 1))
1915 /* Make a copy of this expression and call recursively. */
1916 newexp = attr_rtx (code, XEXP (exp, 0), new_rtx);
1917 else
1918 newexp = exp;
1920 else
1922 /* Insert the new term. */
1923 newexp = attr_rtx (code, exp, term);
1926 return simplify_test_exp_in_temp (newexp, insn_code, insn_index);
1929 /* If we have an expression which AND's a bunch of
1930 (not (eq_attrq "alternative" "n"))
1931 terms, we may have covered all or all but one of the possible alternatives.
1932 If so, we can optimize. Similarly for IOR's of EQ_ATTR.
1934 This routine is passed an expression and either AND or IOR. It returns a
1935 bitmask indicating which alternatives are mentioned within EXP. */
1937 static int
1938 compute_alternative_mask (rtx exp, enum rtx_code code)
1940 const char *string;
1941 if (GET_CODE (exp) == code)
1942 return compute_alternative_mask (XEXP (exp, 0), code)
1943 | compute_alternative_mask (XEXP (exp, 1), code);
1945 else if (code == AND && GET_CODE (exp) == NOT
1946 && GET_CODE (XEXP (exp, 0)) == EQ_ATTR
1947 && XSTR (XEXP (exp, 0), 0) == alternative_name)
1948 string = XSTR (XEXP (exp, 0), 1);
1950 else if (code == IOR && GET_CODE (exp) == EQ_ATTR
1951 && XSTR (exp, 0) == alternative_name)
1952 string = XSTR (exp, 1);
1954 else if (GET_CODE (exp) == EQ_ATTR_ALT)
1956 if (code == AND && XINT (exp, 1))
1957 return XINT (exp, 0);
1959 if (code == IOR && !XINT (exp, 1))
1960 return XINT (exp, 0);
1962 return 0;
1964 else
1965 return 0;
1967 if (string[1] == 0)
1968 return 1 << (string[0] - '0');
1969 return 1 << atoi (string);
1972 /* Given I, a single-bit mask, return RTX to compare the `alternative'
1973 attribute with the value represented by that bit. */
1975 static rtx
1976 make_alternative_compare (int mask)
1978 return mk_attr_alt (mask);
1981 /* If we are processing an (eq_attr "attr" "value") test, we find the value
1982 of "attr" for this insn code. From that value, we can compute a test
1983 showing when the EQ_ATTR will be true. This routine performs that
1984 computation. If a test condition involves an address, we leave the EQ_ATTR
1985 intact because addresses are only valid for the `length' attribute.
1987 EXP is the EQ_ATTR expression and ATTR is the attribute to which
1988 it refers. VALUE is the value of that attribute for the insn
1989 corresponding to INSN_CODE and INSN_INDEX. */
1991 static rtx
1992 evaluate_eq_attr (rtx exp, struct attr_desc *attr, rtx value,
1993 int insn_code, int insn_index)
1995 rtx orexp, andexp;
1996 rtx right;
1997 rtx newexp;
1998 int i;
2000 while (GET_CODE (value) == ATTR)
2002 struct attr_value *av = NULL;
2004 attr = find_attr (&XSTR (value, 0), 0);
2006 if (insn_code_values)
2008 struct attr_value_list *iv;
2009 for (iv = insn_code_values[insn_code]; iv; iv = iv->next)
2010 if (iv->attr == attr)
2012 av = iv->av;
2013 break;
2016 else
2018 struct insn_ent *ie;
2019 for (av = attr->first_value; av; av = av->next)
2020 for (ie = av->first_insn; ie; ie = ie->next)
2021 if (ie->def->insn_code == insn_code)
2022 goto got_av;
2024 if (av)
2026 got_av:
2027 value = av->value;
2031 switch (GET_CODE (value))
2033 case CONST_STRING:
2034 if (! strcmp_check (XSTR (value, 0), XSTR (exp, 1)))
2035 newexp = true_rtx;
2036 else
2037 newexp = false_rtx;
2038 break;
2040 case SYMBOL_REF:
2042 const char *prefix;
2043 char *string, *p;
2045 gcc_assert (GET_CODE (exp) == EQ_ATTR);
2046 prefix = attr->enum_name ? attr->enum_name : attr->name;
2047 string = ACONCAT ((prefix, "_", XSTR (exp, 1), NULL));
2048 for (p = string; *p; p++)
2049 *p = TOUPPER (*p);
2051 newexp = attr_rtx (EQ, value,
2052 attr_rtx (SYMBOL_REF,
2053 DEF_ATTR_STRING (string)));
2054 break;
2057 case COND:
2058 /* We construct an IOR of all the cases for which the
2059 requested attribute value is present. Since we start with
2060 FALSE, if it is not present, FALSE will be returned.
2062 Each case is the AND of the NOT's of the previous conditions with the
2063 current condition; in the default case the current condition is TRUE.
2065 For each possible COND value, call ourselves recursively.
2067 The extra TRUE and FALSE expressions will be eliminated by another
2068 call to the simplification routine. */
2070 orexp = false_rtx;
2071 andexp = true_rtx;
2073 for (i = 0; i < XVECLEN (value, 0); i += 2)
2075 rtx this_cond = simplify_test_exp_in_temp (XVECEXP (value, 0, i),
2076 insn_code, insn_index);
2078 right = insert_right_side (AND, andexp, this_cond,
2079 insn_code, insn_index);
2080 right = insert_right_side (AND, right,
2081 evaluate_eq_attr (exp, attr,
2082 XVECEXP (value, 0,
2083 i + 1),
2084 insn_code, insn_index),
2085 insn_code, insn_index);
2086 orexp = insert_right_side (IOR, orexp, right,
2087 insn_code, insn_index);
2089 /* Add this condition into the AND expression. */
2090 newexp = attr_rtx (NOT, this_cond);
2091 andexp = insert_right_side (AND, andexp, newexp,
2092 insn_code, insn_index);
2095 /* Handle the default case. */
2096 right = insert_right_side (AND, andexp,
2097 evaluate_eq_attr (exp, attr, XEXP (value, 1),
2098 insn_code, insn_index),
2099 insn_code, insn_index);
2100 newexp = insert_right_side (IOR, orexp, right, insn_code, insn_index);
2101 break;
2103 default:
2104 gcc_unreachable ();
2107 /* If uses an address, must return original expression. But set the
2108 ATTR_IND_SIMPLIFIED_P bit so we don't try to simplify it again. */
2110 address_used = 0;
2111 walk_attr_value (newexp);
2113 if (address_used)
2115 if (! ATTR_IND_SIMPLIFIED_P (exp))
2116 return copy_rtx_unchanging (exp);
2117 return exp;
2119 else
2120 return newexp;
2123 /* This routine is called when an AND of a term with a tree of AND's is
2124 encountered. If the term or its complement is present in the tree, it
2125 can be replaced with TRUE or FALSE, respectively.
2127 Note that (eq_attr "att" "v1") and (eq_attr "att" "v2") cannot both
2128 be true and hence are complementary.
2130 There is one special case: If we see
2131 (and (not (eq_attr "att" "v1"))
2132 (eq_attr "att" "v2"))
2133 this can be replaced by (eq_attr "att" "v2"). To do this we need to
2134 replace the term, not anything in the AND tree. So we pass a pointer to
2135 the term. */
2137 static rtx
2138 simplify_and_tree (rtx exp, rtx *pterm, int insn_code, int insn_index)
2140 rtx left, right;
2141 rtx newexp;
2142 rtx temp;
2143 int left_eliminates_term, right_eliminates_term;
2145 if (GET_CODE (exp) == AND)
2147 left = simplify_and_tree (XEXP (exp, 0), pterm, insn_code, insn_index);
2148 right = simplify_and_tree (XEXP (exp, 1), pterm, insn_code, insn_index);
2149 if (left != XEXP (exp, 0) || right != XEXP (exp, 1))
2151 newexp = attr_rtx (AND, left, right);
2153 exp = simplify_test_exp_in_temp (newexp, insn_code, insn_index);
2157 else if (GET_CODE (exp) == IOR)
2159 /* For the IOR case, we do the same as above, except that we can
2160 only eliminate `term' if both sides of the IOR would do so. */
2161 temp = *pterm;
2162 left = simplify_and_tree (XEXP (exp, 0), &temp, insn_code, insn_index);
2163 left_eliminates_term = (temp == true_rtx);
2165 temp = *pterm;
2166 right = simplify_and_tree (XEXP (exp, 1), &temp, insn_code, insn_index);
2167 right_eliminates_term = (temp == true_rtx);
2169 if (left_eliminates_term && right_eliminates_term)
2170 *pterm = true_rtx;
2172 if (left != XEXP (exp, 0) || right != XEXP (exp, 1))
2174 newexp = attr_rtx (IOR, left, right);
2176 exp = simplify_test_exp_in_temp (newexp, insn_code, insn_index);
2180 /* Check for simplifications. Do some extra checking here since this
2181 routine is called so many times. */
2183 if (exp == *pterm)
2184 return true_rtx;
2186 else if (GET_CODE (exp) == NOT && XEXP (exp, 0) == *pterm)
2187 return false_rtx;
2189 else if (GET_CODE (*pterm) == NOT && exp == XEXP (*pterm, 0))
2190 return false_rtx;
2192 else if (GET_CODE (exp) == EQ_ATTR_ALT && GET_CODE (*pterm) == EQ_ATTR_ALT)
2194 if (attr_alt_subset_p (*pterm, exp))
2195 return true_rtx;
2197 if (attr_alt_subset_of_compl_p (*pterm, exp))
2198 return false_rtx;
2200 if (attr_alt_subset_p (exp, *pterm))
2201 *pterm = true_rtx;
2203 return exp;
2206 else if (GET_CODE (exp) == EQ_ATTR && GET_CODE (*pterm) == EQ_ATTR)
2208 if (XSTR (exp, 0) != XSTR (*pterm, 0))
2209 return exp;
2211 if (! strcmp_check (XSTR (exp, 1), XSTR (*pterm, 1)))
2212 return true_rtx;
2213 else
2214 return false_rtx;
2217 else if (GET_CODE (*pterm) == EQ_ATTR && GET_CODE (exp) == NOT
2218 && GET_CODE (XEXP (exp, 0)) == EQ_ATTR)
2220 if (XSTR (*pterm, 0) != XSTR (XEXP (exp, 0), 0))
2221 return exp;
2223 if (! strcmp_check (XSTR (*pterm, 1), XSTR (XEXP (exp, 0), 1)))
2224 return false_rtx;
2225 else
2226 return true_rtx;
2229 else if (GET_CODE (exp) == EQ_ATTR && GET_CODE (*pterm) == NOT
2230 && GET_CODE (XEXP (*pterm, 0)) == EQ_ATTR)
2232 if (XSTR (exp, 0) != XSTR (XEXP (*pterm, 0), 0))
2233 return exp;
2235 if (! strcmp_check (XSTR (exp, 1), XSTR (XEXP (*pterm, 0), 1)))
2236 return false_rtx;
2237 else
2238 *pterm = true_rtx;
2241 else if (GET_CODE (exp) == NOT && GET_CODE (*pterm) == NOT)
2243 if (attr_equal_p (XEXP (exp, 0), XEXP (*pterm, 0)))
2244 return true_rtx;
2247 else if (GET_CODE (exp) == NOT)
2249 if (attr_equal_p (XEXP (exp, 0), *pterm))
2250 return false_rtx;
2253 else if (GET_CODE (*pterm) == NOT)
2255 if (attr_equal_p (XEXP (*pterm, 0), exp))
2256 return false_rtx;
2259 else if (attr_equal_p (exp, *pterm))
2260 return true_rtx;
2262 return exp;
2265 /* Similar to `simplify_and_tree', but for IOR trees. */
2267 static rtx
2268 simplify_or_tree (rtx exp, rtx *pterm, int insn_code, int insn_index)
2270 rtx left, right;
2271 rtx newexp;
2272 rtx temp;
2273 int left_eliminates_term, right_eliminates_term;
2275 if (GET_CODE (exp) == IOR)
2277 left = simplify_or_tree (XEXP (exp, 0), pterm, insn_code, insn_index);
2278 right = simplify_or_tree (XEXP (exp, 1), pterm, insn_code, insn_index);
2279 if (left != XEXP (exp, 0) || right != XEXP (exp, 1))
2281 newexp = attr_rtx (GET_CODE (exp), left, right);
2283 exp = simplify_test_exp_in_temp (newexp, insn_code, insn_index);
2287 else if (GET_CODE (exp) == AND)
2289 /* For the AND case, we do the same as above, except that we can
2290 only eliminate `term' if both sides of the AND would do so. */
2291 temp = *pterm;
2292 left = simplify_or_tree (XEXP (exp, 0), &temp, insn_code, insn_index);
2293 left_eliminates_term = (temp == false_rtx);
2295 temp = *pterm;
2296 right = simplify_or_tree (XEXP (exp, 1), &temp, insn_code, insn_index);
2297 right_eliminates_term = (temp == false_rtx);
2299 if (left_eliminates_term && right_eliminates_term)
2300 *pterm = false_rtx;
2302 if (left != XEXP (exp, 0) || right != XEXP (exp, 1))
2304 newexp = attr_rtx (GET_CODE (exp), left, right);
2306 exp = simplify_test_exp_in_temp (newexp, insn_code, insn_index);
2310 if (attr_equal_p (exp, *pterm))
2311 return false_rtx;
2313 else if (GET_CODE (exp) == NOT && attr_equal_p (XEXP (exp, 0), *pterm))
2314 return true_rtx;
2316 else if (GET_CODE (*pterm) == NOT && attr_equal_p (XEXP (*pterm, 0), exp))
2317 return true_rtx;
2319 else if (GET_CODE (*pterm) == EQ_ATTR && GET_CODE (exp) == NOT
2320 && GET_CODE (XEXP (exp, 0)) == EQ_ATTR
2321 && XSTR (*pterm, 0) == XSTR (XEXP (exp, 0), 0))
2322 *pterm = false_rtx;
2324 else if (GET_CODE (exp) == EQ_ATTR && GET_CODE (*pterm) == NOT
2325 && GET_CODE (XEXP (*pterm, 0)) == EQ_ATTR
2326 && XSTR (exp, 0) == XSTR (XEXP (*pterm, 0), 0))
2327 return false_rtx;
2329 return exp;
2332 /* Simplify test expression and use temporary obstack in order to avoid
2333 memory bloat. Use ATTR_IND_SIMPLIFIED to avoid unnecessary simplifications
2334 and avoid unnecessary copying if possible. */
2336 static rtx
2337 simplify_test_exp_in_temp (rtx exp, int insn_code, int insn_index)
2339 rtx x;
2340 struct obstack *old;
2341 if (ATTR_IND_SIMPLIFIED_P (exp))
2342 return exp;
2343 old = rtl_obstack;
2344 rtl_obstack = temp_obstack;
2345 x = simplify_test_exp (exp, insn_code, insn_index);
2346 rtl_obstack = old;
2347 if (x == exp || rtl_obstack == temp_obstack)
2348 return x;
2349 return attr_copy_rtx (x);
2352 /* Returns true if S1 is a subset of S2. */
2354 static bool
2355 attr_alt_subset_p (rtx s1, rtx s2)
2357 switch ((XINT (s1, 1) << 1) | XINT (s2, 1))
2359 case (0 << 1) | 0:
2360 return !(XINT (s1, 0) &~ XINT (s2, 0));
2362 case (0 << 1) | 1:
2363 return !(XINT (s1, 0) & XINT (s2, 0));
2365 case (1 << 1) | 0:
2366 return false;
2368 case (1 << 1) | 1:
2369 return !(XINT (s2, 0) &~ XINT (s1, 0));
2371 default:
2372 gcc_unreachable ();
2376 /* Returns true if S1 is a subset of complement of S2. */
2378 static bool
2379 attr_alt_subset_of_compl_p (rtx s1, rtx s2)
2381 switch ((XINT (s1, 1) << 1) | XINT (s2, 1))
2383 case (0 << 1) | 0:
2384 return !(XINT (s1, 0) & XINT (s2, 0));
2386 case (0 << 1) | 1:
2387 return !(XINT (s1, 0) & ~XINT (s2, 0));
2389 case (1 << 1) | 0:
2390 return !(XINT (s2, 0) &~ XINT (s1, 0));
2392 case (1 << 1) | 1:
2393 return false;
2395 default:
2396 gcc_unreachable ();
2400 /* Return EQ_ATTR_ALT expression representing intersection of S1 and S2. */
2402 static rtx
2403 attr_alt_intersection (rtx s1, rtx s2)
2405 rtx result = rtx_alloc (EQ_ATTR_ALT);
2407 switch ((XINT (s1, 1) << 1) | XINT (s2, 1))
2409 case (0 << 1) | 0:
2410 XINT (result, 0) = XINT (s1, 0) & XINT (s2, 0);
2411 break;
2412 case (0 << 1) | 1:
2413 XINT (result, 0) = XINT (s1, 0) & ~XINT (s2, 0);
2414 break;
2415 case (1 << 1) | 0:
2416 XINT (result, 0) = XINT (s2, 0) & ~XINT (s1, 0);
2417 break;
2418 case (1 << 1) | 1:
2419 XINT (result, 0) = XINT (s1, 0) | XINT (s2, 0);
2420 break;
2421 default:
2422 gcc_unreachable ();
2424 XINT (result, 1) = XINT (s1, 1) & XINT (s2, 1);
2426 return result;
2429 /* Return EQ_ATTR_ALT expression representing union of S1 and S2. */
2431 static rtx
2432 attr_alt_union (rtx s1, rtx s2)
2434 rtx result = rtx_alloc (EQ_ATTR_ALT);
2436 switch ((XINT (s1, 1) << 1) | XINT (s2, 1))
2438 case (0 << 1) | 0:
2439 XINT (result, 0) = XINT (s1, 0) | XINT (s2, 0);
2440 break;
2441 case (0 << 1) | 1:
2442 XINT (result, 0) = XINT (s2, 0) & ~XINT (s1, 0);
2443 break;
2444 case (1 << 1) | 0:
2445 XINT (result, 0) = XINT (s1, 0) & ~XINT (s2, 0);
2446 break;
2447 case (1 << 1) | 1:
2448 XINT (result, 0) = XINT (s1, 0) & XINT (s2, 0);
2449 break;
2450 default:
2451 gcc_unreachable ();
2454 XINT (result, 1) = XINT (s1, 1) | XINT (s2, 1);
2455 return result;
2458 /* Return EQ_ATTR_ALT expression representing complement of S. */
2460 static rtx
2461 attr_alt_complement (rtx s)
2463 rtx result = rtx_alloc (EQ_ATTR_ALT);
2465 XINT (result, 0) = XINT (s, 0);
2466 XINT (result, 1) = 1 - XINT (s, 1);
2468 return result;
2471 /* Return EQ_ATTR_ALT expression representing set containing elements set
2472 in E. */
2474 static rtx
2475 mk_attr_alt (int e)
2477 rtx result = rtx_alloc (EQ_ATTR_ALT);
2479 XINT (result, 0) = e;
2480 XINT (result, 1) = 0;
2482 return result;
2485 /* Given an expression, see if it can be simplified for a particular insn
2486 code based on the values of other attributes being tested. This can
2487 eliminate nested get_attr_... calls.
2489 Note that if an endless recursion is specified in the patterns, the
2490 optimization will loop. However, it will do so in precisely the cases where
2491 an infinite recursion loop could occur during compilation. It's better that
2492 it occurs here! */
2494 static rtx
2495 simplify_test_exp (rtx exp, int insn_code, int insn_index)
2497 rtx left, right;
2498 struct attr_desc *attr;
2499 struct attr_value *av;
2500 struct insn_ent *ie;
2501 struct attr_value_list *iv;
2502 int i;
2503 rtx newexp = exp;
2504 bool left_alt, right_alt;
2506 /* Don't re-simplify something we already simplified. */
2507 if (ATTR_IND_SIMPLIFIED_P (exp) || ATTR_CURR_SIMPLIFIED_P (exp))
2508 return exp;
2510 switch (GET_CODE (exp))
2512 case AND:
2513 left = SIMPLIFY_TEST_EXP (XEXP (exp, 0), insn_code, insn_index);
2514 if (left == false_rtx)
2515 return false_rtx;
2516 right = SIMPLIFY_TEST_EXP (XEXP (exp, 1), insn_code, insn_index);
2517 if (right == false_rtx)
2518 return false_rtx;
2520 if (GET_CODE (left) == EQ_ATTR_ALT
2521 && GET_CODE (right) == EQ_ATTR_ALT)
2523 exp = attr_alt_intersection (left, right);
2524 return simplify_test_exp (exp, insn_code, insn_index);
2527 /* If either side is an IOR and we have (eq_attr "alternative" ..")
2528 present on both sides, apply the distributive law since this will
2529 yield simplifications. */
2530 if ((GET_CODE (left) == IOR || GET_CODE (right) == IOR)
2531 && compute_alternative_mask (left, IOR)
2532 && compute_alternative_mask (right, IOR))
2534 if (GET_CODE (left) == IOR)
2536 rtx tem = left;
2537 left = right;
2538 right = tem;
2541 newexp = attr_rtx (IOR,
2542 attr_rtx (AND, left, XEXP (right, 0)),
2543 attr_rtx (AND, left, XEXP (right, 1)));
2545 return SIMPLIFY_TEST_EXP (newexp, insn_code, insn_index);
2548 /* Try with the term on both sides. */
2549 right = simplify_and_tree (right, &left, insn_code, insn_index);
2550 if (left == XEXP (exp, 0) && right == XEXP (exp, 1))
2551 left = simplify_and_tree (left, &right, insn_code, insn_index);
2553 if (left == false_rtx || right == false_rtx)
2554 return false_rtx;
2555 else if (left == true_rtx)
2557 return right;
2559 else if (right == true_rtx)
2561 return left;
2563 /* See if all or all but one of the insn's alternatives are specified
2564 in this tree. Optimize if so. */
2566 if (GET_CODE (left) == NOT)
2567 left_alt = (GET_CODE (XEXP (left, 0)) == EQ_ATTR
2568 && XSTR (XEXP (left, 0), 0) == alternative_name);
2569 else
2570 left_alt = (GET_CODE (left) == EQ_ATTR_ALT
2571 && XINT (left, 1));
2573 if (GET_CODE (right) == NOT)
2574 right_alt = (GET_CODE (XEXP (right, 0)) == EQ_ATTR
2575 && XSTR (XEXP (right, 0), 0) == alternative_name);
2576 else
2577 right_alt = (GET_CODE (right) == EQ_ATTR_ALT
2578 && XINT (right, 1));
2580 if (insn_code >= 0
2581 && (GET_CODE (left) == AND
2582 || left_alt
2583 || GET_CODE (right) == AND
2584 || right_alt))
2586 i = compute_alternative_mask (exp, AND);
2587 if (i & ~insn_alternatives[insn_code])
2588 fatal ("invalid alternative specified for pattern number %d",
2589 insn_index);
2591 /* If all alternatives are excluded, this is false. */
2592 i ^= insn_alternatives[insn_code];
2593 if (i == 0)
2594 return false_rtx;
2595 else if ((i & (i - 1)) == 0 && insn_alternatives[insn_code] > 1)
2597 /* If just one excluded, AND a comparison with that one to the
2598 front of the tree. The others will be eliminated by
2599 optimization. We do not want to do this if the insn has one
2600 alternative and we have tested none of them! */
2601 left = make_alternative_compare (i);
2602 right = simplify_and_tree (exp, &left, insn_code, insn_index);
2603 newexp = attr_rtx (AND, left, right);
2605 return SIMPLIFY_TEST_EXP (newexp, insn_code, insn_index);
2609 if (left != XEXP (exp, 0) || right != XEXP (exp, 1))
2611 newexp = attr_rtx (AND, left, right);
2612 return SIMPLIFY_TEST_EXP (newexp, insn_code, insn_index);
2614 break;
2616 case IOR:
2617 left = SIMPLIFY_TEST_EXP (XEXP (exp, 0), insn_code, insn_index);
2618 if (left == true_rtx)
2619 return true_rtx;
2620 right = SIMPLIFY_TEST_EXP (XEXP (exp, 1), insn_code, insn_index);
2621 if (right == true_rtx)
2622 return true_rtx;
2624 if (GET_CODE (left) == EQ_ATTR_ALT
2625 && GET_CODE (right) == EQ_ATTR_ALT)
2627 exp = attr_alt_union (left, right);
2628 return simplify_test_exp (exp, insn_code, insn_index);
2631 right = simplify_or_tree (right, &left, insn_code, insn_index);
2632 if (left == XEXP (exp, 0) && right == XEXP (exp, 1))
2633 left = simplify_or_tree (left, &right, insn_code, insn_index);
2635 if (right == true_rtx || left == true_rtx)
2636 return true_rtx;
2637 else if (left == false_rtx)
2639 return right;
2641 else if (right == false_rtx)
2643 return left;
2646 /* Test for simple cases where the distributive law is useful. I.e.,
2647 convert (ior (and (x) (y))
2648 (and (x) (z)))
2649 to (and (x)
2650 (ior (y) (z)))
2653 else if (GET_CODE (left) == AND && GET_CODE (right) == AND
2654 && attr_equal_p (XEXP (left, 0), XEXP (right, 0)))
2656 newexp = attr_rtx (IOR, XEXP (left, 1), XEXP (right, 1));
2658 left = XEXP (left, 0);
2659 right = newexp;
2660 newexp = attr_rtx (AND, left, right);
2661 return SIMPLIFY_TEST_EXP (newexp, insn_code, insn_index);
2664 /* Similarly,
2665 convert (ior (and (y) (x))
2666 (and (z) (x)))
2667 to (and (ior (y) (z))
2668 (x))
2669 Note that we want the common term to stay at the end.
2672 else if (GET_CODE (left) == AND && GET_CODE (right) == AND
2673 && attr_equal_p (XEXP (left, 1), XEXP (right, 1)))
2675 newexp = attr_rtx (IOR, XEXP (left, 0), XEXP (right, 0));
2677 left = newexp;
2678 right = XEXP (right, 1);
2679 newexp = attr_rtx (AND, left, right);
2680 return SIMPLIFY_TEST_EXP (newexp, insn_code, insn_index);
2683 /* See if all or all but one of the insn's alternatives are specified
2684 in this tree. Optimize if so. */
2686 else if (insn_code >= 0
2687 && (GET_CODE (left) == IOR
2688 || (GET_CODE (left) == EQ_ATTR_ALT
2689 && !XINT (left, 1))
2690 || (GET_CODE (left) == EQ_ATTR
2691 && XSTR (left, 0) == alternative_name)
2692 || GET_CODE (right) == IOR
2693 || (GET_CODE (right) == EQ_ATTR_ALT
2694 && !XINT (right, 1))
2695 || (GET_CODE (right) == EQ_ATTR
2696 && XSTR (right, 0) == alternative_name)))
2698 i = compute_alternative_mask (exp, IOR);
2699 if (i & ~insn_alternatives[insn_code])
2700 fatal ("invalid alternative specified for pattern number %d",
2701 insn_index);
2703 /* If all alternatives are included, this is true. */
2704 i ^= insn_alternatives[insn_code];
2705 if (i == 0)
2706 return true_rtx;
2707 else if ((i & (i - 1)) == 0 && insn_alternatives[insn_code] > 1)
2709 /* If just one excluded, IOR a comparison with that one to the
2710 front of the tree. The others will be eliminated by
2711 optimization. We do not want to do this if the insn has one
2712 alternative and we have tested none of them! */
2713 left = make_alternative_compare (i);
2714 right = simplify_and_tree (exp, &left, insn_code, insn_index);
2715 newexp = attr_rtx (IOR, attr_rtx (NOT, left), right);
2717 return SIMPLIFY_TEST_EXP (newexp, insn_code, insn_index);
2721 if (left != XEXP (exp, 0) || right != XEXP (exp, 1))
2723 newexp = attr_rtx (IOR, left, right);
2724 return SIMPLIFY_TEST_EXP (newexp, insn_code, insn_index);
2726 break;
2728 case NOT:
2729 if (GET_CODE (XEXP (exp, 0)) == NOT)
2731 left = SIMPLIFY_TEST_EXP (XEXP (XEXP (exp, 0), 0),
2732 insn_code, insn_index);
2733 return left;
2736 left = SIMPLIFY_TEST_EXP (XEXP (exp, 0), insn_code, insn_index);
2737 if (GET_CODE (left) == NOT)
2738 return XEXP (left, 0);
2740 if (left == false_rtx)
2741 return true_rtx;
2742 if (left == true_rtx)
2743 return false_rtx;
2745 if (GET_CODE (left) == EQ_ATTR_ALT)
2747 exp = attr_alt_complement (left);
2748 return simplify_test_exp (exp, insn_code, insn_index);
2751 /* Try to apply De`Morgan's laws. */
2752 if (GET_CODE (left) == IOR)
2754 newexp = attr_rtx (AND,
2755 attr_rtx (NOT, XEXP (left, 0)),
2756 attr_rtx (NOT, XEXP (left, 1)));
2758 newexp = SIMPLIFY_TEST_EXP (newexp, insn_code, insn_index);
2760 else if (GET_CODE (left) == AND)
2762 newexp = attr_rtx (IOR,
2763 attr_rtx (NOT, XEXP (left, 0)),
2764 attr_rtx (NOT, XEXP (left, 1)));
2766 newexp = SIMPLIFY_TEST_EXP (newexp, insn_code, insn_index);
2768 else if (left != XEXP (exp, 0))
2770 newexp = attr_rtx (NOT, left);
2772 break;
2774 case EQ_ATTR_ALT:
2775 if (!XINT (exp, 0))
2776 return XINT (exp, 1) ? true_rtx : false_rtx;
2777 break;
2779 case EQ_ATTR:
2780 if (XSTR (exp, 0) == alternative_name)
2782 newexp = mk_attr_alt (1 << atoi (XSTR (exp, 1)));
2783 break;
2786 /* Look at the value for this insn code in the specified attribute.
2787 We normally can replace this comparison with the condition that
2788 would give this insn the values being tested for. */
2789 if (insn_code >= 0
2790 && (attr = find_attr (&XSTR (exp, 0), 0)) != NULL)
2792 rtx x;
2794 av = NULL;
2795 if (insn_code_values)
2797 for (iv = insn_code_values[insn_code]; iv; iv = iv->next)
2798 if (iv->attr == attr)
2800 av = iv->av;
2801 break;
2804 else
2806 for (av = attr->first_value; av; av = av->next)
2807 for (ie = av->first_insn; ie; ie = ie->next)
2808 if (ie->def->insn_code == insn_code)
2809 goto got_av;
2812 if (av)
2814 got_av:
2815 x = evaluate_eq_attr (exp, attr, av->value,
2816 insn_code, insn_index);
2817 x = SIMPLIFY_TEST_EXP (x, insn_code, insn_index);
2818 if (attr_rtx_cost (x) < 7)
2819 return x;
2822 break;
2824 default:
2825 break;
2828 /* We have already simplified this expression. Simplifying it again
2829 won't buy anything unless we weren't given a valid insn code
2830 to process (i.e., we are canonicalizing something.). */
2831 if (insn_code != -2
2832 && ! ATTR_IND_SIMPLIFIED_P (newexp))
2833 return copy_rtx_unchanging (newexp);
2835 return newexp;
2838 /* Return 1 if any EQ_ATTR subexpression of P refers to ATTR,
2839 otherwise return 0. */
2841 static int
2842 tests_attr_p (rtx p, struct attr_desc *attr)
2844 const char *fmt;
2845 int i, ie, j, je;
2847 if (GET_CODE (p) == EQ_ATTR)
2849 if (XSTR (p, 0) != attr->name)
2850 return 0;
2851 return 1;
2854 fmt = GET_RTX_FORMAT (GET_CODE (p));
2855 ie = GET_RTX_LENGTH (GET_CODE (p));
2856 for (i = 0; i < ie; i++)
2858 switch (*fmt++)
2860 case 'e':
2861 if (tests_attr_p (XEXP (p, i), attr))
2862 return 1;
2863 break;
2865 case 'E':
2866 je = XVECLEN (p, i);
2867 for (j = 0; j < je; ++j)
2868 if (tests_attr_p (XVECEXP (p, i, j), attr))
2869 return 1;
2870 break;
2874 return 0;
2877 /* Calculate a topological sorting of all attributes so that
2878 all attributes only depend on attributes in front of it.
2879 Place the result in *RET (which is a pointer to an array of
2880 attr_desc pointers), and return the size of that array. */
2882 static int
2883 get_attr_order (struct attr_desc ***ret)
2885 int i, j;
2886 int num = 0;
2887 struct attr_desc *attr;
2888 struct attr_desc **all, **sorted;
2889 char *handled;
2890 for (i = 0; i < MAX_ATTRS_INDEX; i++)
2891 for (attr = attrs[i]; attr; attr = attr->next)
2892 num++;
2893 all = XNEWVEC (struct attr_desc *, num);
2894 sorted = XNEWVEC (struct attr_desc *, num);
2895 handled = XCNEWVEC (char, num);
2896 num = 0;
2897 for (i = 0; i < MAX_ATTRS_INDEX; i++)
2898 for (attr = attrs[i]; attr; attr = attr->next)
2899 all[num++] = attr;
2901 j = 0;
2902 for (i = 0; i < num; i++)
2903 if (all[i]->is_const)
2904 handled[i] = 1, sorted[j++] = all[i];
2906 /* We have only few attributes hence we can live with the inner
2907 loop being O(n^2), unlike the normal fast variants of topological
2908 sorting. */
2909 while (j < num)
2911 for (i = 0; i < num; i++)
2912 if (!handled[i])
2914 /* Let's see if I depends on anything interesting. */
2915 int k;
2916 for (k = 0; k < num; k++)
2917 if (!handled[k])
2919 struct attr_value *av;
2920 for (av = all[i]->first_value; av; av = av->next)
2921 if (av->num_insns != 0)
2922 if (tests_attr_p (av->value, all[k]))
2923 break;
2925 if (av)
2926 /* Something in I depends on K. */
2927 break;
2929 if (k == num)
2931 /* Nothing in I depended on anything intersting, so
2932 it's done. */
2933 handled[i] = 1;
2934 sorted[j++] = all[i];
2939 if (DEBUG)
2940 for (j = 0; j < num; j++)
2942 struct attr_desc *attr2;
2943 struct attr_value *av;
2945 attr = sorted[j];
2946 fprintf (stderr, "%s depends on: ", attr->name);
2947 for (i = 0; i < MAX_ATTRS_INDEX; ++i)
2948 for (attr2 = attrs[i]; attr2; attr2 = attr2->next)
2949 if (!attr2->is_const)
2950 for (av = attr->first_value; av; av = av->next)
2951 if (av->num_insns != 0)
2952 if (tests_attr_p (av->value, attr2))
2954 fprintf (stderr, "%s, ", attr2->name);
2955 break;
2957 fprintf (stderr, "\n");
2960 free (all);
2961 *ret = sorted;
2962 return num;
2965 /* Optimize the attribute lists by seeing if we can determine conditional
2966 values from the known values of other attributes. This will save subroutine
2967 calls during the compilation. */
2969 static void
2970 optimize_attrs (void)
2972 struct attr_desc *attr;
2973 struct attr_value *av;
2974 struct insn_ent *ie;
2975 rtx newexp;
2976 int i;
2977 struct attr_value_list *ivbuf;
2978 struct attr_value_list *iv;
2979 struct attr_desc **topsort;
2980 int topnum;
2982 /* For each insn code, make a list of all the insn_ent's for it,
2983 for all values for all attributes. */
2985 if (num_insn_ents == 0)
2986 return;
2988 /* Make 2 extra elements, for "code" values -2 and -1. */
2989 insn_code_values = XCNEWVEC (struct attr_value_list *, insn_code_number + 2);
2991 /* Offset the table address so we can index by -2 or -1. */
2992 insn_code_values += 2;
2994 iv = ivbuf = XNEWVEC (struct attr_value_list, num_insn_ents);
2996 /* Create the chain of insn*attr values such that we see dependend
2997 attributes after their dependencies. As we use a stack via the
2998 next pointers start from the end of the topological order. */
2999 topnum = get_attr_order (&topsort);
3000 for (i = topnum - 1; i >= 0; i--)
3001 for (av = topsort[i]->first_value; av; av = av->next)
3002 for (ie = av->first_insn; ie; ie = ie->next)
3004 iv->attr = topsort[i];
3005 iv->av = av;
3006 iv->ie = ie;
3007 iv->next = insn_code_values[ie->def->insn_code];
3008 insn_code_values[ie->def->insn_code] = iv;
3009 iv++;
3011 free (topsort);
3013 /* Sanity check on num_insn_ents. */
3014 gcc_assert (iv == ivbuf + num_insn_ents);
3016 /* Process one insn code at a time. */
3017 for (i = -2; i < insn_code_number; i++)
3019 /* Clear the ATTR_CURR_SIMPLIFIED_P flag everywhere relevant.
3020 We use it to mean "already simplified for this insn". */
3021 for (iv = insn_code_values[i]; iv; iv = iv->next)
3022 clear_struct_flag (iv->av->value);
3024 for (iv = insn_code_values[i]; iv; iv = iv->next)
3026 struct obstack *old = rtl_obstack;
3028 attr = iv->attr;
3029 av = iv->av;
3030 ie = iv->ie;
3031 if (GET_CODE (av->value) != COND)
3032 continue;
3034 rtl_obstack = temp_obstack;
3035 newexp = av->value;
3036 while (GET_CODE (newexp) == COND)
3038 rtx newexp2 = simplify_cond (newexp, ie->def->insn_code,
3039 ie->def->insn_index);
3040 if (newexp2 == newexp)
3041 break;
3042 newexp = newexp2;
3045 rtl_obstack = old;
3046 /* If we created a new value for this instruction, and it's
3047 cheaper than the old value, and overall cheap, use that
3048 one as specific value for the current instruction.
3049 The last test is to avoid exploding the get_attr_ function
3050 sizes for no much gain. */
3051 if (newexp != av->value
3052 && attr_rtx_cost (newexp) < attr_rtx_cost (av->value)
3053 && attr_rtx_cost (newexp) < 26
3056 newexp = attr_copy_rtx (newexp);
3057 remove_insn_ent (av, ie);
3058 av = get_attr_value (newexp, attr, ie->def->insn_code);
3059 iv->av = av;
3060 insert_insn_ent (av, ie);
3065 free (ivbuf);
3066 free (insn_code_values - 2);
3067 insn_code_values = NULL;
3070 /* Clear the ATTR_CURR_SIMPLIFIED_P flag in EXP and its subexpressions. */
3072 static void
3073 clear_struct_flag (rtx x)
3075 int i;
3076 int j;
3077 enum rtx_code code;
3078 const char *fmt;
3080 ATTR_CURR_SIMPLIFIED_P (x) = 0;
3081 if (ATTR_IND_SIMPLIFIED_P (x))
3082 return;
3084 code = GET_CODE (x);
3086 switch (code)
3088 case REG:
3089 CASE_CONST_ANY:
3090 case MATCH_TEST:
3091 case SYMBOL_REF:
3092 case CODE_LABEL:
3093 case PC:
3094 case CC0:
3095 case EQ_ATTR:
3096 case ATTR_FLAG:
3097 return;
3099 default:
3100 break;
3103 /* Compare the elements. If any pair of corresponding elements
3104 fail to match, return 0 for the whole things. */
3106 fmt = GET_RTX_FORMAT (code);
3107 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
3109 switch (fmt[i])
3111 case 'V':
3112 case 'E':
3113 for (j = 0; j < XVECLEN (x, i); j++)
3114 clear_struct_flag (XVECEXP (x, i, j));
3115 break;
3117 case 'e':
3118 clear_struct_flag (XEXP (x, i));
3119 break;
3124 /* Add attribute value NAME to the beginning of ATTR's list. */
3126 static void
3127 add_attr_value (struct attr_desc *attr, const char *name)
3129 struct attr_value *av;
3131 av = oballoc (struct attr_value);
3132 av->value = attr_rtx (CONST_STRING, name);
3133 av->next = attr->first_value;
3134 attr->first_value = av;
3135 av->first_insn = NULL;
3136 av->num_insns = 0;
3137 av->has_asm_insn = 0;
3140 /* Create table entries for DEFINE_ATTR or DEFINE_ENUM_ATTR. */
3142 static void
3143 gen_attr (rtx exp, int lineno)
3145 struct enum_type *et;
3146 struct enum_value *ev;
3147 struct attr_desc *attr;
3148 const char *name_ptr;
3149 char *p;
3151 /* Make a new attribute structure. Check for duplicate by looking at
3152 attr->default_val, since it is initialized by this routine. */
3153 attr = find_attr (&XSTR (exp, 0), 1);
3154 if (attr->default_val)
3156 error_with_line (lineno, "duplicate definition for attribute %s",
3157 attr->name);
3158 message_with_line (attr->lineno, "previous definition");
3159 return;
3161 attr->lineno = lineno;
3163 if (GET_CODE (exp) == DEFINE_ENUM_ATTR)
3165 attr->enum_name = XSTR (exp, 1);
3166 et = lookup_enum_type (XSTR (exp, 1));
3167 if (!et || !et->md_p)
3168 error_with_line (lineno, "No define_enum called `%s' defined",
3169 attr->name);
3170 if (et)
3171 for (ev = et->values; ev; ev = ev->next)
3172 add_attr_value (attr, ev->name);
3174 else if (*XSTR (exp, 1) == '\0')
3175 attr->is_numeric = 1;
3176 else
3178 name_ptr = XSTR (exp, 1);
3179 while ((p = next_comma_elt (&name_ptr)) != NULL)
3180 add_attr_value (attr, p);
3183 if (GET_CODE (XEXP (exp, 2)) == CONST)
3185 attr->is_const = 1;
3186 if (attr->is_numeric)
3187 error_with_line (lineno,
3188 "constant attributes may not take numeric values");
3190 /* Get rid of the CONST node. It is allowed only at top-level. */
3191 XEXP (exp, 2) = XEXP (XEXP (exp, 2), 0);
3194 if (! strcmp_check (attr->name, length_str) && ! attr->is_numeric)
3195 error_with_line (lineno, "`length' attribute must take numeric values");
3197 /* Set up the default value. */
3198 XEXP (exp, 2) = check_attr_value (XEXP (exp, 2), attr);
3199 attr->default_val = get_attr_value (XEXP (exp, 2), attr, -2);
3202 /* Given a pattern for DEFINE_PEEPHOLE or DEFINE_INSN, return the number of
3203 alternatives in the constraints. Assume all MATCH_OPERANDs have the same
3204 number of alternatives as this should be checked elsewhere. */
3206 static int
3207 count_alternatives (rtx exp)
3209 int i, j, n;
3210 const char *fmt;
3212 if (GET_CODE (exp) == MATCH_OPERAND)
3213 return n_comma_elts (XSTR (exp, 2));
3215 for (i = 0, fmt = GET_RTX_FORMAT (GET_CODE (exp));
3216 i < GET_RTX_LENGTH (GET_CODE (exp)); i++)
3217 switch (*fmt++)
3219 case 'e':
3220 case 'u':
3221 n = count_alternatives (XEXP (exp, i));
3222 if (n)
3223 return n;
3224 break;
3226 case 'E':
3227 case 'V':
3228 if (XVEC (exp, i) != NULL)
3229 for (j = 0; j < XVECLEN (exp, i); j++)
3231 n = count_alternatives (XVECEXP (exp, i, j));
3232 if (n)
3233 return n;
3237 return 0;
3240 /* Returns nonzero if the given expression contains an EQ_ATTR with the
3241 `alternative' attribute. */
3243 static int
3244 compares_alternatives_p (rtx exp)
3246 int i, j;
3247 const char *fmt;
3249 if (GET_CODE (exp) == EQ_ATTR && XSTR (exp, 0) == alternative_name)
3250 return 1;
3252 for (i = 0, fmt = GET_RTX_FORMAT (GET_CODE (exp));
3253 i < GET_RTX_LENGTH (GET_CODE (exp)); i++)
3254 switch (*fmt++)
3256 case 'e':
3257 case 'u':
3258 if (compares_alternatives_p (XEXP (exp, i)))
3259 return 1;
3260 break;
3262 case 'E':
3263 for (j = 0; j < XVECLEN (exp, i); j++)
3264 if (compares_alternatives_p (XVECEXP (exp, i, j)))
3265 return 1;
3266 break;
3269 return 0;
3272 /* Process DEFINE_PEEPHOLE, DEFINE_INSN, and DEFINE_ASM_ATTRIBUTES. */
3274 static void
3275 gen_insn (rtx exp, int lineno)
3277 struct insn_def *id;
3279 id = oballoc (struct insn_def);
3280 id->next = defs;
3281 defs = id;
3282 id->def = exp;
3283 id->lineno = lineno;
3285 switch (GET_CODE (exp))
3287 case DEFINE_INSN:
3288 id->insn_code = insn_code_number;
3289 id->insn_index = insn_index_number;
3290 id->num_alternatives = count_alternatives (exp);
3291 if (id->num_alternatives == 0)
3292 id->num_alternatives = 1;
3293 id->vec_idx = 4;
3294 break;
3296 case DEFINE_PEEPHOLE:
3297 id->insn_code = insn_code_number;
3298 id->insn_index = insn_index_number;
3299 id->num_alternatives = count_alternatives (exp);
3300 if (id->num_alternatives == 0)
3301 id->num_alternatives = 1;
3302 id->vec_idx = 3;
3303 break;
3305 case DEFINE_ASM_ATTRIBUTES:
3306 id->insn_code = -1;
3307 id->insn_index = -1;
3308 id->num_alternatives = 1;
3309 id->vec_idx = 0;
3310 got_define_asm_attributes = 1;
3311 break;
3313 default:
3314 gcc_unreachable ();
3318 /* Process a DEFINE_DELAY. Validate the vector length, check if annul
3319 true or annul false is specified, and make a `struct delay_desc'. */
3321 static void
3322 gen_delay (rtx def, int lineno)
3324 struct delay_desc *delay;
3325 int i;
3327 if (XVECLEN (def, 1) % 3 != 0)
3329 error_with_line (lineno,
3330 "number of elements in DEFINE_DELAY must"
3331 " be multiple of three");
3332 return;
3335 for (i = 0; i < XVECLEN (def, 1); i += 3)
3337 if (XVECEXP (def, 1, i + 1))
3338 have_annul_true = 1;
3339 if (XVECEXP (def, 1, i + 2))
3340 have_annul_false = 1;
3343 delay = oballoc (struct delay_desc);
3344 delay->def = def;
3345 delay->num = ++num_delays;
3346 delay->next = delays;
3347 delay->lineno = lineno;
3348 delays = delay;
3351 /* Names of attributes that could be possibly cached. */
3352 static const char *cached_attrs[32];
3353 /* Number of such attributes. */
3354 static int cached_attr_count;
3355 /* Bitmasks of possibly cached attributes. */
3356 static unsigned int attrs_seen_once, attrs_seen_more_than_once;
3357 static unsigned int attrs_to_cache;
3358 static unsigned int attrs_cached_inside, attrs_cached_after;
3360 /* Finds non-const attributes that could be possibly cached.
3361 When create is TRUE, fills in cached_attrs array.
3362 Computes ATTRS_SEEN_ONCE and ATTRS_SEEN_MORE_THAN_ONCE
3363 bitmasks. */
3365 static void
3366 find_attrs_to_cache (rtx exp, bool create)
3368 int i;
3369 const char *name;
3370 struct attr_desc *attr;
3372 if (exp == NULL)
3373 return;
3375 switch (GET_CODE (exp))
3377 case NOT:
3378 if (GET_CODE (XEXP (exp, 0)) == EQ_ATTR)
3379 find_attrs_to_cache (XEXP (exp, 0), create);
3380 return;
3382 case EQ_ATTR:
3383 name = XSTR (exp, 0);
3384 if (name == alternative_name)
3385 return;
3386 for (i = 0; i < cached_attr_count; i++)
3387 if (name == cached_attrs[i])
3389 if ((attrs_seen_once & (1U << i)) != 0)
3390 attrs_seen_more_than_once |= (1U << i);
3391 else
3392 attrs_seen_once |= (1U << i);
3393 return;
3395 if (!create)
3396 return;
3397 attr = find_attr (&name, 0);
3398 gcc_assert (attr);
3399 if (attr->is_const)
3400 return;
3401 if (cached_attr_count == 32)
3402 return;
3403 cached_attrs[cached_attr_count] = XSTR (exp, 0);
3404 attrs_seen_once |= (1U << cached_attr_count);
3405 cached_attr_count++;
3406 return;
3408 case AND:
3409 case IOR:
3410 find_attrs_to_cache (XEXP (exp, 0), create);
3411 find_attrs_to_cache (XEXP (exp, 1), create);
3412 return;
3414 case COND:
3415 for (i = 0; i < XVECLEN (exp, 0); i += 2)
3416 find_attrs_to_cache (XVECEXP (exp, 0, i), create);
3417 return;
3419 default:
3420 return;
3424 /* Given a piece of RTX, print a C expression to test its truth value to OUTF.
3425 We use AND and IOR both for logical and bit-wise operations, so
3426 interpret them as logical unless they are inside a comparison expression. */
3428 /* Interpret AND/IOR as bit-wise operations instead of logical. */
3429 #define FLG_BITWISE 1
3430 /* Set if cached attribute will be known initialized in else block after
3431 this condition. This is true for LHS of toplevel && and || and
3432 even for RHS of ||, but not for RHS of &&. */
3433 #define FLG_AFTER 2
3434 /* Set if cached attribute will be known initialized in then block after
3435 this condition. This is true for LHS of toplevel && and || and
3436 even for RHS of &&, but not for RHS of ||. */
3437 #define FLG_INSIDE 4
3438 /* Cleared when an operand of &&. */
3439 #define FLG_OUTSIDE_AND 8
3441 static unsigned int
3442 write_test_expr (FILE *outf, rtx exp, unsigned int attrs_cached, int flags)
3444 int comparison_operator = 0;
3445 RTX_CODE code;
3446 struct attr_desc *attr;
3448 /* In order not to worry about operator precedence, surround our part of
3449 the expression with parentheses. */
3451 fprintf (outf, "(");
3452 code = GET_CODE (exp);
3453 switch (code)
3455 /* Binary operators. */
3456 case GEU: case GTU:
3457 case LEU: case LTU:
3458 fprintf (outf, "(unsigned) ");
3459 /* Fall through. */
3461 case EQ: case NE:
3462 case GE: case GT:
3463 case LE: case LT:
3464 comparison_operator = FLG_BITWISE;
3466 case PLUS: case MINUS: case MULT: case DIV: case MOD:
3467 case AND: case IOR: case XOR:
3468 case ASHIFT: case LSHIFTRT: case ASHIFTRT:
3469 if ((code != AND && code != IOR) || (flags & FLG_BITWISE))
3471 flags &= ~(FLG_AFTER | FLG_INSIDE | FLG_OUTSIDE_AND);
3472 write_test_expr (outf, XEXP (exp, 0), attrs_cached,
3473 flags | comparison_operator);
3475 else
3477 if (code == AND)
3478 flags &= ~FLG_OUTSIDE_AND;
3479 if (GET_CODE (XEXP (exp, 0)) == code
3480 || GET_CODE (XEXP (exp, 0)) == EQ_ATTR
3481 || (GET_CODE (XEXP (exp, 0)) == NOT
3482 && GET_CODE (XEXP (XEXP (exp, 0), 0)) == EQ_ATTR))
3483 attrs_cached
3484 = write_test_expr (outf, XEXP (exp, 0), attrs_cached, flags);
3485 else
3486 write_test_expr (outf, XEXP (exp, 0), attrs_cached, flags);
3488 switch (code)
3490 case EQ:
3491 fprintf (outf, " == ");
3492 break;
3493 case NE:
3494 fprintf (outf, " != ");
3495 break;
3496 case GE:
3497 fprintf (outf, " >= ");
3498 break;
3499 case GT:
3500 fprintf (outf, " > ");
3501 break;
3502 case GEU:
3503 fprintf (outf, " >= (unsigned) ");
3504 break;
3505 case GTU:
3506 fprintf (outf, " > (unsigned) ");
3507 break;
3508 case LE:
3509 fprintf (outf, " <= ");
3510 break;
3511 case LT:
3512 fprintf (outf, " < ");
3513 break;
3514 case LEU:
3515 fprintf (outf, " <= (unsigned) ");
3516 break;
3517 case LTU:
3518 fprintf (outf, " < (unsigned) ");
3519 break;
3520 case PLUS:
3521 fprintf (outf, " + ");
3522 break;
3523 case MINUS:
3524 fprintf (outf, " - ");
3525 break;
3526 case MULT:
3527 fprintf (outf, " * ");
3528 break;
3529 case DIV:
3530 fprintf (outf, " / ");
3531 break;
3532 case MOD:
3533 fprintf (outf, " %% ");
3534 break;
3535 case AND:
3536 if (flags & FLG_BITWISE)
3537 fprintf (outf, " & ");
3538 else
3539 fprintf (outf, " && ");
3540 break;
3541 case IOR:
3542 if (flags & FLG_BITWISE)
3543 fprintf (outf, " | ");
3544 else
3545 fprintf (outf, " || ");
3546 break;
3547 case XOR:
3548 fprintf (outf, " ^ ");
3549 break;
3550 case ASHIFT:
3551 fprintf (outf, " << ");
3552 break;
3553 case LSHIFTRT:
3554 case ASHIFTRT:
3555 fprintf (outf, " >> ");
3556 break;
3557 default:
3558 gcc_unreachable ();
3561 if (code == AND)
3563 /* For if (something && (cached_x = get_attr_x (insn)) == X)
3564 cached_x is only known to be initialized in then block. */
3565 flags &= ~FLG_AFTER;
3567 else if (code == IOR)
3569 if (flags & FLG_OUTSIDE_AND)
3570 /* For if (something || (cached_x = get_attr_x (insn)) == X)
3571 cached_x is only known to be initialized in else block
3572 and else if conditions. */
3573 flags &= ~FLG_INSIDE;
3574 else
3575 /* For if ((something || (cached_x = get_attr_x (insn)) == X)
3576 && something_else)
3577 cached_x is not know to be initialized anywhere. */
3578 flags &= ~(FLG_AFTER | FLG_INSIDE);
3580 if ((code == AND || code == IOR)
3581 && (GET_CODE (XEXP (exp, 1)) == code
3582 || GET_CODE (XEXP (exp, 1)) == EQ_ATTR
3583 || (GET_CODE (XEXP (exp, 1)) == NOT
3584 && GET_CODE (XEXP (XEXP (exp, 1), 0)) == EQ_ATTR)))
3585 attrs_cached
3586 = write_test_expr (outf, XEXP (exp, 1), attrs_cached, flags);
3587 else
3588 write_test_expr (outf, XEXP (exp, 1), attrs_cached,
3589 flags | comparison_operator);
3590 break;
3592 case NOT:
3593 /* Special-case (not (eq_attrq "alternative" "x")) */
3594 if (! (flags & FLG_BITWISE) && GET_CODE (XEXP (exp, 0)) == EQ_ATTR)
3596 if (XSTR (XEXP (exp, 0), 0) == alternative_name)
3598 fprintf (outf, "which_alternative != %s",
3599 XSTR (XEXP (exp, 0), 1));
3600 break;
3603 fprintf (outf, "! ");
3604 attrs_cached =
3605 write_test_expr (outf, XEXP (exp, 0), attrs_cached, flags);
3606 break;
3609 /* Otherwise, fall through to normal unary operator. */
3611 /* Unary operators. */
3612 case ABS: case NEG:
3613 switch (code)
3615 case NOT:
3616 if (flags & FLG_BITWISE)
3617 fprintf (outf, "~ ");
3618 else
3619 fprintf (outf, "! ");
3620 break;
3621 case ABS:
3622 fprintf (outf, "abs ");
3623 break;
3624 case NEG:
3625 fprintf (outf, "-");
3626 break;
3627 default:
3628 gcc_unreachable ();
3631 flags &= ~(FLG_AFTER | FLG_INSIDE | FLG_OUTSIDE_AND);
3632 write_test_expr (outf, XEXP (exp, 0), attrs_cached, flags);
3633 break;
3635 case EQ_ATTR_ALT:
3637 int set = XINT (exp, 0), bit = 0;
3639 if (flags & FLG_BITWISE)
3640 fatal ("EQ_ATTR_ALT not valid inside comparison");
3642 if (!set)
3643 fatal ("Empty EQ_ATTR_ALT should be optimized out");
3645 if (!(set & (set - 1)))
3647 if (!(set & 0xffff))
3649 bit += 16;
3650 set >>= 16;
3652 if (!(set & 0xff))
3654 bit += 8;
3655 set >>= 8;
3657 if (!(set & 0xf))
3659 bit += 4;
3660 set >>= 4;
3662 if (!(set & 0x3))
3664 bit += 2;
3665 set >>= 2;
3667 if (!(set & 1))
3668 bit++;
3670 fprintf (outf, "which_alternative %s= %d",
3671 XINT (exp, 1) ? "!" : "=", bit);
3673 else
3675 fprintf (outf, "%s((1 << which_alternative) & %#x)",
3676 XINT (exp, 1) ? "!" : "", set);
3679 break;
3681 /* Comparison test of an attribute with a value. Most of these will
3682 have been removed by optimization. Handle "alternative"
3683 specially and give error if EQ_ATTR present inside a comparison. */
3684 case EQ_ATTR:
3685 if (flags & FLG_BITWISE)
3686 fatal ("EQ_ATTR not valid inside comparison");
3688 if (XSTR (exp, 0) == alternative_name)
3690 fprintf (outf, "which_alternative == %s", XSTR (exp, 1));
3691 break;
3694 attr = find_attr (&XSTR (exp, 0), 0);
3695 gcc_assert (attr);
3697 /* Now is the time to expand the value of a constant attribute. */
3698 if (attr->is_const)
3700 write_test_expr (outf,
3701 evaluate_eq_attr (exp, attr,
3702 attr->default_val->value,
3703 -2, -2),
3704 attrs_cached, 0);
3706 else
3708 int i;
3709 for (i = 0; i < cached_attr_count; i++)
3710 if (attr->name == cached_attrs[i])
3711 break;
3712 if (i < cached_attr_count && (attrs_cached & (1U << i)) != 0)
3713 fprintf (outf, "cached_%s", attr->name);
3714 else if (i < cached_attr_count && (attrs_to_cache & (1U << i)) != 0)
3716 fprintf (outf, "(cached_%s = get_attr_%s (insn))",
3717 attr->name, attr->name);
3718 if (flags & FLG_AFTER)
3719 attrs_cached_after |= (1U << i);
3720 if (flags & FLG_INSIDE)
3721 attrs_cached_inside |= (1U << i);
3722 attrs_cached |= (1U << i);
3724 else
3725 fprintf (outf, "get_attr_%s (insn)", attr->name);
3726 fprintf (outf, " == ");
3727 write_attr_valueq (outf, attr, XSTR (exp, 1));
3729 break;
3731 /* Comparison test of flags for define_delays. */
3732 case ATTR_FLAG:
3733 if (flags & FLG_BITWISE)
3734 fatal ("ATTR_FLAG not valid inside comparison");
3735 fprintf (outf, "(flags & ATTR_FLAG_%s) != 0", XSTR (exp, 0));
3736 break;
3738 /* See if an operand matches a predicate. */
3739 case MATCH_OPERAND:
3740 /* If only a mode is given, just ensure the mode matches the operand.
3741 If neither a mode nor predicate is given, error. */
3742 if (XSTR (exp, 1) == NULL || *XSTR (exp, 1) == '\0')
3744 if (GET_MODE (exp) == VOIDmode)
3745 fatal ("null MATCH_OPERAND specified as test");
3746 else
3747 fprintf (outf, "GET_MODE (operands[%d]) == %smode",
3748 XINT (exp, 0), GET_MODE_NAME (GET_MODE (exp)));
3750 else
3751 fprintf (outf, "%s (operands[%d], %smode)",
3752 XSTR (exp, 1), XINT (exp, 0), GET_MODE_NAME (GET_MODE (exp)));
3753 break;
3755 /* Constant integer. */
3756 case CONST_INT:
3757 fprintf (outf, HOST_WIDE_INT_PRINT_DEC, XWINT (exp, 0));
3758 break;
3760 case MATCH_TEST:
3761 fprint_c_condition (outf, XSTR (exp, 0));
3762 if (flags & FLG_BITWISE)
3763 fprintf (outf, " != 0");
3764 break;
3766 /* A random C expression. */
3767 case SYMBOL_REF:
3768 fprint_c_condition (outf, XSTR (exp, 0));
3769 break;
3771 /* The address of the branch target. */
3772 case MATCH_DUP:
3773 fprintf (outf,
3774 "INSN_ADDRESSES_SET_P () ? INSN_ADDRESSES (INSN_UID (GET_CODE (operands[%d]) == LABEL_REF ? XEXP (operands[%d], 0) : operands[%d])) : 0",
3775 XINT (exp, 0), XINT (exp, 0), XINT (exp, 0));
3776 break;
3778 case PC:
3779 /* The address of the current insn. We implement this actually as the
3780 address of the current insn for backward branches, but the last
3781 address of the next insn for forward branches, and both with
3782 adjustments that account for the worst-case possible stretching of
3783 intervening alignments between this insn and its destination. */
3784 fprintf (outf, "insn_current_reference_address (insn)");
3785 break;
3787 case CONST_STRING:
3788 fprintf (outf, "%s", XSTR (exp, 0));
3789 break;
3791 case IF_THEN_ELSE:
3792 write_test_expr (outf, XEXP (exp, 0), attrs_cached, 0);
3793 fprintf (outf, " ? ");
3794 write_test_expr (outf, XEXP (exp, 1), attrs_cached, FLG_BITWISE);
3795 fprintf (outf, " : ");
3796 write_test_expr (outf, XEXP (exp, 2), attrs_cached, FLG_BITWISE);
3797 break;
3799 default:
3800 fatal ("bad RTX code `%s' in attribute calculation\n",
3801 GET_RTX_NAME (code));
3804 fprintf (outf, ")");
3805 return attrs_cached;
3808 /* Given an attribute value, return the maximum CONST_STRING argument
3809 encountered. Set *UNKNOWNP and return INT_MAX if the value is unknown. */
3811 static int
3812 max_attr_value (rtx exp, int *unknownp)
3814 int current_max;
3815 int i, n;
3817 switch (GET_CODE (exp))
3819 case CONST_STRING:
3820 current_max = atoi (XSTR (exp, 0));
3821 break;
3823 case COND:
3824 current_max = max_attr_value (XEXP (exp, 1), unknownp);
3825 for (i = 0; i < XVECLEN (exp, 0); i += 2)
3827 n = max_attr_value (XVECEXP (exp, 0, i + 1), unknownp);
3828 if (n > current_max)
3829 current_max = n;
3831 break;
3833 case IF_THEN_ELSE:
3834 current_max = max_attr_value (XEXP (exp, 1), unknownp);
3835 n = max_attr_value (XEXP (exp, 2), unknownp);
3836 if (n > current_max)
3837 current_max = n;
3838 break;
3840 default:
3841 *unknownp = 1;
3842 current_max = INT_MAX;
3843 break;
3846 return current_max;
3849 /* Given an attribute value, return the minimum CONST_STRING argument
3850 encountered. Set *UNKNOWNP and return 0 if the value is unknown. */
3852 static int
3853 min_attr_value (rtx exp, int *unknownp)
3855 int current_min;
3856 int i, n;
3858 switch (GET_CODE (exp))
3860 case CONST_STRING:
3861 current_min = atoi (XSTR (exp, 0));
3862 break;
3864 case COND:
3865 current_min = min_attr_value (XEXP (exp, 1), unknownp);
3866 for (i = 0; i < XVECLEN (exp, 0); i += 2)
3868 n = min_attr_value (XVECEXP (exp, 0, i + 1), unknownp);
3869 if (n < current_min)
3870 current_min = n;
3872 break;
3874 case IF_THEN_ELSE:
3875 current_min = min_attr_value (XEXP (exp, 1), unknownp);
3876 n = min_attr_value (XEXP (exp, 2), unknownp);
3877 if (n < current_min)
3878 current_min = n;
3879 break;
3881 default:
3882 *unknownp = 1;
3883 current_min = INT_MAX;
3884 break;
3887 return current_min;
3890 /* Given an attribute value, return the result of ORing together all
3891 CONST_STRING arguments encountered. Set *UNKNOWNP and return -1
3892 if the numeric value is not known. */
3894 static int
3895 or_attr_value (rtx exp, int *unknownp)
3897 int current_or;
3898 int i;
3900 switch (GET_CODE (exp))
3902 case CONST_STRING:
3903 current_or = atoi (XSTR (exp, 0));
3904 break;
3906 case COND:
3907 current_or = or_attr_value (XEXP (exp, 1), unknownp);
3908 for (i = 0; i < XVECLEN (exp, 0); i += 2)
3909 current_or |= or_attr_value (XVECEXP (exp, 0, i + 1), unknownp);
3910 break;
3912 case IF_THEN_ELSE:
3913 current_or = or_attr_value (XEXP (exp, 1), unknownp);
3914 current_or |= or_attr_value (XEXP (exp, 2), unknownp);
3915 break;
3917 default:
3918 *unknownp = 1;
3919 current_or = -1;
3920 break;
3923 return current_or;
3926 /* Scan an attribute value, possibly a conditional, and record what actions
3927 will be required to do any conditional tests in it.
3929 Specifically, set
3930 `must_extract' if we need to extract the insn operands
3931 `must_constrain' if we must compute `which_alternative'
3932 `address_used' if an address expression was used
3933 `length_used' if an (eq_attr "length" ...) was used
3936 static void
3937 walk_attr_value (rtx exp)
3939 int i, j;
3940 const char *fmt;
3941 RTX_CODE code;
3943 if (exp == NULL)
3944 return;
3946 code = GET_CODE (exp);
3947 switch (code)
3949 case SYMBOL_REF:
3950 if (! ATTR_IND_SIMPLIFIED_P (exp))
3951 /* Since this is an arbitrary expression, it can look at anything.
3952 However, constant expressions do not depend on any particular
3953 insn. */
3954 must_extract = must_constrain = 1;
3955 return;
3957 case MATCH_OPERAND:
3958 must_extract = 1;
3959 return;
3961 case MATCH_TEST:
3962 case EQ_ATTR_ALT:
3963 must_extract = must_constrain = 1;
3964 break;
3966 case EQ_ATTR:
3967 if (XSTR (exp, 0) == alternative_name)
3968 must_extract = must_constrain = 1;
3969 else if (strcmp_check (XSTR (exp, 0), length_str) == 0)
3970 length_used = 1;
3971 return;
3973 case MATCH_DUP:
3974 must_extract = 1;
3975 address_used = 1;
3976 return;
3978 case PC:
3979 address_used = 1;
3980 return;
3982 case ATTR_FLAG:
3983 return;
3985 default:
3986 break;
3989 for (i = 0, fmt = GET_RTX_FORMAT (code); i < GET_RTX_LENGTH (code); i++)
3990 switch (*fmt++)
3992 case 'e':
3993 case 'u':
3994 walk_attr_value (XEXP (exp, i));
3995 break;
3997 case 'E':
3998 if (XVEC (exp, i) != NULL)
3999 for (j = 0; j < XVECLEN (exp, i); j++)
4000 walk_attr_value (XVECEXP (exp, i, j));
4001 break;
4005 /* Write out a function to obtain the attribute for a given INSN. */
4007 static void
4008 write_attr_get (FILE *outf, struct attr_desc *attr)
4010 struct attr_value *av, *common_av;
4011 int i, j;
4013 /* Find the most used attribute value. Handle that as the `default' of the
4014 switch we will generate. */
4015 common_av = find_most_used (attr);
4017 /* Write out start of function, then all values with explicit `case' lines,
4018 then a `default', then the value with the most uses. */
4019 if (attr->enum_name)
4020 fprintf (outf, "enum %s\n", attr->enum_name);
4021 else if (!attr->is_numeric)
4022 fprintf (outf, "enum attr_%s\n", attr->name);
4023 else
4024 fprintf (outf, "int\n");
4026 /* If the attribute name starts with a star, the remainder is the name of
4027 the subroutine to use, instead of `get_attr_...'. */
4028 if (attr->name[0] == '*')
4029 fprintf (outf, "%s (rtx insn ATTRIBUTE_UNUSED)\n", &attr->name[1]);
4030 else if (attr->is_const == 0)
4031 fprintf (outf, "get_attr_%s (rtx insn ATTRIBUTE_UNUSED)\n", attr->name);
4032 else
4034 fprintf (outf, "get_attr_%s (void)\n", attr->name);
4035 fprintf (outf, "{\n");
4037 for (av = attr->first_value; av; av = av->next)
4038 if (av->num_insns == 1)
4039 write_attr_set (outf, attr, 2, av->value, "return", ";",
4040 true_rtx, av->first_insn->def->insn_code,
4041 av->first_insn->def->insn_index, 0);
4042 else if (av->num_insns != 0)
4043 write_attr_set (outf, attr, 2, av->value, "return", ";",
4044 true_rtx, -2, 0, 0);
4046 fprintf (outf, "}\n\n");
4047 return;
4050 fprintf (outf, "{\n");
4052 /* Find attributes that are worth caching in the conditions. */
4053 cached_attr_count = 0;
4054 attrs_seen_more_than_once = 0;
4055 for (av = attr->first_value; av; av = av->next)
4057 attrs_seen_once = 0;
4058 find_attrs_to_cache (av->value, true);
4060 /* Remove those that aren't worth caching from the array. */
4061 for (i = 0, j = 0; i < cached_attr_count; i++)
4062 if ((attrs_seen_more_than_once & (1U << i)) != 0)
4064 const char *name = cached_attrs[i];
4065 struct attr_desc *cached_attr;
4066 if (i != j)
4067 cached_attrs[j] = name;
4068 cached_attr = find_attr (&name, 0);
4069 gcc_assert (cached_attr && cached_attr->is_const == 0);
4070 if (cached_attr->enum_name)
4071 fprintf (outf, " enum %s", cached_attr->enum_name);
4072 else if (!cached_attr->is_numeric)
4073 fprintf (outf, " enum attr_%s", cached_attr->name);
4074 else
4075 fprintf (outf, " int");
4076 fprintf (outf, " cached_%s ATTRIBUTE_UNUSED;\n", name);
4077 j++;
4079 cached_attr_count = j;
4080 if (cached_attr_count)
4081 fprintf (outf, "\n");
4083 fprintf (outf, " switch (recog_memoized (insn))\n");
4084 fprintf (outf, " {\n");
4086 for (av = attr->first_value; av; av = av->next)
4087 if (av != common_av)
4088 write_attr_case (outf, attr, av, 1, "return", ";", 4, true_rtx);
4090 write_attr_case (outf, attr, common_av, 0, "return", ";", 4, true_rtx);
4091 fprintf (outf, " }\n}\n\n");
4092 cached_attr_count = 0;
4095 /* Given an AND tree of known true terms (because we are inside an `if' with
4096 that as the condition or are in an `else' clause) and an expression,
4097 replace any known true terms with TRUE. Use `simplify_and_tree' to do
4098 the bulk of the work. */
4100 static rtx
4101 eliminate_known_true (rtx known_true, rtx exp, int insn_code, int insn_index)
4103 rtx term;
4105 known_true = SIMPLIFY_TEST_EXP (known_true, insn_code, insn_index);
4107 if (GET_CODE (known_true) == AND)
4109 exp = eliminate_known_true (XEXP (known_true, 0), exp,
4110 insn_code, insn_index);
4111 exp = eliminate_known_true (XEXP (known_true, 1), exp,
4112 insn_code, insn_index);
4114 else
4116 term = known_true;
4117 exp = simplify_and_tree (exp, &term, insn_code, insn_index);
4120 return exp;
4123 /* Write out a series of tests and assignment statements to perform tests and
4124 sets of an attribute value. We are passed an indentation amount and prefix
4125 and suffix strings to write around each attribute value (e.g., "return"
4126 and ";"). */
4128 static void
4129 write_attr_set (FILE *outf, struct attr_desc *attr, int indent, rtx value,
4130 const char *prefix, const char *suffix, rtx known_true,
4131 int insn_code, int insn_index, unsigned int attrs_cached)
4133 if (GET_CODE (value) == COND)
4135 /* Assume the default value will be the default of the COND unless we
4136 find an always true expression. */
4137 rtx default_val = XEXP (value, 1);
4138 rtx our_known_true = known_true;
4139 rtx newexp;
4140 int first_if = 1;
4141 int i;
4143 if (cached_attr_count)
4145 attrs_seen_once = 0;
4146 attrs_seen_more_than_once = 0;
4147 for (i = 0; i < XVECLEN (value, 0); i += 2)
4148 find_attrs_to_cache (XVECEXP (value, 0, i), false);
4149 attrs_to_cache |= attrs_seen_more_than_once;
4152 for (i = 0; i < XVECLEN (value, 0); i += 2)
4154 rtx testexp;
4155 rtx inner_true;
4157 /* Reset our_known_true after some time to not accumulate
4158 too much cruft (slowing down genattrtab). */
4159 if ((i & 31) == 0)
4160 our_known_true = known_true;
4161 testexp = eliminate_known_true (our_known_true,
4162 XVECEXP (value, 0, i),
4163 insn_code, insn_index);
4164 newexp = attr_rtx (NOT, testexp);
4165 newexp = insert_right_side (AND, our_known_true, newexp,
4166 insn_code, insn_index);
4168 /* If the test expression is always true or if the next `known_true'
4169 expression is always false, this is the last case, so break
4170 out and let this value be the `else' case. */
4171 if (testexp == true_rtx || newexp == false_rtx)
4173 default_val = XVECEXP (value, 0, i + 1);
4174 break;
4177 /* Compute the expression to pass to our recursive call as being
4178 known true. */
4179 inner_true = insert_right_side (AND, our_known_true,
4180 testexp, insn_code, insn_index);
4182 /* If this is always false, skip it. */
4183 if (inner_true == false_rtx)
4184 continue;
4186 attrs_cached_inside = attrs_cached;
4187 attrs_cached_after = attrs_cached;
4188 write_indent (outf, indent);
4189 fprintf (outf, "%sif ", first_if ? "" : "else ");
4190 first_if = 0;
4191 write_test_expr (outf, testexp, attrs_cached,
4192 (FLG_AFTER | FLG_INSIDE | FLG_OUTSIDE_AND));
4193 attrs_cached = attrs_cached_after;
4194 fprintf (outf, "\n");
4195 write_indent (outf, indent + 2);
4196 fprintf (outf, "{\n");
4198 write_attr_set (outf, attr, indent + 4,
4199 XVECEXP (value, 0, i + 1), prefix, suffix,
4200 inner_true, insn_code, insn_index,
4201 attrs_cached_inside);
4202 write_indent (outf, indent + 2);
4203 fprintf (outf, "}\n");
4204 our_known_true = newexp;
4207 if (! first_if)
4209 write_indent (outf, indent);
4210 fprintf (outf, "else\n");
4211 write_indent (outf, indent + 2);
4212 fprintf (outf, "{\n");
4215 write_attr_set (outf, attr, first_if ? indent : indent + 4, default_val,
4216 prefix, suffix, our_known_true, insn_code, insn_index,
4217 attrs_cached);
4219 if (! first_if)
4221 write_indent (outf, indent + 2);
4222 fprintf (outf, "}\n");
4225 else
4227 write_indent (outf, indent);
4228 fprintf (outf, "%s ", prefix);
4229 write_attr_value (outf, attr, value);
4230 fprintf (outf, "%s\n", suffix);
4234 /* Write a series of case statements for every instruction in list IE.
4235 INDENT is the amount of indentation to write before each case. */
4237 static void
4238 write_insn_cases (FILE *outf, struct insn_ent *ie, int indent)
4240 for (; ie != 0; ie = ie->next)
4241 if (ie->def->insn_code != -1)
4243 write_indent (outf, indent);
4244 if (GET_CODE (ie->def->def) == DEFINE_PEEPHOLE)
4245 fprintf (outf, "case %d: /* define_peephole, line %d */\n",
4246 ie->def->insn_code, ie->def->lineno);
4247 else
4248 fprintf (outf, "case %d: /* %s */\n",
4249 ie->def->insn_code, XSTR (ie->def->def, 0));
4253 /* Write out the computation for one attribute value. */
4255 static void
4256 write_attr_case (FILE *outf, struct attr_desc *attr, struct attr_value *av,
4257 int write_case_lines, const char *prefix, const char *suffix,
4258 int indent, rtx known_true)
4260 if (av->num_insns == 0)
4261 return;
4263 if (av->has_asm_insn)
4265 write_indent (outf, indent);
4266 fprintf (outf, "case -1:\n");
4267 write_indent (outf, indent + 2);
4268 fprintf (outf, "if (GET_CODE (PATTERN (insn)) != ASM_INPUT\n");
4269 write_indent (outf, indent + 2);
4270 fprintf (outf, " && asm_noperands (PATTERN (insn)) < 0)\n");
4271 write_indent (outf, indent + 2);
4272 fprintf (outf, " fatal_insn_not_found (insn);\n");
4275 if (write_case_lines)
4276 write_insn_cases (outf, av->first_insn, indent);
4277 else
4279 write_indent (outf, indent);
4280 fprintf (outf, "default:\n");
4283 /* See what we have to do to output this value. */
4284 must_extract = must_constrain = address_used = 0;
4285 walk_attr_value (av->value);
4287 if (must_constrain)
4289 write_indent (outf, indent + 2);
4290 fprintf (outf, "extract_constrain_insn_cached (insn);\n");
4292 else if (must_extract)
4294 write_indent (outf, indent + 2);
4295 fprintf (outf, "extract_insn_cached (insn);\n");
4298 attrs_to_cache = 0;
4299 if (av->num_insns == 1)
4300 write_attr_set (outf, attr, indent + 2, av->value, prefix, suffix,
4301 known_true, av->first_insn->def->insn_code,
4302 av->first_insn->def->insn_index, 0);
4303 else
4304 write_attr_set (outf, attr, indent + 2, av->value, prefix, suffix,
4305 known_true, -2, 0, 0);
4307 if (strncmp (prefix, "return", 6))
4309 write_indent (outf, indent + 2);
4310 fprintf (outf, "break;\n");
4312 fprintf (outf, "\n");
4315 /* Utilities to write in various forms. */
4317 static void
4318 write_attr_valueq (FILE *outf, struct attr_desc *attr, const char *s)
4320 if (attr->is_numeric)
4322 int num = atoi (s);
4324 fprintf (outf, "%d", num);
4326 if (num > 9 || num < 0)
4327 fprintf (outf, " /* %#x */", num);
4329 else
4331 write_upcase (outf, attr->enum_name ? attr->enum_name : attr->name);
4332 fprintf (outf, "_");
4333 write_upcase (outf, s);
4337 static void
4338 write_attr_value (FILE *outf, struct attr_desc *attr, rtx value)
4340 int op;
4342 switch (GET_CODE (value))
4344 case CONST_STRING:
4345 write_attr_valueq (outf, attr, XSTR (value, 0));
4346 break;
4348 case CONST_INT:
4349 fprintf (outf, HOST_WIDE_INT_PRINT_DEC, INTVAL (value));
4350 break;
4352 case SYMBOL_REF:
4353 fprint_c_condition (outf, XSTR (value, 0));
4354 break;
4356 case ATTR:
4358 struct attr_desc *attr2 = find_attr (&XSTR (value, 0), 0);
4359 if (attr->enum_name)
4360 fprintf (outf, "(enum %s)", attr->enum_name);
4361 else if (!attr->is_numeric)
4362 fprintf (outf, "(enum attr_%s)", attr->name);
4363 else if (!attr2->is_numeric)
4364 fprintf (outf, "(int)");
4366 fprintf (outf, "get_attr_%s (%s)", attr2->name,
4367 (attr2->is_const ? "" : "insn"));
4369 break;
4371 case PLUS:
4372 op = '+';
4373 goto do_operator;
4374 case MINUS:
4375 op = '-';
4376 goto do_operator;
4377 case MULT:
4378 op = '*';
4379 goto do_operator;
4380 case DIV:
4381 op = '/';
4382 goto do_operator;
4383 case MOD:
4384 op = '%';
4385 goto do_operator;
4387 do_operator:
4388 write_attr_value (outf, attr, XEXP (value, 0));
4389 fputc (' ', outf);
4390 fputc (op, outf);
4391 fputc (' ', outf);
4392 write_attr_value (outf, attr, XEXP (value, 1));
4393 break;
4395 default:
4396 gcc_unreachable ();
4400 static void
4401 write_upcase (FILE *outf, const char *str)
4403 while (*str)
4405 /* The argument of TOUPPER should not have side effects. */
4406 fputc (TOUPPER (*str), outf);
4407 str++;
4411 static void
4412 write_indent (FILE *outf, int indent)
4414 for (; indent > 8; indent -= 8)
4415 fprintf (outf, "\t");
4417 for (; indent; indent--)
4418 fprintf (outf, " ");
4421 /* Write a subroutine that is given an insn that requires a delay slot, a
4422 delay slot ordinal, and a candidate insn. It returns nonzero if the
4423 candidate can be placed in the specified delay slot of the insn.
4425 We can write as many as three subroutines. `eligible_for_delay'
4426 handles normal delay slots, `eligible_for_annul_true' indicates that
4427 the specified insn can be annulled if the branch is true, and likewise
4428 for `eligible_for_annul_false'.
4430 KIND is a string distinguishing these three cases ("delay", "annul_true",
4431 or "annul_false"). */
4433 static void
4434 write_eligible_delay (FILE *outf, const char *kind)
4436 struct delay_desc *delay;
4437 int max_slots;
4438 char str[50];
4439 const char *pstr;
4440 struct attr_desc *attr;
4441 struct attr_value *av, *common_av;
4442 int i;
4444 /* Compute the maximum number of delay slots required. We use the delay
4445 ordinal times this number plus one, plus the slot number as an index into
4446 the appropriate predicate to test. */
4448 for (delay = delays, max_slots = 0; delay; delay = delay->next)
4449 if (XVECLEN (delay->def, 1) / 3 > max_slots)
4450 max_slots = XVECLEN (delay->def, 1) / 3;
4452 /* Write function prelude. */
4454 fprintf (outf, "int\n");
4455 fprintf (outf, "eligible_for_%s (rtx delay_insn ATTRIBUTE_UNUSED, int slot, \n"
4456 " rtx candidate_insn, int flags ATTRIBUTE_UNUSED)\n",
4457 kind);
4458 fprintf (outf, "{\n");
4459 fprintf (outf, " rtx insn;\n");
4460 fprintf (outf, "\n");
4461 fprintf (outf, " gcc_assert (slot < %d);\n", max_slots);
4462 fprintf (outf, "\n");
4463 /* Allow dbr_schedule to pass labels, etc. This can happen if try_split
4464 converts a compound instruction into a loop. */
4465 fprintf (outf, " if (!INSN_P (candidate_insn))\n");
4466 fprintf (outf, " return 0;\n");
4467 fprintf (outf, "\n");
4469 /* If more than one delay type, find out which type the delay insn is. */
4471 if (num_delays > 1)
4473 attr = find_attr (&delay_type_str, 0);
4474 gcc_assert (attr);
4475 common_av = find_most_used (attr);
4477 fprintf (outf, " insn = delay_insn;\n");
4478 fprintf (outf, " switch (recog_memoized (insn))\n");
4479 fprintf (outf, " {\n");
4481 sprintf (str, " * %d;\n break;", max_slots);
4482 for (av = attr->first_value; av; av = av->next)
4483 if (av != common_av)
4484 write_attr_case (outf, attr, av, 1, "slot +=", str, 4, true_rtx);
4486 write_attr_case (outf, attr, common_av, 0, "slot +=", str, 4, true_rtx);
4487 fprintf (outf, " }\n\n");
4489 /* Ensure matched. Otherwise, shouldn't have been called. */
4490 fprintf (outf, " gcc_assert (slot >= %d);\n\n", max_slots);
4493 /* If just one type of delay slot, write simple switch. */
4494 if (num_delays == 1 && max_slots == 1)
4496 fprintf (outf, " insn = candidate_insn;\n");
4497 fprintf (outf, " switch (recog_memoized (insn))\n");
4498 fprintf (outf, " {\n");
4500 attr = find_attr (&delay_1_0_str, 0);
4501 gcc_assert (attr);
4502 common_av = find_most_used (attr);
4504 for (av = attr->first_value; av; av = av->next)
4505 if (av != common_av)
4506 write_attr_case (outf, attr, av, 1, "return", ";", 4, true_rtx);
4508 write_attr_case (outf, attr, common_av, 0, "return", ";", 4, true_rtx);
4509 fprintf (outf, " }\n");
4512 else
4514 /* Write a nested CASE. The first indicates which condition we need to
4515 test, and the inner CASE tests the condition. */
4516 fprintf (outf, " insn = candidate_insn;\n");
4517 fprintf (outf, " switch (slot)\n");
4518 fprintf (outf, " {\n");
4520 for (delay = delays; delay; delay = delay->next)
4521 for (i = 0; i < XVECLEN (delay->def, 1); i += 3)
4523 fprintf (outf, " case %d:\n",
4524 (i / 3) + (num_delays == 1 ? 0 : delay->num * max_slots));
4525 fprintf (outf, " switch (recog_memoized (insn))\n");
4526 fprintf (outf, "\t{\n");
4528 sprintf (str, "*%s_%d_%d", kind, delay->num, i / 3);
4529 pstr = str;
4530 attr = find_attr (&pstr, 0);
4531 gcc_assert (attr);
4532 common_av = find_most_used (attr);
4534 for (av = attr->first_value; av; av = av->next)
4535 if (av != common_av)
4536 write_attr_case (outf, attr, av, 1, "return", ";", 8, true_rtx);
4538 write_attr_case (outf, attr, common_av, 0, "return", ";", 8, true_rtx);
4539 fprintf (outf, " }\n");
4542 fprintf (outf, " default:\n");
4543 fprintf (outf, " gcc_unreachable ();\n");
4544 fprintf (outf, " }\n");
4547 fprintf (outf, "}\n\n");
4550 /* This page contains miscellaneous utility routines. */
4552 /* Given a pointer to a (char *), return a malloc'ed string containing the
4553 next comma-separated element. Advance the pointer to after the string
4554 scanned, or the end-of-string. Return NULL if at end of string. */
4556 static char *
4557 next_comma_elt (const char **pstr)
4559 const char *start;
4561 start = scan_comma_elt (pstr);
4563 if (start == NULL)
4564 return NULL;
4566 return attr_string (start, *pstr - start);
4569 /* Return a `struct attr_desc' pointer for a given named attribute. If CREATE
4570 is nonzero, build a new attribute, if one does not exist. *NAME_P is
4571 replaced by a pointer to a canonical copy of the string. */
4573 static struct attr_desc *
4574 find_attr (const char **name_p, int create)
4576 struct attr_desc *attr;
4577 int index;
4578 const char *name = *name_p;
4580 /* Before we resort to using `strcmp', see if the string address matches
4581 anywhere. In most cases, it should have been canonicalized to do so. */
4582 if (name == alternative_name)
4583 return NULL;
4585 index = name[0] & (MAX_ATTRS_INDEX - 1);
4586 for (attr = attrs[index]; attr; attr = attr->next)
4587 if (name == attr->name)
4588 return attr;
4590 /* Otherwise, do it the slow way. */
4591 for (attr = attrs[index]; attr; attr = attr->next)
4592 if (name[0] == attr->name[0] && ! strcmp (name, attr->name))
4594 *name_p = attr->name;
4595 return attr;
4598 if (! create)
4599 return NULL;
4601 attr = oballoc (struct attr_desc);
4602 attr->name = DEF_ATTR_STRING (name);
4603 attr->enum_name = 0;
4604 attr->first_value = attr->default_val = NULL;
4605 attr->is_numeric = attr->is_const = attr->is_special = 0;
4606 attr->next = attrs[index];
4607 attrs[index] = attr;
4609 *name_p = attr->name;
4611 return attr;
4614 /* Create internal attribute with the given default value. */
4616 static void
4617 make_internal_attr (const char *name, rtx value, int special)
4619 struct attr_desc *attr;
4621 attr = find_attr (&name, 1);
4622 gcc_assert (!attr->default_val);
4624 attr->is_numeric = 1;
4625 attr->is_const = 0;
4626 attr->is_special = (special & ATTR_SPECIAL) != 0;
4627 attr->default_val = get_attr_value (value, attr, -2);
4630 /* Find the most used value of an attribute. */
4632 static struct attr_value *
4633 find_most_used (struct attr_desc *attr)
4635 struct attr_value *av;
4636 struct attr_value *most_used;
4637 int nuses;
4639 most_used = NULL;
4640 nuses = -1;
4642 for (av = attr->first_value; av; av = av->next)
4643 if (av->num_insns > nuses)
4644 nuses = av->num_insns, most_used = av;
4646 return most_used;
4649 /* Return (attr_value "n") */
4651 static rtx
4652 make_numeric_value (int n)
4654 static rtx int_values[20];
4655 rtx exp;
4656 char *p;
4658 gcc_assert (n >= 0);
4660 if (n < 20 && int_values[n])
4661 return int_values[n];
4663 p = attr_printf (MAX_DIGITS, "%d", n);
4664 exp = attr_rtx (CONST_STRING, p);
4666 if (n < 20)
4667 int_values[n] = exp;
4669 return exp;
4672 static rtx
4673 copy_rtx_unchanging (rtx orig)
4675 if (ATTR_IND_SIMPLIFIED_P (orig) || ATTR_CURR_SIMPLIFIED_P (orig))
4676 return orig;
4678 ATTR_CURR_SIMPLIFIED_P (orig) = 1;
4679 return orig;
4682 /* Determine if an insn has a constant number of delay slots, i.e., the
4683 number of delay slots is not a function of the length of the insn. */
4685 static void
4686 write_const_num_delay_slots (FILE *outf)
4688 struct attr_desc *attr = find_attr (&num_delay_slots_str, 0);
4689 struct attr_value *av;
4691 if (attr)
4693 fprintf (outf, "int\nconst_num_delay_slots (rtx insn)\n");
4694 fprintf (outf, "{\n");
4695 fprintf (outf, " switch (recog_memoized (insn))\n");
4696 fprintf (outf, " {\n");
4698 for (av = attr->first_value; av; av = av->next)
4700 length_used = 0;
4701 walk_attr_value (av->value);
4702 if (length_used)
4703 write_insn_cases (outf, av->first_insn, 4);
4706 fprintf (outf, " default:\n");
4707 fprintf (outf, " return 1;\n");
4708 fprintf (outf, " }\n}\n\n");
4712 /* Synthetic attributes used by insn-automata.c and the scheduler.
4713 These are primarily concerned with (define_insn_reservation)
4714 patterns. */
4716 struct insn_reserv
4718 struct insn_reserv *next;
4720 const char *name;
4721 int default_latency;
4722 rtx condexp;
4724 /* Sequence number of this insn. */
4725 int insn_num;
4727 /* Whether a (define_bypass) construct names this insn in its
4728 output list. */
4729 bool bypassed;
4732 static struct insn_reserv *all_insn_reservs = 0;
4733 static struct insn_reserv **last_insn_reserv_p = &all_insn_reservs;
4734 static size_t n_insn_reservs;
4736 /* Store information from a DEFINE_INSN_RESERVATION for future
4737 attribute generation. */
4738 static void
4739 gen_insn_reserv (rtx def)
4741 struct insn_reserv *decl = oballoc (struct insn_reserv);
4743 decl->name = DEF_ATTR_STRING (XSTR (def, 0));
4744 decl->default_latency = XINT (def, 1);
4745 decl->condexp = check_attr_test (XEXP (def, 2), 0, 0);
4746 decl->insn_num = n_insn_reservs;
4747 decl->bypassed = false;
4748 decl->next = 0;
4750 *last_insn_reserv_p = decl;
4751 last_insn_reserv_p = &decl->next;
4752 n_insn_reservs++;
4755 /* Store information from a DEFINE_BYPASS for future attribute
4756 generation. The only thing we care about is the list of output
4757 insns, which will later be used to tag reservation structures with
4758 a 'bypassed' bit. */
4760 struct bypass_list
4762 struct bypass_list *next;
4763 const char *pattern;
4766 static struct bypass_list *all_bypasses;
4767 static size_t n_bypasses;
4769 static void
4770 gen_bypass_1 (const char *s, size_t len)
4772 struct bypass_list *b;
4774 if (len == 0)
4775 return;
4777 s = attr_string (s, len);
4778 for (b = all_bypasses; b; b = b->next)
4779 if (s == b->pattern)
4780 return; /* already got that one */
4782 b = oballoc (struct bypass_list);
4783 b->pattern = s;
4784 b->next = all_bypasses;
4785 all_bypasses = b;
4786 n_bypasses++;
4789 static void
4790 gen_bypass (rtx def)
4792 const char *p, *base;
4794 for (p = base = XSTR (def, 1); *p; p++)
4795 if (*p == ',')
4797 gen_bypass_1 (base, p - base);
4799 p++;
4800 while (ISSPACE (*p));
4801 base = p;
4803 gen_bypass_1 (base, p - base);
4806 /* Find and mark all of the bypassed insns. */
4807 static void
4808 process_bypasses (void)
4810 struct bypass_list *b;
4811 struct insn_reserv *r;
4813 /* The reservation list is likely to be much longer than the bypass
4814 list. */
4815 for (r = all_insn_reservs; r; r = r->next)
4816 for (b = all_bypasses; b; b = b->next)
4817 if (fnmatch (b->pattern, r->name, 0) == 0)
4818 r->bypassed = true;
4821 /* Check that attribute NAME is used in define_insn_reservation condition
4822 EXP. Return true if it is. */
4823 static bool
4824 check_tune_attr (const char *name, rtx exp)
4826 switch (GET_CODE (exp))
4828 case AND:
4829 if (check_tune_attr (name, XEXP (exp, 0)))
4830 return true;
4831 return check_tune_attr (name, XEXP (exp, 1));
4833 case IOR:
4834 return (check_tune_attr (name, XEXP (exp, 0))
4835 && check_tune_attr (name, XEXP (exp, 1)));
4837 case EQ_ATTR:
4838 return XSTR (exp, 0) == name;
4840 default:
4841 return false;
4845 /* Try to find a const attribute (usually cpu or tune) that is used
4846 in all define_insn_reservation conditions. */
4847 static struct attr_desc *
4848 find_tune_attr (rtx exp)
4850 struct attr_desc *attr;
4852 switch (GET_CODE (exp))
4854 case AND:
4855 case IOR:
4856 attr = find_tune_attr (XEXP (exp, 0));
4857 if (attr)
4858 return attr;
4859 return find_tune_attr (XEXP (exp, 1));
4861 case EQ_ATTR:
4862 if (XSTR (exp, 0) == alternative_name)
4863 return NULL;
4865 attr = find_attr (&XSTR (exp, 0), 0);
4866 gcc_assert (attr);
4868 if (attr->is_const && !attr->is_special)
4870 struct insn_reserv *decl;
4872 for (decl = all_insn_reservs; decl; decl = decl->next)
4873 if (! check_tune_attr (attr->name, decl->condexp))
4874 return NULL;
4875 return attr;
4877 return NULL;
4879 default:
4880 return NULL;
4884 /* Create all of the attributes that describe automaton properties.
4885 Write the DFA and latency function prototypes to the files that
4886 need to have them, and write the init_sched_attrs(). */
4888 static void
4889 make_automaton_attrs (void)
4891 int i;
4892 struct insn_reserv *decl;
4893 rtx code_exp, lats_exp, byps_exp;
4894 struct attr_desc *tune_attr;
4896 if (n_insn_reservs == 0)
4897 return;
4899 tune_attr = find_tune_attr (all_insn_reservs->condexp);
4900 if (tune_attr != NULL)
4902 rtx *condexps = XNEWVEC (rtx, n_insn_reservs * 3);
4903 struct attr_value *val;
4904 bool first = true;
4906 gcc_assert (tune_attr->is_const
4907 && !tune_attr->is_special
4908 && !tune_attr->is_numeric);
4910 /* Write the prototypes for all DFA functions. */
4911 for (val = tune_attr->first_value; val; val = val->next)
4913 if (val == tune_attr->default_val)
4914 continue;
4915 gcc_assert (GET_CODE (val->value) == CONST_STRING);
4916 fprintf (dfa_file,
4917 "extern int internal_dfa_insn_code_%s (rtx);\n",
4918 XSTR (val->value, 0));
4920 fprintf (dfa_file, "\n");
4922 /* Write the prototypes for all latency functions. */
4923 for (val = tune_attr->first_value; val; val = val->next)
4925 if (val == tune_attr->default_val)
4926 continue;
4927 gcc_assert (GET_CODE (val->value) == CONST_STRING);
4928 fprintf (latency_file,
4929 "extern int insn_default_latency_%s (rtx);\n",
4930 XSTR (val->value, 0));
4932 fprintf (latency_file, "\n");
4934 /* Write the prototypes for all automaton functions. */
4935 for (val = tune_attr->first_value; val; val = val->next)
4937 if (val == tune_attr->default_val)
4938 continue;
4939 gcc_assert (GET_CODE (val->value) == CONST_STRING);
4940 fprintf (attr_file,
4941 "extern int internal_dfa_insn_code_%s (rtx);\n"
4942 "extern int insn_default_latency_%s (rtx);\n",
4943 XSTR (val->value, 0), XSTR (val->value, 0));
4945 fprintf (attr_file, "\n");
4946 fprintf (attr_file, "int (*internal_dfa_insn_code) (rtx);\n");
4947 fprintf (attr_file, "int (*insn_default_latency) (rtx);\n");
4948 fprintf (attr_file, "\n");
4949 fprintf (attr_file, "void\n");
4950 fprintf (attr_file, "init_sched_attrs (void)\n");
4951 fprintf (attr_file, "{\n");
4953 for (val = tune_attr->first_value; val; val = val->next)
4955 int j;
4956 char *name;
4957 rtx test = attr_rtx (EQ_ATTR, tune_attr->name, XSTR (val->value, 0));
4959 if (val == tune_attr->default_val)
4960 continue;
4961 for (decl = all_insn_reservs, i = 0;
4962 decl;
4963 decl = decl->next)
4965 rtx ctest = test;
4966 rtx condexp
4967 = simplify_and_tree (decl->condexp, &ctest, -2, 0);
4968 if (condexp == false_rtx)
4969 continue;
4970 if (condexp == true_rtx)
4971 break;
4972 condexps[i] = condexp;
4973 condexps[i + 1] = make_numeric_value (decl->insn_num);
4974 condexps[i + 2] = make_numeric_value (decl->default_latency);
4975 i += 3;
4978 code_exp = rtx_alloc (COND);
4979 lats_exp = rtx_alloc (COND);
4981 j = i / 3 * 2;
4982 XVEC (code_exp, 0) = rtvec_alloc (j);
4983 XVEC (lats_exp, 0) = rtvec_alloc (j);
4985 if (decl)
4987 XEXP (code_exp, 1) = make_numeric_value (decl->insn_num);
4988 XEXP (lats_exp, 1) = make_numeric_value (decl->default_latency);
4990 else
4992 XEXP (code_exp, 1) = make_numeric_value (n_insn_reservs + 1);
4993 XEXP (lats_exp, 1) = make_numeric_value (0);
4996 while (i > 0)
4998 i -= 3;
4999 j -= 2;
5000 XVECEXP (code_exp, 0, j) = condexps[i];
5001 XVECEXP (lats_exp, 0, j) = condexps[i];
5003 XVECEXP (code_exp, 0, j + 1) = condexps[i + 1];
5004 XVECEXP (lats_exp, 0, j + 1) = condexps[i + 2];
5007 name = XNEWVEC (char,
5008 sizeof ("*internal_dfa_insn_code_")
5009 + strlen (XSTR (val->value, 0)));
5010 strcpy (name, "*internal_dfa_insn_code_");
5011 strcat (name, XSTR (val->value, 0));
5012 make_internal_attr (name, code_exp, ATTR_NONE);
5013 strcpy (name, "*insn_default_latency_");
5014 strcat (name, XSTR (val->value, 0));
5015 make_internal_attr (name, lats_exp, ATTR_NONE);
5016 XDELETEVEC (name);
5018 if (first)
5020 fprintf (attr_file, " if (");
5021 first = false;
5023 else
5024 fprintf (attr_file, " else if (");
5025 write_test_expr (attr_file, test, 0, 0);
5026 fprintf (attr_file, ")\n");
5027 fprintf (attr_file, " {\n");
5028 fprintf (attr_file, " internal_dfa_insn_code\n");
5029 fprintf (attr_file, " = internal_dfa_insn_code_%s;\n",
5030 XSTR (val->value, 0));
5031 fprintf (attr_file, " insn_default_latency\n");
5032 fprintf (attr_file, " = insn_default_latency_%s;\n",
5033 XSTR (val->value, 0));
5034 fprintf (attr_file, " }\n");
5037 fprintf (attr_file, " else\n");
5038 fprintf (attr_file, " gcc_unreachable ();\n");
5039 fprintf (attr_file, "}\n");
5040 fprintf (attr_file, "\n");
5042 XDELETEVEC (condexps);
5044 else
5046 code_exp = rtx_alloc (COND);
5047 lats_exp = rtx_alloc (COND);
5049 XVEC (code_exp, 0) = rtvec_alloc (n_insn_reservs * 2);
5050 XVEC (lats_exp, 0) = rtvec_alloc (n_insn_reservs * 2);
5052 XEXP (code_exp, 1) = make_numeric_value (n_insn_reservs + 1);
5053 XEXP (lats_exp, 1) = make_numeric_value (0);
5055 for (decl = all_insn_reservs, i = 0;
5056 decl;
5057 decl = decl->next, i += 2)
5059 XVECEXP (code_exp, 0, i) = decl->condexp;
5060 XVECEXP (lats_exp, 0, i) = decl->condexp;
5062 XVECEXP (code_exp, 0, i+1) = make_numeric_value (decl->insn_num);
5063 XVECEXP (lats_exp, 0, i+1)
5064 = make_numeric_value (decl->default_latency);
5066 make_internal_attr ("*internal_dfa_insn_code", code_exp, ATTR_NONE);
5067 make_internal_attr ("*insn_default_latency", lats_exp, ATTR_NONE);
5070 if (n_bypasses == 0)
5071 byps_exp = make_numeric_value (0);
5072 else
5074 process_bypasses ();
5076 byps_exp = rtx_alloc (COND);
5077 XVEC (byps_exp, 0) = rtvec_alloc (n_bypasses * 2);
5078 XEXP (byps_exp, 1) = make_numeric_value (0);
5079 for (decl = all_insn_reservs, i = 0;
5080 decl;
5081 decl = decl->next)
5082 if (decl->bypassed)
5084 XVECEXP (byps_exp, 0, i) = decl->condexp;
5085 XVECEXP (byps_exp, 0, i+1) = make_numeric_value (1);
5086 i += 2;
5090 make_internal_attr ("*bypass_p", byps_exp, ATTR_NONE);
5093 static void
5094 write_header (FILE *outf)
5096 fprintf (outf, "/* Generated automatically by the program `genattrtab'\n"
5097 " from the machine description file `md'. */\n\n");
5099 fprintf (outf, "#include \"config.h\"\n");
5100 fprintf (outf, "#include \"system.h\"\n");
5101 fprintf (outf, "#include \"coretypes.h\"\n");
5102 fprintf (outf, "#include \"tm.h\"\n");
5103 fprintf (outf, "#include \"tree.h\"\n");
5104 fprintf (outf, "#include \"varasm.h\"\n");
5105 fprintf (outf, "#include \"stor-layout.h\"\n");
5106 fprintf (outf, "#include \"calls.h\"\n");
5107 fprintf (outf, "#include \"rtl.h\"\n");
5108 fprintf (outf, "#include \"insn-attr.h\"\n");
5109 fprintf (outf, "#include \"tm_p.h\"\n");
5110 fprintf (outf, "#include \"insn-config.h\"\n");
5111 fprintf (outf, "#include \"recog.h\"\n");
5112 fprintf (outf, "#include \"regs.h\"\n");
5113 fprintf (outf, "#include \"real.h\"\n");
5114 fprintf (outf, "#include \"output.h\"\n");
5115 fprintf (outf, "#include \"toplev.h\"\n");
5116 fprintf (outf, "#include \"flags.h\"\n");
5117 fprintf (outf, "#include \"function.h\"\n");
5118 fprintf (outf, "\n");
5119 fprintf (outf, "#define operands recog_data.operand\n\n");
5122 static FILE *
5123 open_outfile (const char *file_name)
5125 FILE *outf;
5126 outf = fopen (file_name, "w");
5127 if (! outf)
5128 fatal ("cannot open file %s: %s", file_name, xstrerror (errno));
5129 write_header (outf);
5130 return outf;
5133 static bool
5134 handle_arg (const char *arg)
5136 switch (arg[1])
5138 case 'A':
5139 attr_file_name = &arg[2];
5140 return true;
5141 case 'D':
5142 dfa_file_name = &arg[2];
5143 return true;
5144 case 'L':
5145 latency_file_name = &arg[2];
5146 return true;
5147 default:
5148 return false;
5153 main (int argc, char **argv)
5155 rtx desc;
5156 struct attr_desc *attr;
5157 struct insn_def *id;
5158 rtx tem;
5159 int i;
5161 progname = "genattrtab";
5163 if (!init_rtx_reader_args_cb (argc, argv, handle_arg))
5164 return FATAL_EXIT_CODE;
5166 attr_file = open_outfile (attr_file_name);
5167 dfa_file = open_outfile (dfa_file_name);
5168 latency_file = open_outfile (latency_file_name);
5170 obstack_init (hash_obstack);
5171 obstack_init (temp_obstack);
5173 /* Set up true and false rtx's */
5174 true_rtx = rtx_alloc (CONST_INT);
5175 XWINT (true_rtx, 0) = 1;
5176 false_rtx = rtx_alloc (CONST_INT);
5177 XWINT (false_rtx, 0) = 0;
5178 ATTR_IND_SIMPLIFIED_P (true_rtx) = ATTR_IND_SIMPLIFIED_P (false_rtx) = 1;
5179 ATTR_PERMANENT_P (true_rtx) = ATTR_PERMANENT_P (false_rtx) = 1;
5181 alternative_name = DEF_ATTR_STRING ("alternative");
5182 length_str = DEF_ATTR_STRING ("length");
5183 delay_type_str = DEF_ATTR_STRING ("*delay_type");
5184 delay_1_0_str = DEF_ATTR_STRING ("*delay_1_0");
5185 num_delay_slots_str = DEF_ATTR_STRING ("*num_delay_slots");
5187 /* Read the machine description. */
5189 while (1)
5191 int lineno;
5193 desc = read_md_rtx (&lineno, &insn_code_number);
5194 if (desc == NULL)
5195 break;
5197 switch (GET_CODE (desc))
5199 case DEFINE_INSN:
5200 case DEFINE_PEEPHOLE:
5201 case DEFINE_ASM_ATTRIBUTES:
5202 gen_insn (desc, lineno);
5203 break;
5205 case DEFINE_ATTR:
5206 case DEFINE_ENUM_ATTR:
5207 gen_attr (desc, lineno);
5208 break;
5210 case DEFINE_DELAY:
5211 gen_delay (desc, lineno);
5212 break;
5214 case DEFINE_INSN_RESERVATION:
5215 gen_insn_reserv (desc);
5216 break;
5218 case DEFINE_BYPASS:
5219 gen_bypass (desc);
5220 break;
5222 default:
5223 break;
5225 if (GET_CODE (desc) != DEFINE_ASM_ATTRIBUTES)
5226 insn_index_number++;
5229 if (have_error)
5230 return FATAL_EXIT_CODE;
5232 insn_code_number++;
5234 /* If we didn't have a DEFINE_ASM_ATTRIBUTES, make a null one. */
5235 if (! got_define_asm_attributes)
5237 tem = rtx_alloc (DEFINE_ASM_ATTRIBUTES);
5238 XVEC (tem, 0) = rtvec_alloc (0);
5239 gen_insn (tem, 0);
5242 /* Expand DEFINE_DELAY information into new attribute. */
5243 if (num_delays)
5244 expand_delays ();
5246 /* Make `insn_alternatives'. */
5247 insn_alternatives = oballocvec (int, insn_code_number);
5248 for (id = defs; id; id = id->next)
5249 if (id->insn_code >= 0)
5250 insn_alternatives[id->insn_code] = (1 << id->num_alternatives) - 1;
5252 /* Make `insn_n_alternatives'. */
5253 insn_n_alternatives = oballocvec (int, insn_code_number);
5254 for (id = defs; id; id = id->next)
5255 if (id->insn_code >= 0)
5256 insn_n_alternatives[id->insn_code] = id->num_alternatives;
5258 /* Construct extra attributes for automata. */
5259 make_automaton_attrs ();
5261 /* Prepare to write out attribute subroutines by checking everything stored
5262 away and building the attribute cases. */
5264 check_defs ();
5266 for (i = 0; i < MAX_ATTRS_INDEX; i++)
5267 for (attr = attrs[i]; attr; attr = attr->next)
5268 attr->default_val->value
5269 = check_attr_value (attr->default_val->value, attr);
5271 if (have_error)
5272 return FATAL_EXIT_CODE;
5274 for (i = 0; i < MAX_ATTRS_INDEX; i++)
5275 for (attr = attrs[i]; attr; attr = attr->next)
5276 fill_attr (attr);
5278 /* Construct extra attributes for `length'. */
5279 make_length_attrs ();
5281 /* Perform any possible optimizations to speed up compilation. */
5282 optimize_attrs ();
5284 /* Now write out all the `gen_attr_...' routines. Do these before the
5285 special routines so that they get defined before they are used. */
5287 for (i = 0; i < MAX_ATTRS_INDEX; i++)
5288 for (attr = attrs[i]; attr; attr = attr->next)
5290 FILE *outf;
5292 #define IS_ATTR_GROUP(X) (!strncmp (attr->name, X, strlen (X)))
5293 if (IS_ATTR_GROUP ("*internal_dfa_insn_code"))
5294 outf = dfa_file;
5295 else if (IS_ATTR_GROUP ("*insn_default_latency"))
5296 outf = latency_file;
5297 else
5298 outf = attr_file;
5299 #undef IS_ATTR_GROUP
5301 if (! attr->is_special && ! attr->is_const)
5302 write_attr_get (outf, attr);
5305 /* Write out delay eligibility information, if DEFINE_DELAY present.
5306 (The function to compute the number of delay slots will be written
5307 below.) */
5308 if (num_delays)
5310 write_eligible_delay (attr_file, "delay");
5311 if (have_annul_true)
5312 write_eligible_delay (attr_file, "annul_true");
5313 if (have_annul_false)
5314 write_eligible_delay (attr_file, "annul_false");
5317 /* Write out constant delay slot info. */
5318 write_const_num_delay_slots (attr_file);
5320 write_length_unit_log (attr_file);
5322 if (fclose (attr_file) != 0)
5323 fatal ("cannot close file %s: %s", attr_file_name, xstrerror (errno));
5324 if (fclose (dfa_file) != 0)
5325 fatal ("cannot close file %s: %s", dfa_file_name, xstrerror (errno));
5326 if (fclose (latency_file) != 0)
5327 fatal ("cannot close file %s: %s", latency_file_name, xstrerror (errno));
5329 return SUCCESS_EXIT_CODE;