PR target/49541
[official-gcc.git] / gcc / genattrtab.c
blobe927ca2492c58c5b7e9a1c77ffa10cfd3714bbec
1 /* Generate code from machine description to compute values of attributes.
2 Copyright (C) 1991, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
4 Free Software Foundation, Inc.
5 Contributed by Richard Kenner (kenner@vlsi1.ultra.nyu.edu)
7 This file is part of GCC.
9 GCC is free software; you can redistribute it and/or modify it under
10 the terms of the GNU General Public License as published by the Free
11 Software Foundation; either version 3, or (at your option) any later
12 version.
14 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
15 WARRANTY; without even the implied warranty of MERCHANTABILITY or
16 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 for more details.
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING3. If not see
21 <http://www.gnu.org/licenses/>. */
23 /* This program handles insn attributes and the DEFINE_DELAY and
24 DEFINE_INSN_RESERVATION definitions.
26 It produces a series of functions named `get_attr_...', one for each insn
27 attribute. Each of these is given the rtx for an insn and returns a member
28 of the enum for the attribute.
30 These subroutines have the form of a `switch' on the INSN_CODE (via
31 `recog_memoized'). Each case either returns a constant attribute value
32 or a value that depends on tests on other attributes, the form of
33 operands, or some random C expression (encoded with a SYMBOL_REF
34 expression).
36 If the attribute `alternative', or a random C expression is present,
37 `constrain_operands' is called. If either of these cases of a reference to
38 an operand is found, `extract_insn' is called.
40 The special attribute `length' is also recognized. For this operand,
41 expressions involving the address of an operand or the current insn,
42 (address (pc)), are valid. In this case, an initial pass is made to
43 set all lengths that do not depend on address. Those that do are set to
44 the maximum length. Then each insn that depends on an address is checked
45 and possibly has its length changed. The process repeats until no further
46 changed are made. The resulting lengths are saved for use by
47 `get_attr_length'.
49 A special form of DEFINE_ATTR, where the expression for default value is a
50 CONST expression, indicates an attribute that is constant for a given run
51 of the compiler. The subroutine generated for these attributes has no
52 parameters as it does not depend on any particular insn. Constant
53 attributes are typically used to specify which variety of processor is
54 used.
56 Internal attributes are defined to handle DEFINE_DELAY and
57 DEFINE_INSN_RESERVATION. Special routines are output for these cases.
59 This program works by keeping a list of possible values for each attribute.
60 These include the basic attribute choices, default values for attribute, and
61 all derived quantities.
63 As the description file is read, the definition for each insn is saved in a
64 `struct insn_def'. When the file reading is complete, a `struct insn_ent'
65 is created for each insn and chained to the corresponding attribute value,
66 either that specified, or the default.
68 An optimization phase is then run. This simplifies expressions for each
69 insn. EQ_ATTR tests are resolved, whenever possible, to a test that
70 indicates when the attribute has the specified value for the insn. This
71 avoids recursive calls during compilation.
73 The strategy used when processing DEFINE_DELAY definitions is to create
74 arbitrarily complex expressions and have the optimization simplify them.
76 Once optimization is complete, any required routines and definitions
77 will be written.
79 An optimization that is not yet implemented is to hoist the constant
80 expressions entirely out of the routines and definitions that are written.
81 A way to do this is to iterate over all possible combinations of values
82 for constant attributes and generate a set of functions for that given
83 combination. An initialization function would be written that evaluates
84 the attributes and installs the corresponding set of routines and
85 definitions (each would be accessed through a pointer).
87 We use the flags in an RTX as follows:
88 `unchanging' (ATTR_IND_SIMPLIFIED_P): This rtx is fully simplified
89 independent of the insn code.
90 `in_struct' (ATTR_CURR_SIMPLIFIED_P): This rtx is fully simplified
91 for the insn code currently being processed (see optimize_attrs).
92 `return_val' (ATTR_PERMANENT_P): This rtx is permanent and unique
93 (see attr_rtx). */
95 #define ATTR_IND_SIMPLIFIED_P(RTX) (RTX_FLAG((RTX), unchanging))
96 #define ATTR_CURR_SIMPLIFIED_P(RTX) (RTX_FLAG((RTX), in_struct))
97 #define ATTR_PERMANENT_P(RTX) (RTX_FLAG((RTX), return_val))
99 #if 0
100 #define strcmp_check(S1, S2) ((S1) == (S2) \
101 ? 0 \
102 : (gcc_assert (strcmp ((S1), (S2))), 1))
103 #else
104 #define strcmp_check(S1, S2) ((S1) != (S2))
105 #endif
107 #include "bconfig.h"
108 #include "system.h"
109 #include "coretypes.h"
110 #include "tm.h"
111 #include "rtl.h"
112 #include "obstack.h"
113 #include "errors.h"
114 #include "read-md.h"
115 #include "gensupport.h"
116 #include "vecprim.h"
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 (struct attr_desc *, const char *);
278 static struct attr_value *find_most_used (struct attr_desc *);
279 static void write_attr_set (struct attr_desc *, int, rtx,
280 const char *, const char *, rtx,
281 int, int, unsigned int);
282 static void write_attr_case (struct attr_desc *, struct attr_value *,
283 int, const char *, const char *, int, rtx);
284 static void write_attr_value (struct attr_desc *, rtx);
285 static void write_upcase (const char *);
286 static void write_indent (int);
287 static rtx identity_fn (rtx);
288 static rtx zero_fn (rtx);
289 static rtx one_fn (rtx);
290 static rtx max_fn (rtx);
291 static rtx min_fn (rtx);
293 #define oballoc(T) XOBNEW (hash_obstack, T)
294 #define oballocvec(T, N) XOBNEWVEC (hash_obstack, T, (N))
296 /* Hash table for sharing RTL and strings. */
298 /* Each hash table slot is a bucket containing a chain of these structures.
299 Strings are given negative hash codes; RTL expressions are given positive
300 hash codes. */
302 struct attr_hash
304 struct attr_hash *next; /* Next structure in the bucket. */
305 int hashcode; /* Hash code of this rtx or string. */
306 union
308 char *str; /* The string (negative hash codes) */
309 rtx rtl; /* or the RTL recorded here. */
310 } u;
313 /* Now here is the hash table. When recording an RTL, it is added to
314 the slot whose index is the hash code mod the table size. Note
315 that the hash table is used for several kinds of RTL (see attr_rtx)
316 and for strings. While all these live in the same table, they are
317 completely independent, and the hash code is computed differently
318 for each. */
320 #define RTL_HASH_SIZE 4093
321 static struct attr_hash *attr_hash_table[RTL_HASH_SIZE];
323 /* Here is how primitive or already-shared RTL's hash
324 codes are made. */
325 #define RTL_HASH(RTL) ((intptr_t) (RTL) & 0777777)
327 /* Add an entry to the hash table for RTL with hash code HASHCODE. */
329 static void
330 attr_hash_add_rtx (int hashcode, rtx rtl)
332 struct attr_hash *h;
334 h = XOBNEW (hash_obstack, struct attr_hash);
335 h->hashcode = hashcode;
336 h->u.rtl = rtl;
337 h->next = attr_hash_table[hashcode % RTL_HASH_SIZE];
338 attr_hash_table[hashcode % RTL_HASH_SIZE] = h;
341 /* Add an entry to the hash table for STRING with hash code HASHCODE. */
343 static void
344 attr_hash_add_string (int hashcode, char *str)
346 struct attr_hash *h;
348 h = XOBNEW (hash_obstack, struct attr_hash);
349 h->hashcode = -hashcode;
350 h->u.str = str;
351 h->next = attr_hash_table[hashcode % RTL_HASH_SIZE];
352 attr_hash_table[hashcode % RTL_HASH_SIZE] = h;
355 /* Generate an RTL expression, but avoid duplicates.
356 Set the ATTR_PERMANENT_P flag for these permanent objects.
358 In some cases we cannot uniquify; then we return an ordinary
359 impermanent rtx with ATTR_PERMANENT_P clear.
361 Args are as follows:
363 rtx attr_rtx (code, [element1, ..., elementn]) */
365 static rtx
366 attr_rtx_1 (enum rtx_code code, va_list p)
368 rtx rt_val = NULL_RTX;/* RTX to return to caller... */
369 int hashcode;
370 struct attr_hash *h;
371 struct obstack *old_obstack = rtl_obstack;
373 /* For each of several cases, search the hash table for an existing entry.
374 Use that entry if one is found; otherwise create a new RTL and add it
375 to the table. */
377 if (GET_RTX_CLASS (code) == RTX_UNARY)
379 rtx arg0 = va_arg (p, rtx);
381 /* A permanent object cannot point to impermanent ones. */
382 if (! ATTR_PERMANENT_P (arg0))
384 rt_val = rtx_alloc (code);
385 XEXP (rt_val, 0) = arg0;
386 return rt_val;
389 hashcode = ((HOST_WIDE_INT) code + RTL_HASH (arg0));
390 for (h = attr_hash_table[hashcode % RTL_HASH_SIZE]; h; h = h->next)
391 if (h->hashcode == hashcode
392 && GET_CODE (h->u.rtl) == code
393 && XEXP (h->u.rtl, 0) == arg0)
394 return h->u.rtl;
396 if (h == 0)
398 rtl_obstack = hash_obstack;
399 rt_val = rtx_alloc (code);
400 XEXP (rt_val, 0) = arg0;
403 else if (GET_RTX_CLASS (code) == RTX_BIN_ARITH
404 || GET_RTX_CLASS (code) == RTX_COMM_ARITH
405 || GET_RTX_CLASS (code) == RTX_COMPARE
406 || GET_RTX_CLASS (code) == RTX_COMM_COMPARE)
408 rtx arg0 = va_arg (p, rtx);
409 rtx arg1 = va_arg (p, rtx);
411 /* A permanent object cannot point to impermanent ones. */
412 if (! ATTR_PERMANENT_P (arg0) || ! ATTR_PERMANENT_P (arg1))
414 rt_val = rtx_alloc (code);
415 XEXP (rt_val, 0) = arg0;
416 XEXP (rt_val, 1) = arg1;
417 return rt_val;
420 hashcode = ((HOST_WIDE_INT) code + RTL_HASH (arg0) + RTL_HASH (arg1));
421 for (h = attr_hash_table[hashcode % RTL_HASH_SIZE]; h; h = h->next)
422 if (h->hashcode == hashcode
423 && GET_CODE (h->u.rtl) == code
424 && XEXP (h->u.rtl, 0) == arg0
425 && XEXP (h->u.rtl, 1) == arg1)
426 return h->u.rtl;
428 if (h == 0)
430 rtl_obstack = hash_obstack;
431 rt_val = rtx_alloc (code);
432 XEXP (rt_val, 0) = arg0;
433 XEXP (rt_val, 1) = arg1;
436 else if (GET_RTX_LENGTH (code) == 1
437 && GET_RTX_FORMAT (code)[0] == 's')
439 char *arg0 = va_arg (p, char *);
441 arg0 = DEF_ATTR_STRING (arg0);
443 hashcode = ((HOST_WIDE_INT) code + RTL_HASH (arg0));
444 for (h = attr_hash_table[hashcode % RTL_HASH_SIZE]; h; h = h->next)
445 if (h->hashcode == hashcode
446 && GET_CODE (h->u.rtl) == code
447 && XSTR (h->u.rtl, 0) == arg0)
448 return h->u.rtl;
450 if (h == 0)
452 rtl_obstack = hash_obstack;
453 rt_val = rtx_alloc (code);
454 XSTR (rt_val, 0) = arg0;
457 else if (GET_RTX_LENGTH (code) == 2
458 && GET_RTX_FORMAT (code)[0] == 's'
459 && GET_RTX_FORMAT (code)[1] == 's')
461 char *arg0 = va_arg (p, char *);
462 char *arg1 = va_arg (p, char *);
464 hashcode = ((HOST_WIDE_INT) code + RTL_HASH (arg0) + RTL_HASH (arg1));
465 for (h = attr_hash_table[hashcode % RTL_HASH_SIZE]; h; h = h->next)
466 if (h->hashcode == hashcode
467 && GET_CODE (h->u.rtl) == code
468 && XSTR (h->u.rtl, 0) == arg0
469 && XSTR (h->u.rtl, 1) == arg1)
470 return h->u.rtl;
472 if (h == 0)
474 rtl_obstack = hash_obstack;
475 rt_val = rtx_alloc (code);
476 XSTR (rt_val, 0) = arg0;
477 XSTR (rt_val, 1) = arg1;
480 else if (code == CONST_INT)
482 HOST_WIDE_INT arg0 = va_arg (p, HOST_WIDE_INT);
483 if (arg0 == 0)
484 return false_rtx;
485 else if (arg0 == 1)
486 return true_rtx;
487 else
488 goto nohash;
490 else
492 int i; /* Array indices... */
493 const char *fmt; /* Current rtx's format... */
494 nohash:
495 rt_val = rtx_alloc (code); /* Allocate the storage space. */
497 fmt = GET_RTX_FORMAT (code); /* Find the right format... */
498 for (i = 0; i < GET_RTX_LENGTH (code); i++)
500 switch (*fmt++)
502 case '0': /* Unused field. */
503 break;
505 case 'i': /* An integer? */
506 XINT (rt_val, i) = va_arg (p, int);
507 break;
509 case 'w': /* A wide integer? */
510 XWINT (rt_val, i) = va_arg (p, HOST_WIDE_INT);
511 break;
513 case 's': /* A string? */
514 XSTR (rt_val, i) = va_arg (p, char *);
515 break;
517 case 'e': /* An expression? */
518 case 'u': /* An insn? Same except when printing. */
519 XEXP (rt_val, i) = va_arg (p, rtx);
520 break;
522 case 'E': /* An RTX vector? */
523 XVEC (rt_val, i) = va_arg (p, rtvec);
524 break;
526 default:
527 gcc_unreachable ();
530 return rt_val;
533 rtl_obstack = old_obstack;
534 attr_hash_add_rtx (hashcode, rt_val);
535 ATTR_PERMANENT_P (rt_val) = 1;
536 return rt_val;
539 static rtx
540 attr_rtx (enum rtx_code code, ...)
542 rtx result;
543 va_list p;
545 va_start (p, code);
546 result = attr_rtx_1 (code, p);
547 va_end (p);
548 return result;
551 /* Create a new string printed with the printf line arguments into a space
552 of at most LEN bytes:
554 rtx attr_printf (len, format, [arg1, ..., argn]) */
556 static char *
557 attr_printf (unsigned int len, const char *fmt, ...)
559 char str[256];
560 va_list p;
562 va_start (p, fmt);
564 gcc_assert (len < sizeof str); /* Leave room for \0. */
566 vsprintf (str, fmt, p);
567 va_end (p);
569 return DEF_ATTR_STRING (str);
572 static rtx
573 attr_eq (const char *name, const char *value)
575 return attr_rtx (EQ_ATTR, DEF_ATTR_STRING (name), DEF_ATTR_STRING (value));
578 static const char *
579 attr_numeral (int n)
581 return XSTR (make_numeric_value (n), 0);
584 /* Return a permanent (possibly shared) copy of a string STR (not assumed
585 to be null terminated) with LEN bytes. */
587 static char *
588 attr_string (const char *str, int len)
590 struct attr_hash *h;
591 int hashcode;
592 int i;
593 char *new_str;
595 /* Compute the hash code. */
596 hashcode = (len + 1) * 613 + (unsigned) str[0];
597 for (i = 1; i < len; i += 2)
598 hashcode = ((hashcode * 613) + (unsigned) str[i]);
599 if (hashcode < 0)
600 hashcode = -hashcode;
602 /* Search the table for the string. */
603 for (h = attr_hash_table[hashcode % RTL_HASH_SIZE]; h; h = h->next)
604 if (h->hashcode == -hashcode && h->u.str[0] == str[0]
605 && !strncmp (h->u.str, str, len))
606 return h->u.str; /* <-- return if found. */
608 /* Not found; create a permanent copy and add it to the hash table. */
609 new_str = XOBNEWVAR (hash_obstack, char, len + 1);
610 memcpy (new_str, str, len);
611 new_str[len] = '\0';
612 attr_hash_add_string (hashcode, new_str);
614 return new_str; /* Return the new string. */
617 /* Check two rtx's for equality of contents,
618 taking advantage of the fact that if both are hashed
619 then they can't be equal unless they are the same object. */
621 static int
622 attr_equal_p (rtx x, rtx y)
624 return (x == y || (! (ATTR_PERMANENT_P (x) && ATTR_PERMANENT_P (y))
625 && rtx_equal_p (x, y)));
628 /* Copy an attribute value expression,
629 descending to all depths, but not copying any
630 permanent hashed subexpressions. */
632 static rtx
633 attr_copy_rtx (rtx orig)
635 rtx copy;
636 int i, j;
637 RTX_CODE code;
638 const char *format_ptr;
640 /* No need to copy a permanent object. */
641 if (ATTR_PERMANENT_P (orig))
642 return orig;
644 code = GET_CODE (orig);
646 switch (code)
648 case REG:
649 case CONST_INT:
650 case CONST_DOUBLE:
651 case CONST_VECTOR:
652 case SYMBOL_REF:
653 case CODE_LABEL:
654 case PC:
655 case CC0:
656 return orig;
658 default:
659 break;
662 copy = rtx_alloc (code);
663 PUT_MODE (copy, GET_MODE (orig));
664 ATTR_IND_SIMPLIFIED_P (copy) = ATTR_IND_SIMPLIFIED_P (orig);
665 ATTR_CURR_SIMPLIFIED_P (copy) = ATTR_CURR_SIMPLIFIED_P (orig);
666 ATTR_PERMANENT_P (copy) = ATTR_PERMANENT_P (orig);
668 format_ptr = GET_RTX_FORMAT (GET_CODE (copy));
670 for (i = 0; i < GET_RTX_LENGTH (GET_CODE (copy)); i++)
672 switch (*format_ptr++)
674 case 'e':
675 XEXP (copy, i) = XEXP (orig, i);
676 if (XEXP (orig, i) != NULL)
677 XEXP (copy, i) = attr_copy_rtx (XEXP (orig, i));
678 break;
680 case 'E':
681 case 'V':
682 XVEC (copy, i) = XVEC (orig, i);
683 if (XVEC (orig, i) != NULL)
685 XVEC (copy, i) = rtvec_alloc (XVECLEN (orig, i));
686 for (j = 0; j < XVECLEN (copy, i); j++)
687 XVECEXP (copy, i, j) = attr_copy_rtx (XVECEXP (orig, i, j));
689 break;
691 case 'n':
692 case 'i':
693 XINT (copy, i) = XINT (orig, i);
694 break;
696 case 'w':
697 XWINT (copy, i) = XWINT (orig, i);
698 break;
700 case 's':
701 case 'S':
702 XSTR (copy, i) = XSTR (orig, i);
703 break;
705 default:
706 gcc_unreachable ();
709 return copy;
712 /* Given a test expression for an attribute, ensure it is validly formed.
713 IS_CONST indicates whether the expression is constant for each compiler
714 run (a constant expression may not test any particular insn).
716 Convert (eq_attr "att" "a1,a2") to (ior (eq_attr ... ) (eq_attrq ..))
717 and (eq_attr "att" "!a1") to (not (eq_attr "att" "a1")). Do the latter
718 test first so that (eq_attr "att" "!a1,a2,a3") works as expected.
720 Update the string address in EQ_ATTR expression to be the same used
721 in the attribute (or `alternative_name') to speed up subsequent
722 `find_attr' calls and eliminate most `strcmp' calls.
724 Return the new expression, if any. */
726 static rtx
727 check_attr_test (rtx exp, int is_const, int lineno)
729 struct attr_desc *attr;
730 struct attr_value *av;
731 const char *name_ptr, *p;
732 rtx orexp, newexp;
734 switch (GET_CODE (exp))
736 case EQ_ATTR:
737 /* Handle negation test. */
738 if (XSTR (exp, 1)[0] == '!')
739 return check_attr_test (attr_rtx (NOT,
740 attr_eq (XSTR (exp, 0),
741 &XSTR (exp, 1)[1])),
742 is_const, lineno);
744 else if (n_comma_elts (XSTR (exp, 1)) == 1)
746 attr = find_attr (&XSTR (exp, 0), 0);
747 if (attr == NULL)
749 if (! strcmp (XSTR (exp, 0), "alternative"))
750 return mk_attr_alt (1 << atoi (XSTR (exp, 1)));
751 else
752 fatal ("unknown attribute `%s' in EQ_ATTR", XSTR (exp, 0));
755 if (is_const && ! attr->is_const)
756 fatal ("constant expression uses insn attribute `%s' in EQ_ATTR",
757 XSTR (exp, 0));
759 /* Copy this just to make it permanent,
760 so expressions using it can be permanent too. */
761 exp = attr_eq (XSTR (exp, 0), XSTR (exp, 1));
763 /* It shouldn't be possible to simplify the value given to a
764 constant attribute, so don't expand this until it's time to
765 write the test expression. */
766 if (attr->is_const)
767 ATTR_IND_SIMPLIFIED_P (exp) = 1;
769 if (attr->is_numeric)
771 for (p = XSTR (exp, 1); *p; p++)
772 if (! ISDIGIT (*p))
773 fatal ("attribute `%s' takes only numeric values",
774 XSTR (exp, 0));
776 else
778 for (av = attr->first_value; av; av = av->next)
779 if (GET_CODE (av->value) == CONST_STRING
780 && ! strcmp (XSTR (exp, 1), XSTR (av->value, 0)))
781 break;
783 if (av == NULL)
784 fatal ("unknown value `%s' for `%s' attribute",
785 XSTR (exp, 1), XSTR (exp, 0));
788 else
790 if (! strcmp (XSTR (exp, 0), "alternative"))
792 int set = 0;
794 name_ptr = XSTR (exp, 1);
795 while ((p = next_comma_elt (&name_ptr)) != NULL)
796 set |= 1 << atoi (p);
798 return mk_attr_alt (set);
800 else
802 /* Make an IOR tree of the possible values. */
803 orexp = false_rtx;
804 name_ptr = XSTR (exp, 1);
805 while ((p = next_comma_elt (&name_ptr)) != NULL)
807 newexp = attr_eq (XSTR (exp, 0), p);
808 orexp = insert_right_side (IOR, orexp, newexp, -2, -2);
811 return check_attr_test (orexp, is_const, lineno);
814 break;
816 case ATTR_FLAG:
817 break;
819 case CONST_INT:
820 /* Either TRUE or FALSE. */
821 if (XWINT (exp, 0))
822 return true_rtx;
823 else
824 return false_rtx;
826 case IOR:
827 case AND:
828 XEXP (exp, 0) = check_attr_test (XEXP (exp, 0), is_const, lineno);
829 XEXP (exp, 1) = check_attr_test (XEXP (exp, 1), is_const, lineno);
830 break;
832 case NOT:
833 XEXP (exp, 0) = check_attr_test (XEXP (exp, 0), is_const, lineno);
834 break;
836 case MATCH_OPERAND:
837 if (is_const)
838 fatal ("RTL operator \"%s\" not valid in constant attribute test",
839 GET_RTX_NAME (GET_CODE (exp)));
840 /* These cases can't be simplified. */
841 ATTR_IND_SIMPLIFIED_P (exp) = 1;
842 break;
844 case LE: case LT: case GT: case GE:
845 case LEU: case LTU: case GTU: case GEU:
846 case NE: case EQ:
847 if (GET_CODE (XEXP (exp, 0)) == SYMBOL_REF
848 && GET_CODE (XEXP (exp, 1)) == SYMBOL_REF)
849 exp = attr_rtx (GET_CODE (exp),
850 attr_rtx (SYMBOL_REF, XSTR (XEXP (exp, 0), 0)),
851 attr_rtx (SYMBOL_REF, XSTR (XEXP (exp, 1), 0)));
852 /* These cases can't be simplified. */
853 ATTR_IND_SIMPLIFIED_P (exp) = 1;
854 break;
856 case SYMBOL_REF:
857 if (is_const)
859 /* These cases are valid for constant attributes, but can't be
860 simplified. */
861 exp = attr_rtx (SYMBOL_REF, XSTR (exp, 0));
862 ATTR_IND_SIMPLIFIED_P (exp) = 1;
863 break;
865 default:
866 fatal ("RTL operator \"%s\" not valid in attribute test",
867 GET_RTX_NAME (GET_CODE (exp)));
870 return exp;
873 /* Given an expression, ensure that it is validly formed and that all named
874 attribute values are valid for the given attribute. Issue a fatal error
875 if not. If no attribute is specified, assume a numeric attribute.
877 Return a perhaps modified replacement expression for the value. */
879 static rtx
880 check_attr_value (rtx exp, struct attr_desc *attr)
882 struct attr_value *av;
883 const char *p;
884 int i;
886 switch (GET_CODE (exp))
888 case CONST_INT:
889 if (attr && ! attr->is_numeric)
891 error_with_line (attr->lineno,
892 "CONST_INT not valid for non-numeric attribute %s",
893 attr->name);
894 break;
897 if (INTVAL (exp) < 0)
899 error_with_line (attr->lineno,
900 "negative numeric value specified for attribute %s",
901 attr->name);
902 break;
904 break;
906 case CONST_STRING:
907 if (! strcmp (XSTR (exp, 0), "*"))
908 break;
910 if (attr == 0 || attr->is_numeric)
912 p = XSTR (exp, 0);
913 for (; *p; p++)
914 if (! ISDIGIT (*p))
916 error_with_line (attr ? attr->lineno : 0,
917 "non-numeric value for numeric attribute %s",
918 attr ? attr->name : "internal");
919 break;
921 break;
924 for (av = attr->first_value; av; av = av->next)
925 if (GET_CODE (av->value) == CONST_STRING
926 && ! strcmp (XSTR (av->value, 0), XSTR (exp, 0)))
927 break;
929 if (av == NULL)
930 error_with_line (attr->lineno,
931 "unknown value `%s' for `%s' attribute",
932 XSTR (exp, 0), attr ? attr->name : "internal");
933 break;
935 case IF_THEN_ELSE:
936 XEXP (exp, 0) = check_attr_test (XEXP (exp, 0),
937 attr ? attr->is_const : 0,
938 attr ? attr->lineno : 0);
939 XEXP (exp, 1) = check_attr_value (XEXP (exp, 1), attr);
940 XEXP (exp, 2) = check_attr_value (XEXP (exp, 2), attr);
941 break;
943 case PLUS:
944 case MINUS:
945 case MULT:
946 case DIV:
947 case MOD:
948 if (attr && !attr->is_numeric)
950 error_with_line (attr->lineno,
951 "invalid operation `%s' for non-numeric"
952 " attribute value", GET_RTX_NAME (GET_CODE (exp)));
953 break;
955 /* Fall through. */
957 case IOR:
958 case AND:
959 XEXP (exp, 0) = check_attr_value (XEXP (exp, 0), attr);
960 XEXP (exp, 1) = check_attr_value (XEXP (exp, 1), attr);
961 break;
963 case FFS:
964 case CLZ:
965 case CTZ:
966 case POPCOUNT:
967 case PARITY:
968 case BSWAP:
969 XEXP (exp, 0) = check_attr_value (XEXP (exp, 0), attr);
970 break;
972 case COND:
973 if (XVECLEN (exp, 0) % 2 != 0)
975 error_with_line (attr->lineno,
976 "first operand of COND must have even length");
977 break;
980 for (i = 0; i < XVECLEN (exp, 0); i += 2)
982 XVECEXP (exp, 0, i) = check_attr_test (XVECEXP (exp, 0, i),
983 attr ? attr->is_const : 0,
984 attr ? attr->lineno : 0);
985 XVECEXP (exp, 0, i + 1)
986 = check_attr_value (XVECEXP (exp, 0, i + 1), attr);
989 XEXP (exp, 1) = check_attr_value (XEXP (exp, 1), attr);
990 break;
992 case ATTR:
994 struct attr_desc *attr2 = find_attr (&XSTR (exp, 0), 0);
995 if (attr2 == NULL)
996 error_with_line (attr ? attr->lineno : 0,
997 "unknown attribute `%s' in ATTR",
998 XSTR (exp, 0));
999 else if (attr && attr->is_const && ! attr2->is_const)
1000 error_with_line (attr->lineno,
1001 "non-constant attribute `%s' referenced from `%s'",
1002 XSTR (exp, 0), attr->name);
1003 else if (attr
1004 && attr->is_numeric != attr2->is_numeric)
1005 error_with_line (attr->lineno,
1006 "numeric attribute mismatch calling `%s' from `%s'",
1007 XSTR (exp, 0), attr->name);
1009 break;
1011 case SYMBOL_REF:
1012 /* A constant SYMBOL_REF is valid as a constant attribute test and
1013 is expanded later by make_canonical into a COND. In a non-constant
1014 attribute test, it is left be. */
1015 return attr_rtx (SYMBOL_REF, XSTR (exp, 0));
1017 default:
1018 error_with_line (attr ? attr->lineno : 0,
1019 "invalid operation `%s' for attribute value",
1020 GET_RTX_NAME (GET_CODE (exp)));
1021 break;
1024 return exp;
1027 /* Given an SET_ATTR_ALTERNATIVE expression, convert to the canonical SET.
1028 It becomes a COND with each test being (eq_attr "alternative" "n") */
1030 static rtx
1031 convert_set_attr_alternative (rtx exp, struct insn_def *id)
1033 int num_alt = id->num_alternatives;
1034 rtx condexp;
1035 int i;
1037 if (XVECLEN (exp, 1) != num_alt)
1039 error_with_line (id->lineno,
1040 "bad number of entries in SET_ATTR_ALTERNATIVE");
1041 return NULL_RTX;
1044 /* Make a COND with all tests but the last. Select the last value via the
1045 default. */
1046 condexp = rtx_alloc (COND);
1047 XVEC (condexp, 0) = rtvec_alloc ((num_alt - 1) * 2);
1049 for (i = 0; i < num_alt - 1; i++)
1051 const char *p;
1052 p = attr_numeral (i);
1054 XVECEXP (condexp, 0, 2 * i) = attr_eq (alternative_name, p);
1055 XVECEXP (condexp, 0, 2 * i + 1) = XVECEXP (exp, 1, i);
1058 XEXP (condexp, 1) = XVECEXP (exp, 1, i);
1060 return attr_rtx (SET, attr_rtx (ATTR, XSTR (exp, 0)), condexp);
1063 /* Given a SET_ATTR, convert to the appropriate SET. If a comma-separated
1064 list of values is given, convert to SET_ATTR_ALTERNATIVE first. */
1066 static rtx
1067 convert_set_attr (rtx exp, struct insn_def *id)
1069 rtx newexp;
1070 const char *name_ptr;
1071 char *p;
1072 int n;
1074 /* See how many alternative specified. */
1075 n = n_comma_elts (XSTR (exp, 1));
1076 if (n == 1)
1077 return attr_rtx (SET,
1078 attr_rtx (ATTR, XSTR (exp, 0)),
1079 attr_rtx (CONST_STRING, XSTR (exp, 1)));
1081 newexp = rtx_alloc (SET_ATTR_ALTERNATIVE);
1082 XSTR (newexp, 0) = XSTR (exp, 0);
1083 XVEC (newexp, 1) = rtvec_alloc (n);
1085 /* Process each comma-separated name. */
1086 name_ptr = XSTR (exp, 1);
1087 n = 0;
1088 while ((p = next_comma_elt (&name_ptr)) != NULL)
1089 XVECEXP (newexp, 1, n++) = attr_rtx (CONST_STRING, p);
1091 return convert_set_attr_alternative (newexp, id);
1094 /* Scan all definitions, checking for validity. Also, convert any SET_ATTR
1095 and SET_ATTR_ALTERNATIVE expressions to the corresponding SET
1096 expressions. */
1098 static void
1099 check_defs (void)
1101 struct insn_def *id;
1102 struct attr_desc *attr;
1103 int i;
1104 rtx value;
1106 for (id = defs; id; id = id->next)
1108 if (XVEC (id->def, id->vec_idx) == NULL)
1109 continue;
1111 for (i = 0; i < XVECLEN (id->def, id->vec_idx); i++)
1113 value = XVECEXP (id->def, id->vec_idx, i);
1114 switch (GET_CODE (value))
1116 case SET:
1117 if (GET_CODE (XEXP (value, 0)) != ATTR)
1119 error_with_line (id->lineno, "bad attribute set");
1120 value = NULL_RTX;
1122 break;
1124 case SET_ATTR_ALTERNATIVE:
1125 value = convert_set_attr_alternative (value, id);
1126 break;
1128 case SET_ATTR:
1129 value = convert_set_attr (value, id);
1130 break;
1132 default:
1133 error_with_line (id->lineno, "invalid attribute code %s",
1134 GET_RTX_NAME (GET_CODE (value)));
1135 value = NULL_RTX;
1137 if (value == NULL_RTX)
1138 continue;
1140 if ((attr = find_attr (&XSTR (XEXP (value, 0), 0), 0)) == NULL)
1142 error_with_line (id->lineno, "unknown attribute %s",
1143 XSTR (XEXP (value, 0), 0));
1144 continue;
1147 XVECEXP (id->def, id->vec_idx, i) = value;
1148 XEXP (value, 1) = check_attr_value (XEXP (value, 1), attr);
1153 /* Given a valid expression for an attribute value, remove any IF_THEN_ELSE
1154 expressions by converting them into a COND. This removes cases from this
1155 program. Also, replace an attribute value of "*" with the default attribute
1156 value. */
1158 static rtx
1159 make_canonical (struct attr_desc *attr, rtx exp)
1161 int i;
1162 rtx newexp;
1164 switch (GET_CODE (exp))
1166 case CONST_INT:
1167 exp = make_numeric_value (INTVAL (exp));
1168 break;
1170 case CONST_STRING:
1171 if (! strcmp (XSTR (exp, 0), "*"))
1173 if (attr == 0 || attr->default_val == 0)
1174 fatal ("(attr_value \"*\") used in invalid context");
1175 exp = attr->default_val->value;
1177 else
1178 XSTR (exp, 0) = DEF_ATTR_STRING (XSTR (exp, 0));
1180 break;
1182 case SYMBOL_REF:
1183 if (!attr->is_const || ATTR_IND_SIMPLIFIED_P (exp))
1184 break;
1185 /* The SYMBOL_REF is constant for a given run, so mark it as unchanging.
1186 This makes the COND something that won't be considered an arbitrary
1187 expression by walk_attr_value. */
1188 ATTR_IND_SIMPLIFIED_P (exp) = 1;
1189 exp = check_attr_value (exp, attr);
1190 break;
1192 case IF_THEN_ELSE:
1193 newexp = rtx_alloc (COND);
1194 XVEC (newexp, 0) = rtvec_alloc (2);
1195 XVECEXP (newexp, 0, 0) = XEXP (exp, 0);
1196 XVECEXP (newexp, 0, 1) = XEXP (exp, 1);
1198 XEXP (newexp, 1) = XEXP (exp, 2);
1200 exp = newexp;
1201 /* Fall through to COND case since this is now a COND. */
1203 case COND:
1205 int allsame = 1;
1206 rtx defval;
1208 /* First, check for degenerate COND. */
1209 if (XVECLEN (exp, 0) == 0)
1210 return make_canonical (attr, XEXP (exp, 1));
1211 defval = XEXP (exp, 1) = make_canonical (attr, XEXP (exp, 1));
1213 for (i = 0; i < XVECLEN (exp, 0); i += 2)
1215 XVECEXP (exp, 0, i) = copy_boolean (XVECEXP (exp, 0, i));
1216 XVECEXP (exp, 0, i + 1)
1217 = make_canonical (attr, XVECEXP (exp, 0, i + 1));
1218 if (! rtx_equal_p (XVECEXP (exp, 0, i + 1), defval))
1219 allsame = 0;
1221 if (allsame)
1222 return defval;
1224 break;
1226 default:
1227 break;
1230 return exp;
1233 static rtx
1234 copy_boolean (rtx exp)
1236 if (GET_CODE (exp) == AND || GET_CODE (exp) == IOR)
1237 return attr_rtx (GET_CODE (exp), copy_boolean (XEXP (exp, 0)),
1238 copy_boolean (XEXP (exp, 1)));
1239 if (GET_CODE (exp) == MATCH_OPERAND)
1241 XSTR (exp, 1) = DEF_ATTR_STRING (XSTR (exp, 1));
1242 XSTR (exp, 2) = DEF_ATTR_STRING (XSTR (exp, 2));
1244 else if (GET_CODE (exp) == EQ_ATTR)
1246 XSTR (exp, 0) = DEF_ATTR_STRING (XSTR (exp, 0));
1247 XSTR (exp, 1) = DEF_ATTR_STRING (XSTR (exp, 1));
1250 return exp;
1253 /* Given a value and an attribute description, return a `struct attr_value *'
1254 that represents that value. This is either an existing structure, if the
1255 value has been previously encountered, or a newly-created structure.
1257 `insn_code' is the code of an insn whose attribute has the specified
1258 value (-2 if not processing an insn). We ensure that all insns for
1259 a given value have the same number of alternatives if the value checks
1260 alternatives. */
1262 static struct attr_value *
1263 get_attr_value (rtx value, struct attr_desc *attr, int insn_code)
1265 struct attr_value *av;
1266 int num_alt = 0;
1268 value = make_canonical (attr, value);
1269 if (compares_alternatives_p (value))
1271 if (insn_code < 0 || insn_alternatives == NULL)
1272 fatal ("(eq_attr \"alternatives\" ...) used in non-insn context");
1273 else
1274 num_alt = insn_alternatives[insn_code];
1277 for (av = attr->first_value; av; av = av->next)
1278 if (rtx_equal_p (value, av->value)
1279 && (num_alt == 0 || av->first_insn == NULL
1280 || insn_alternatives[av->first_insn->def->insn_code]))
1281 return av;
1283 av = oballoc (struct attr_value);
1284 av->value = value;
1285 av->next = attr->first_value;
1286 attr->first_value = av;
1287 av->first_insn = NULL;
1288 av->num_insns = 0;
1289 av->has_asm_insn = 0;
1291 return av;
1294 /* After all DEFINE_DELAYs have been read in, create internal attributes
1295 to generate the required routines.
1297 First, we compute the number of delay slots for each insn (as a COND of
1298 each of the test expressions in DEFINE_DELAYs). Then, if more than one
1299 delay type is specified, we compute a similar function giving the
1300 DEFINE_DELAY ordinal for each insn.
1302 Finally, for each [DEFINE_DELAY, slot #] pair, we compute an attribute that
1303 tells whether a given insn can be in that delay slot.
1305 Normal attribute filling and optimization expands these to contain the
1306 information needed to handle delay slots. */
1308 static void
1309 expand_delays (void)
1311 struct delay_desc *delay;
1312 rtx condexp;
1313 rtx newexp;
1314 int i;
1315 char *p;
1317 /* First, generate data for `num_delay_slots' function. */
1319 condexp = rtx_alloc (COND);
1320 XVEC (condexp, 0) = rtvec_alloc (num_delays * 2);
1321 XEXP (condexp, 1) = make_numeric_value (0);
1323 for (i = 0, delay = delays; delay; i += 2, delay = delay->next)
1325 XVECEXP (condexp, 0, i) = XEXP (delay->def, 0);
1326 XVECEXP (condexp, 0, i + 1)
1327 = make_numeric_value (XVECLEN (delay->def, 1) / 3);
1330 make_internal_attr (num_delay_slots_str, condexp, ATTR_NONE);
1332 /* If more than one delay type, do the same for computing the delay type. */
1333 if (num_delays > 1)
1335 condexp = rtx_alloc (COND);
1336 XVEC (condexp, 0) = rtvec_alloc (num_delays * 2);
1337 XEXP (condexp, 1) = make_numeric_value (0);
1339 for (i = 0, delay = delays; delay; i += 2, delay = delay->next)
1341 XVECEXP (condexp, 0, i) = XEXP (delay->def, 0);
1342 XVECEXP (condexp, 0, i + 1) = make_numeric_value (delay->num);
1345 make_internal_attr (delay_type_str, condexp, ATTR_SPECIAL);
1348 /* For each delay possibility and delay slot, compute an eligibility
1349 attribute for non-annulled insns and for each type of annulled (annul
1350 if true and annul if false). */
1351 for (delay = delays; delay; delay = delay->next)
1353 for (i = 0; i < XVECLEN (delay->def, 1); i += 3)
1355 condexp = XVECEXP (delay->def, 1, i);
1356 if (condexp == 0)
1357 condexp = false_rtx;
1358 newexp = attr_rtx (IF_THEN_ELSE, condexp,
1359 make_numeric_value (1), make_numeric_value (0));
1361 p = attr_printf (sizeof "*delay__" + MAX_DIGITS * 2,
1362 "*delay_%d_%d", delay->num, i / 3);
1363 make_internal_attr (p, newexp, ATTR_SPECIAL);
1365 if (have_annul_true)
1367 condexp = XVECEXP (delay->def, 1, i + 1);
1368 if (condexp == 0) condexp = false_rtx;
1369 newexp = attr_rtx (IF_THEN_ELSE, condexp,
1370 make_numeric_value (1),
1371 make_numeric_value (0));
1372 p = attr_printf (sizeof "*annul_true__" + MAX_DIGITS * 2,
1373 "*annul_true_%d_%d", delay->num, i / 3);
1374 make_internal_attr (p, newexp, ATTR_SPECIAL);
1377 if (have_annul_false)
1379 condexp = XVECEXP (delay->def, 1, i + 2);
1380 if (condexp == 0) condexp = false_rtx;
1381 newexp = attr_rtx (IF_THEN_ELSE, condexp,
1382 make_numeric_value (1),
1383 make_numeric_value (0));
1384 p = attr_printf (sizeof "*annul_false__" + MAX_DIGITS * 2,
1385 "*annul_false_%d_%d", delay->num, i / 3);
1386 make_internal_attr (p, newexp, ATTR_SPECIAL);
1392 /* Once all attributes and insns have been read and checked, we construct for
1393 each attribute value a list of all the insns that have that value for
1394 the attribute. */
1396 static void
1397 fill_attr (struct attr_desc *attr)
1399 struct attr_value *av;
1400 struct insn_ent *ie;
1401 struct insn_def *id;
1402 int i;
1403 rtx value;
1405 /* Don't fill constant attributes. The value is independent of
1406 any particular insn. */
1407 if (attr->is_const)
1408 return;
1410 for (id = defs; id; id = id->next)
1412 /* If no value is specified for this insn for this attribute, use the
1413 default. */
1414 value = NULL;
1415 if (XVEC (id->def, id->vec_idx))
1416 for (i = 0; i < XVECLEN (id->def, id->vec_idx); i++)
1417 if (! strcmp_check (XSTR (XEXP (XVECEXP (id->def, id->vec_idx, i), 0), 0),
1418 attr->name))
1419 value = XEXP (XVECEXP (id->def, id->vec_idx, i), 1);
1421 if (value == NULL)
1422 av = attr->default_val;
1423 else
1424 av = get_attr_value (value, attr, id->insn_code);
1426 ie = oballoc (struct insn_ent);
1427 ie->def = id;
1428 insert_insn_ent (av, ie);
1432 /* Given an expression EXP, see if it is a COND or IF_THEN_ELSE that has a
1433 test that checks relative positions of insns (uses MATCH_DUP or PC).
1434 If so, replace it with what is obtained by passing the expression to
1435 ADDRESS_FN. If not but it is a COND or IF_THEN_ELSE, call this routine
1436 recursively on each value (including the default value). Otherwise,
1437 return the value returned by NO_ADDRESS_FN applied to EXP. */
1439 static rtx
1440 substitute_address (rtx exp, rtx (*no_address_fn) (rtx),
1441 rtx (*address_fn) (rtx))
1443 int i;
1444 rtx newexp;
1446 if (GET_CODE (exp) == COND)
1448 /* See if any tests use addresses. */
1449 address_used = 0;
1450 for (i = 0; i < XVECLEN (exp, 0); i += 2)
1451 walk_attr_value (XVECEXP (exp, 0, i));
1453 if (address_used)
1454 return (*address_fn) (exp);
1456 /* Make a new copy of this COND, replacing each element. */
1457 newexp = rtx_alloc (COND);
1458 XVEC (newexp, 0) = rtvec_alloc (XVECLEN (exp, 0));
1459 for (i = 0; i < XVECLEN (exp, 0); i += 2)
1461 XVECEXP (newexp, 0, i) = XVECEXP (exp, 0, i);
1462 XVECEXP (newexp, 0, i + 1)
1463 = substitute_address (XVECEXP (exp, 0, i + 1),
1464 no_address_fn, address_fn);
1467 XEXP (newexp, 1) = substitute_address (XEXP (exp, 1),
1468 no_address_fn, address_fn);
1470 return newexp;
1473 else if (GET_CODE (exp) == IF_THEN_ELSE)
1475 address_used = 0;
1476 walk_attr_value (XEXP (exp, 0));
1477 if (address_used)
1478 return (*address_fn) (exp);
1480 return attr_rtx (IF_THEN_ELSE,
1481 substitute_address (XEXP (exp, 0),
1482 no_address_fn, address_fn),
1483 substitute_address (XEXP (exp, 1),
1484 no_address_fn, address_fn),
1485 substitute_address (XEXP (exp, 2),
1486 no_address_fn, address_fn));
1489 return (*no_address_fn) (exp);
1492 /* Make new attributes from the `length' attribute. The following are made,
1493 each corresponding to a function called from `shorten_branches' or
1494 `get_attr_length':
1496 *insn_default_length This is the length of the insn to be returned
1497 by `get_attr_length' before `shorten_branches'
1498 has been called. In each case where the length
1499 depends on relative addresses, the largest
1500 possible is used. This routine is also used
1501 to compute the initial size of the insn.
1503 *insn_variable_length_p This returns 1 if the insn's length depends
1504 on relative addresses, zero otherwise.
1506 *insn_current_length This is only called when it is known that the
1507 insn has a variable length and returns the
1508 current length, based on relative addresses.
1511 static void
1512 make_length_attrs (void)
1514 static const char *new_names[] =
1516 "*insn_default_length",
1517 "*insn_min_length",
1518 "*insn_variable_length_p",
1519 "*insn_current_length"
1521 static rtx (*const no_address_fn[]) (rtx)
1522 = {identity_fn,identity_fn, zero_fn, zero_fn};
1523 static rtx (*const address_fn[]) (rtx)
1524 = {max_fn, min_fn, one_fn, identity_fn};
1525 size_t i;
1526 struct attr_desc *length_attr, *new_attr;
1527 struct attr_value *av, *new_av;
1528 struct insn_ent *ie, *new_ie;
1530 /* See if length attribute is defined. If so, it must be numeric. Make
1531 it special so we don't output anything for it. */
1532 length_attr = find_attr (&length_str, 0);
1533 if (length_attr == 0)
1534 return;
1536 if (! length_attr->is_numeric)
1537 fatal ("length attribute must be numeric");
1539 length_attr->is_const = 0;
1540 length_attr->is_special = 1;
1542 /* Make each new attribute, in turn. */
1543 for (i = 0; i < ARRAY_SIZE (new_names); i++)
1545 make_internal_attr (new_names[i],
1546 substitute_address (length_attr->default_val->value,
1547 no_address_fn[i], address_fn[i]),
1548 ATTR_NONE);
1549 new_attr = find_attr (&new_names[i], 0);
1550 for (av = length_attr->first_value; av; av = av->next)
1551 for (ie = av->first_insn; ie; ie = ie->next)
1553 new_av = get_attr_value (substitute_address (av->value,
1554 no_address_fn[i],
1555 address_fn[i]),
1556 new_attr, ie->def->insn_code);
1557 new_ie = oballoc (struct insn_ent);
1558 new_ie->def = ie->def;
1559 insert_insn_ent (new_av, new_ie);
1564 /* Utility functions called from above routine. */
1566 static rtx
1567 identity_fn (rtx exp)
1569 return exp;
1572 static rtx
1573 zero_fn (rtx exp ATTRIBUTE_UNUSED)
1575 return make_numeric_value (0);
1578 static rtx
1579 one_fn (rtx exp ATTRIBUTE_UNUSED)
1581 return make_numeric_value (1);
1584 static rtx
1585 max_fn (rtx exp)
1587 int unknown;
1588 return make_numeric_value (max_attr_value (exp, &unknown));
1591 static rtx
1592 min_fn (rtx exp)
1594 int unknown;
1595 return make_numeric_value (min_attr_value (exp, &unknown));
1598 static void
1599 write_length_unit_log (void)
1601 struct attr_desc *length_attr = find_attr (&length_str, 0);
1602 struct attr_value *av;
1603 struct insn_ent *ie;
1604 unsigned int length_unit_log, length_or;
1605 int unknown = 0;
1607 if (length_attr == 0)
1608 return;
1609 length_or = or_attr_value (length_attr->default_val->value, &unknown);
1610 for (av = length_attr->first_value; av; av = av->next)
1611 for (ie = av->first_insn; ie; ie = ie->next)
1612 length_or |= or_attr_value (av->value, &unknown);
1614 if (unknown)
1615 length_unit_log = 0;
1616 else
1618 length_or = ~length_or;
1619 for (length_unit_log = 0; length_or & 1; length_or >>= 1)
1620 length_unit_log++;
1622 printf ("EXPORTED_CONST int length_unit_log = %u;\n", length_unit_log);
1625 /* Take a COND expression and see if any of the conditions in it can be
1626 simplified. If any are known true or known false for the particular insn
1627 code, the COND can be further simplified.
1629 Also call ourselves on any COND operations that are values of this COND.
1631 We do not modify EXP; rather, we make and return a new rtx. */
1633 static rtx
1634 simplify_cond (rtx exp, int insn_code, int insn_index)
1636 int i, j;
1637 /* We store the desired contents here,
1638 then build a new expression if they don't match EXP. */
1639 rtx defval = XEXP (exp, 1);
1640 rtx new_defval = XEXP (exp, 1);
1641 int len = XVECLEN (exp, 0);
1642 rtx *tests = XNEWVEC (rtx, len);
1643 int allsame = 1;
1644 rtx ret;
1646 /* This lets us free all storage allocated below, if appropriate. */
1647 obstack_finish (rtl_obstack);
1649 memcpy (tests, XVEC (exp, 0)->elem, len * sizeof (rtx));
1651 /* See if default value needs simplification. */
1652 if (GET_CODE (defval) == COND)
1653 new_defval = simplify_cond (defval, insn_code, insn_index);
1655 /* Simplify the subexpressions, and see what tests we can get rid of. */
1657 for (i = 0; i < len; i += 2)
1659 rtx newtest, newval;
1661 /* Simplify this test. */
1662 newtest = simplify_test_exp_in_temp (tests[i], insn_code, insn_index);
1663 tests[i] = newtest;
1665 newval = tests[i + 1];
1666 /* See if this value may need simplification. */
1667 if (GET_CODE (newval) == COND)
1668 newval = simplify_cond (newval, insn_code, insn_index);
1670 /* Look for ways to delete or combine this test. */
1671 if (newtest == true_rtx)
1673 /* If test is true, make this value the default
1674 and discard this + any following tests. */
1675 len = i;
1676 defval = tests[i + 1];
1677 new_defval = newval;
1680 else if (newtest == false_rtx)
1682 /* If test is false, discard it and its value. */
1683 for (j = i; j < len - 2; j++)
1684 tests[j] = tests[j + 2];
1685 i -= 2;
1686 len -= 2;
1689 else if (i > 0 && attr_equal_p (newval, tests[i - 1]))
1691 /* If this value and the value for the prev test are the same,
1692 merge the tests. */
1694 tests[i - 2]
1695 = insert_right_side (IOR, tests[i - 2], newtest,
1696 insn_code, insn_index);
1698 /* Delete this test/value. */
1699 for (j = i; j < len - 2; j++)
1700 tests[j] = tests[j + 2];
1701 len -= 2;
1702 i -= 2;
1705 else
1706 tests[i + 1] = newval;
1709 /* If the last test in a COND has the same value
1710 as the default value, that test isn't needed. */
1712 while (len > 0 && attr_equal_p (tests[len - 1], new_defval))
1713 len -= 2;
1715 /* See if we changed anything. */
1716 if (len != XVECLEN (exp, 0) || new_defval != XEXP (exp, 1))
1717 allsame = 0;
1718 else
1719 for (i = 0; i < len; i++)
1720 if (! attr_equal_p (tests[i], XVECEXP (exp, 0, i)))
1722 allsame = 0;
1723 break;
1726 if (len == 0)
1728 if (GET_CODE (defval) == COND)
1729 ret = simplify_cond (defval, insn_code, insn_index);
1730 else
1731 ret = defval;
1733 else if (allsame)
1734 ret = exp;
1735 else
1737 rtx newexp = rtx_alloc (COND);
1739 XVEC (newexp, 0) = rtvec_alloc (len);
1740 memcpy (XVEC (newexp, 0)->elem, tests, len * sizeof (rtx));
1741 XEXP (newexp, 1) = new_defval;
1742 ret = newexp;
1744 free (tests);
1745 return ret;
1748 /* Remove an insn entry from an attribute value. */
1750 static void
1751 remove_insn_ent (struct attr_value *av, struct insn_ent *ie)
1753 struct insn_ent *previe;
1755 if (av->first_insn == ie)
1756 av->first_insn = ie->next;
1757 else
1759 for (previe = av->first_insn; previe->next != ie; previe = previe->next)
1761 previe->next = ie->next;
1764 av->num_insns--;
1765 if (ie->def->insn_code == -1)
1766 av->has_asm_insn = 0;
1768 num_insn_ents--;
1771 /* Insert an insn entry in an attribute value list. */
1773 static void
1774 insert_insn_ent (struct attr_value *av, struct insn_ent *ie)
1776 ie->next = av->first_insn;
1777 av->first_insn = ie;
1778 av->num_insns++;
1779 if (ie->def->insn_code == -1)
1780 av->has_asm_insn = 1;
1782 num_insn_ents++;
1785 /* This is a utility routine to take an expression that is a tree of either
1786 AND or IOR expressions and insert a new term. The new term will be
1787 inserted at the right side of the first node whose code does not match
1788 the root. A new node will be created with the root's code. Its left
1789 side will be the old right side and its right side will be the new
1790 term.
1792 If the `term' is itself a tree, all its leaves will be inserted. */
1794 static rtx
1795 insert_right_side (enum rtx_code code, rtx exp, rtx term, int insn_code, int insn_index)
1797 rtx newexp;
1799 /* Avoid consing in some special cases. */
1800 if (code == AND && term == true_rtx)
1801 return exp;
1802 if (code == AND && term == false_rtx)
1803 return false_rtx;
1804 if (code == AND && exp == true_rtx)
1805 return term;
1806 if (code == AND && exp == false_rtx)
1807 return false_rtx;
1808 if (code == IOR && term == true_rtx)
1809 return true_rtx;
1810 if (code == IOR && term == false_rtx)
1811 return exp;
1812 if (code == IOR && exp == true_rtx)
1813 return true_rtx;
1814 if (code == IOR && exp == false_rtx)
1815 return term;
1816 if (attr_equal_p (exp, term))
1817 return exp;
1819 if (GET_CODE (term) == code)
1821 exp = insert_right_side (code, exp, XEXP (term, 0),
1822 insn_code, insn_index);
1823 exp = insert_right_side (code, exp, XEXP (term, 1),
1824 insn_code, insn_index);
1826 return exp;
1829 if (GET_CODE (exp) == code)
1831 rtx new_rtx = insert_right_side (code, XEXP (exp, 1),
1832 term, insn_code, insn_index);
1833 if (new_rtx != XEXP (exp, 1))
1834 /* Make a copy of this expression and call recursively. */
1835 newexp = attr_rtx (code, XEXP (exp, 0), new_rtx);
1836 else
1837 newexp = exp;
1839 else
1841 /* Insert the new term. */
1842 newexp = attr_rtx (code, exp, term);
1845 return simplify_test_exp_in_temp (newexp, insn_code, insn_index);
1848 /* If we have an expression which AND's a bunch of
1849 (not (eq_attrq "alternative" "n"))
1850 terms, we may have covered all or all but one of the possible alternatives.
1851 If so, we can optimize. Similarly for IOR's of EQ_ATTR.
1853 This routine is passed an expression and either AND or IOR. It returns a
1854 bitmask indicating which alternatives are mentioned within EXP. */
1856 static int
1857 compute_alternative_mask (rtx exp, enum rtx_code code)
1859 const char *string;
1860 if (GET_CODE (exp) == code)
1861 return compute_alternative_mask (XEXP (exp, 0), code)
1862 | compute_alternative_mask (XEXP (exp, 1), code);
1864 else if (code == AND && GET_CODE (exp) == NOT
1865 && GET_CODE (XEXP (exp, 0)) == EQ_ATTR
1866 && XSTR (XEXP (exp, 0), 0) == alternative_name)
1867 string = XSTR (XEXP (exp, 0), 1);
1869 else if (code == IOR && GET_CODE (exp) == EQ_ATTR
1870 && XSTR (exp, 0) == alternative_name)
1871 string = XSTR (exp, 1);
1873 else if (GET_CODE (exp) == EQ_ATTR_ALT)
1875 if (code == AND && XINT (exp, 1))
1876 return XINT (exp, 0);
1878 if (code == IOR && !XINT (exp, 1))
1879 return XINT (exp, 0);
1881 return 0;
1883 else
1884 return 0;
1886 if (string[1] == 0)
1887 return 1 << (string[0] - '0');
1888 return 1 << atoi (string);
1891 /* Given I, a single-bit mask, return RTX to compare the `alternative'
1892 attribute with the value represented by that bit. */
1894 static rtx
1895 make_alternative_compare (int mask)
1897 return mk_attr_alt (mask);
1900 /* If we are processing an (eq_attr "attr" "value") test, we find the value
1901 of "attr" for this insn code. From that value, we can compute a test
1902 showing when the EQ_ATTR will be true. This routine performs that
1903 computation. If a test condition involves an address, we leave the EQ_ATTR
1904 intact because addresses are only valid for the `length' attribute.
1906 EXP is the EQ_ATTR expression and ATTR is the attribute to which
1907 it refers. VALUE is the value of that attribute for the insn
1908 corresponding to INSN_CODE and INSN_INDEX. */
1910 static rtx
1911 evaluate_eq_attr (rtx exp, struct attr_desc *attr, rtx value,
1912 int insn_code, int insn_index)
1914 rtx orexp, andexp;
1915 rtx right;
1916 rtx newexp;
1917 int i;
1919 while (GET_CODE (value) == ATTR)
1921 struct attr_value *av = NULL;
1923 attr = find_attr (&XSTR (value, 0), 0);
1925 if (insn_code_values)
1927 struct attr_value_list *iv;
1928 for (iv = insn_code_values[insn_code]; iv; iv = iv->next)
1929 if (iv->attr == attr)
1931 av = iv->av;
1932 break;
1935 else
1937 struct insn_ent *ie;
1938 for (av = attr->first_value; av; av = av->next)
1939 for (ie = av->first_insn; ie; ie = ie->next)
1940 if (ie->def->insn_code == insn_code)
1941 goto got_av;
1943 if (av)
1945 got_av:
1946 value = av->value;
1950 switch (GET_CODE (value))
1952 case CONST_STRING:
1953 if (! strcmp_check (XSTR (value, 0), XSTR (exp, 1)))
1954 newexp = true_rtx;
1955 else
1956 newexp = false_rtx;
1957 break;
1959 case SYMBOL_REF:
1961 const char *prefix;
1962 char *string, *p;
1964 gcc_assert (GET_CODE (exp) == EQ_ATTR);
1965 prefix = attr->enum_name ? attr->enum_name : attr->name;
1966 string = ACONCAT ((prefix, "_", XSTR (exp, 1), NULL));
1967 for (p = string; *p; p++)
1968 *p = TOUPPER (*p);
1970 newexp = attr_rtx (EQ, value,
1971 attr_rtx (SYMBOL_REF,
1972 DEF_ATTR_STRING (string)));
1973 break;
1976 case COND:
1977 /* We construct an IOR of all the cases for which the
1978 requested attribute value is present. Since we start with
1979 FALSE, if it is not present, FALSE will be returned.
1981 Each case is the AND of the NOT's of the previous conditions with the
1982 current condition; in the default case the current condition is TRUE.
1984 For each possible COND value, call ourselves recursively.
1986 The extra TRUE and FALSE expressions will be eliminated by another
1987 call to the simplification routine. */
1989 orexp = false_rtx;
1990 andexp = true_rtx;
1992 for (i = 0; i < XVECLEN (value, 0); i += 2)
1994 rtx this_cond = simplify_test_exp_in_temp (XVECEXP (value, 0, i),
1995 insn_code, insn_index);
1997 right = insert_right_side (AND, andexp, this_cond,
1998 insn_code, insn_index);
1999 right = insert_right_side (AND, right,
2000 evaluate_eq_attr (exp, attr,
2001 XVECEXP (value, 0,
2002 i + 1),
2003 insn_code, insn_index),
2004 insn_code, insn_index);
2005 orexp = insert_right_side (IOR, orexp, right,
2006 insn_code, insn_index);
2008 /* Add this condition into the AND expression. */
2009 newexp = attr_rtx (NOT, this_cond);
2010 andexp = insert_right_side (AND, andexp, newexp,
2011 insn_code, insn_index);
2014 /* Handle the default case. */
2015 right = insert_right_side (AND, andexp,
2016 evaluate_eq_attr (exp, attr, XEXP (value, 1),
2017 insn_code, insn_index),
2018 insn_code, insn_index);
2019 newexp = insert_right_side (IOR, orexp, right, insn_code, insn_index);
2020 break;
2022 default:
2023 gcc_unreachable ();
2026 /* If uses an address, must return original expression. But set the
2027 ATTR_IND_SIMPLIFIED_P bit so we don't try to simplify it again. */
2029 address_used = 0;
2030 walk_attr_value (newexp);
2032 if (address_used)
2034 if (! ATTR_IND_SIMPLIFIED_P (exp))
2035 return copy_rtx_unchanging (exp);
2036 return exp;
2038 else
2039 return newexp;
2042 /* This routine is called when an AND of a term with a tree of AND's is
2043 encountered. If the term or its complement is present in the tree, it
2044 can be replaced with TRUE or FALSE, respectively.
2046 Note that (eq_attr "att" "v1") and (eq_attr "att" "v2") cannot both
2047 be true and hence are complementary.
2049 There is one special case: If we see
2050 (and (not (eq_attr "att" "v1"))
2051 (eq_attr "att" "v2"))
2052 this can be replaced by (eq_attr "att" "v2"). To do this we need to
2053 replace the term, not anything in the AND tree. So we pass a pointer to
2054 the term. */
2056 static rtx
2057 simplify_and_tree (rtx exp, rtx *pterm, int insn_code, int insn_index)
2059 rtx left, right;
2060 rtx newexp;
2061 rtx temp;
2062 int left_eliminates_term, right_eliminates_term;
2064 if (GET_CODE (exp) == AND)
2066 left = simplify_and_tree (XEXP (exp, 0), pterm, insn_code, insn_index);
2067 right = simplify_and_tree (XEXP (exp, 1), pterm, insn_code, insn_index);
2068 if (left != XEXP (exp, 0) || right != XEXP (exp, 1))
2070 newexp = attr_rtx (AND, left, right);
2072 exp = simplify_test_exp_in_temp (newexp, insn_code, insn_index);
2076 else if (GET_CODE (exp) == IOR)
2078 /* For the IOR case, we do the same as above, except that we can
2079 only eliminate `term' if both sides of the IOR would do so. */
2080 temp = *pterm;
2081 left = simplify_and_tree (XEXP (exp, 0), &temp, insn_code, insn_index);
2082 left_eliminates_term = (temp == true_rtx);
2084 temp = *pterm;
2085 right = simplify_and_tree (XEXP (exp, 1), &temp, insn_code, insn_index);
2086 right_eliminates_term = (temp == true_rtx);
2088 if (left_eliminates_term && right_eliminates_term)
2089 *pterm = true_rtx;
2091 if (left != XEXP (exp, 0) || right != XEXP (exp, 1))
2093 newexp = attr_rtx (IOR, left, right);
2095 exp = simplify_test_exp_in_temp (newexp, insn_code, insn_index);
2099 /* Check for simplifications. Do some extra checking here since this
2100 routine is called so many times. */
2102 if (exp == *pterm)
2103 return true_rtx;
2105 else if (GET_CODE (exp) == NOT && XEXP (exp, 0) == *pterm)
2106 return false_rtx;
2108 else if (GET_CODE (*pterm) == NOT && exp == XEXP (*pterm, 0))
2109 return false_rtx;
2111 else if (GET_CODE (exp) == EQ_ATTR_ALT && GET_CODE (*pterm) == EQ_ATTR_ALT)
2113 if (attr_alt_subset_p (*pterm, exp))
2114 return true_rtx;
2116 if (attr_alt_subset_of_compl_p (*pterm, exp))
2117 return false_rtx;
2119 if (attr_alt_subset_p (exp, *pterm))
2120 *pterm = true_rtx;
2122 return exp;
2125 else if (GET_CODE (exp) == EQ_ATTR && GET_CODE (*pterm) == EQ_ATTR)
2127 if (XSTR (exp, 0) != XSTR (*pterm, 0))
2128 return exp;
2130 if (! strcmp_check (XSTR (exp, 1), XSTR (*pterm, 1)))
2131 return true_rtx;
2132 else
2133 return false_rtx;
2136 else if (GET_CODE (*pterm) == EQ_ATTR && GET_CODE (exp) == NOT
2137 && GET_CODE (XEXP (exp, 0)) == EQ_ATTR)
2139 if (XSTR (*pterm, 0) != XSTR (XEXP (exp, 0), 0))
2140 return exp;
2142 if (! strcmp_check (XSTR (*pterm, 1), XSTR (XEXP (exp, 0), 1)))
2143 return false_rtx;
2144 else
2145 return true_rtx;
2148 else if (GET_CODE (exp) == EQ_ATTR && GET_CODE (*pterm) == NOT
2149 && GET_CODE (XEXP (*pterm, 0)) == EQ_ATTR)
2151 if (XSTR (exp, 0) != XSTR (XEXP (*pterm, 0), 0))
2152 return exp;
2154 if (! strcmp_check (XSTR (exp, 1), XSTR (XEXP (*pterm, 0), 1)))
2155 return false_rtx;
2156 else
2157 *pterm = true_rtx;
2160 else if (GET_CODE (exp) == NOT && GET_CODE (*pterm) == NOT)
2162 if (attr_equal_p (XEXP (exp, 0), XEXP (*pterm, 0)))
2163 return true_rtx;
2166 else if (GET_CODE (exp) == NOT)
2168 if (attr_equal_p (XEXP (exp, 0), *pterm))
2169 return false_rtx;
2172 else if (GET_CODE (*pterm) == NOT)
2174 if (attr_equal_p (XEXP (*pterm, 0), exp))
2175 return false_rtx;
2178 else if (attr_equal_p (exp, *pterm))
2179 return true_rtx;
2181 return exp;
2184 /* Similar to `simplify_and_tree', but for IOR trees. */
2186 static rtx
2187 simplify_or_tree (rtx exp, rtx *pterm, int insn_code, int insn_index)
2189 rtx left, right;
2190 rtx newexp;
2191 rtx temp;
2192 int left_eliminates_term, right_eliminates_term;
2194 if (GET_CODE (exp) == IOR)
2196 left = simplify_or_tree (XEXP (exp, 0), pterm, insn_code, insn_index);
2197 right = simplify_or_tree (XEXP (exp, 1), pterm, insn_code, insn_index);
2198 if (left != XEXP (exp, 0) || right != XEXP (exp, 1))
2200 newexp = attr_rtx (GET_CODE (exp), left, right);
2202 exp = simplify_test_exp_in_temp (newexp, insn_code, insn_index);
2206 else if (GET_CODE (exp) == AND)
2208 /* For the AND case, we do the same as above, except that we can
2209 only eliminate `term' if both sides of the AND would do so. */
2210 temp = *pterm;
2211 left = simplify_or_tree (XEXP (exp, 0), &temp, insn_code, insn_index);
2212 left_eliminates_term = (temp == false_rtx);
2214 temp = *pterm;
2215 right = simplify_or_tree (XEXP (exp, 1), &temp, insn_code, insn_index);
2216 right_eliminates_term = (temp == false_rtx);
2218 if (left_eliminates_term && right_eliminates_term)
2219 *pterm = false_rtx;
2221 if (left != XEXP (exp, 0) || right != XEXP (exp, 1))
2223 newexp = attr_rtx (GET_CODE (exp), left, right);
2225 exp = simplify_test_exp_in_temp (newexp, insn_code, insn_index);
2229 if (attr_equal_p (exp, *pterm))
2230 return false_rtx;
2232 else if (GET_CODE (exp) == NOT && attr_equal_p (XEXP (exp, 0), *pterm))
2233 return true_rtx;
2235 else if (GET_CODE (*pterm) == NOT && attr_equal_p (XEXP (*pterm, 0), exp))
2236 return true_rtx;
2238 else if (GET_CODE (*pterm) == EQ_ATTR && GET_CODE (exp) == NOT
2239 && GET_CODE (XEXP (exp, 0)) == EQ_ATTR
2240 && XSTR (*pterm, 0) == XSTR (XEXP (exp, 0), 0))
2241 *pterm = false_rtx;
2243 else if (GET_CODE (exp) == EQ_ATTR && GET_CODE (*pterm) == NOT
2244 && GET_CODE (XEXP (*pterm, 0)) == EQ_ATTR
2245 && XSTR (exp, 0) == XSTR (XEXP (*pterm, 0), 0))
2246 return false_rtx;
2248 return exp;
2251 /* Compute approximate cost of the expression. Used to decide whether
2252 expression is cheap enough for inline. */
2253 static int
2254 attr_rtx_cost (rtx x)
2256 int cost = 0;
2257 enum rtx_code code;
2258 if (!x)
2259 return 0;
2260 code = GET_CODE (x);
2261 switch (code)
2263 case MATCH_OPERAND:
2264 if (XSTR (x, 1)[0])
2265 return 10;
2266 else
2267 return 0;
2269 case EQ_ATTR_ALT:
2270 return 0;
2272 case EQ_ATTR:
2273 /* Alternatives don't result into function call. */
2274 if (!strcmp_check (XSTR (x, 0), alternative_name))
2275 return 0;
2276 else
2277 return 5;
2278 default:
2280 int i, j;
2281 const char *fmt = GET_RTX_FORMAT (code);
2282 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
2284 switch (fmt[i])
2286 case 'V':
2287 case 'E':
2288 for (j = 0; j < XVECLEN (x, i); j++)
2289 cost += attr_rtx_cost (XVECEXP (x, i, j));
2290 break;
2291 case 'e':
2292 cost += attr_rtx_cost (XEXP (x, i));
2293 break;
2297 break;
2299 return cost;
2302 /* Simplify test expression and use temporary obstack in order to avoid
2303 memory bloat. Use ATTR_IND_SIMPLIFIED to avoid unnecessary simplifications
2304 and avoid unnecessary copying if possible. */
2306 static rtx
2307 simplify_test_exp_in_temp (rtx exp, int insn_code, int insn_index)
2309 rtx x;
2310 struct obstack *old;
2311 if (ATTR_IND_SIMPLIFIED_P (exp))
2312 return exp;
2313 old = rtl_obstack;
2314 rtl_obstack = temp_obstack;
2315 x = simplify_test_exp (exp, insn_code, insn_index);
2316 rtl_obstack = old;
2317 if (x == exp || rtl_obstack == temp_obstack)
2318 return x;
2319 return attr_copy_rtx (x);
2322 /* Returns true if S1 is a subset of S2. */
2324 static bool
2325 attr_alt_subset_p (rtx s1, rtx s2)
2327 switch ((XINT (s1, 1) << 1) | XINT (s2, 1))
2329 case (0 << 1) | 0:
2330 return !(XINT (s1, 0) &~ XINT (s2, 0));
2332 case (0 << 1) | 1:
2333 return !(XINT (s1, 0) & XINT (s2, 0));
2335 case (1 << 1) | 0:
2336 return false;
2338 case (1 << 1) | 1:
2339 return !(XINT (s2, 0) &~ XINT (s1, 0));
2341 default:
2342 gcc_unreachable ();
2346 /* Returns true if S1 is a subset of complement of S2. */
2348 static bool
2349 attr_alt_subset_of_compl_p (rtx s1, rtx s2)
2351 switch ((XINT (s1, 1) << 1) | XINT (s2, 1))
2353 case (0 << 1) | 0:
2354 return !(XINT (s1, 0) & XINT (s2, 0));
2356 case (0 << 1) | 1:
2357 return !(XINT (s1, 0) & ~XINT (s2, 0));
2359 case (1 << 1) | 0:
2360 return !(XINT (s2, 0) &~ XINT (s1, 0));
2362 case (1 << 1) | 1:
2363 return false;
2365 default:
2366 gcc_unreachable ();
2370 /* Return EQ_ATTR_ALT expression representing intersection of S1 and S2. */
2372 static rtx
2373 attr_alt_intersection (rtx s1, rtx s2)
2375 rtx result = rtx_alloc (EQ_ATTR_ALT);
2377 switch ((XINT (s1, 1) << 1) | XINT (s2, 1))
2379 case (0 << 1) | 0:
2380 XINT (result, 0) = XINT (s1, 0) & XINT (s2, 0);
2381 break;
2382 case (0 << 1) | 1:
2383 XINT (result, 0) = XINT (s1, 0) & ~XINT (s2, 0);
2384 break;
2385 case (1 << 1) | 0:
2386 XINT (result, 0) = XINT (s2, 0) & ~XINT (s1, 0);
2387 break;
2388 case (1 << 1) | 1:
2389 XINT (result, 0) = XINT (s1, 0) | XINT (s2, 0);
2390 break;
2391 default:
2392 gcc_unreachable ();
2394 XINT (result, 1) = XINT (s1, 1) & XINT (s2, 1);
2396 return result;
2399 /* Return EQ_ATTR_ALT expression representing union of S1 and S2. */
2401 static rtx
2402 attr_alt_union (rtx s1, rtx s2)
2404 rtx result = rtx_alloc (EQ_ATTR_ALT);
2406 switch ((XINT (s1, 1) << 1) | XINT (s2, 1))
2408 case (0 << 1) | 0:
2409 XINT (result, 0) = XINT (s1, 0) | XINT (s2, 0);
2410 break;
2411 case (0 << 1) | 1:
2412 XINT (result, 0) = XINT (s2, 0) & ~XINT (s1, 0);
2413 break;
2414 case (1 << 1) | 0:
2415 XINT (result, 0) = XINT (s1, 0) & ~XINT (s2, 0);
2416 break;
2417 case (1 << 1) | 1:
2418 XINT (result, 0) = XINT (s1, 0) & XINT (s2, 0);
2419 break;
2420 default:
2421 gcc_unreachable ();
2424 XINT (result, 1) = XINT (s1, 1) | XINT (s2, 1);
2425 return result;
2428 /* Return EQ_ATTR_ALT expression representing complement of S. */
2430 static rtx
2431 attr_alt_complement (rtx s)
2433 rtx result = rtx_alloc (EQ_ATTR_ALT);
2435 XINT (result, 0) = XINT (s, 0);
2436 XINT (result, 1) = 1 - XINT (s, 1);
2438 return result;
2441 /* Return EQ_ATTR_ALT expression representing set containing elements set
2442 in E. */
2444 static rtx
2445 mk_attr_alt (int e)
2447 rtx result = rtx_alloc (EQ_ATTR_ALT);
2449 XINT (result, 0) = e;
2450 XINT (result, 1) = 0;
2452 return result;
2455 /* Given an expression, see if it can be simplified for a particular insn
2456 code based on the values of other attributes being tested. This can
2457 eliminate nested get_attr_... calls.
2459 Note that if an endless recursion is specified in the patterns, the
2460 optimization will loop. However, it will do so in precisely the cases where
2461 an infinite recursion loop could occur during compilation. It's better that
2462 it occurs here! */
2464 static rtx
2465 simplify_test_exp (rtx exp, int insn_code, int insn_index)
2467 rtx left, right;
2468 struct attr_desc *attr;
2469 struct attr_value *av;
2470 struct insn_ent *ie;
2471 struct attr_value_list *iv;
2472 int i;
2473 rtx newexp = exp;
2474 bool left_alt, right_alt;
2476 /* Don't re-simplify something we already simplified. */
2477 if (ATTR_IND_SIMPLIFIED_P (exp) || ATTR_CURR_SIMPLIFIED_P (exp))
2478 return exp;
2480 switch (GET_CODE (exp))
2482 case AND:
2483 left = SIMPLIFY_TEST_EXP (XEXP (exp, 0), insn_code, insn_index);
2484 if (left == false_rtx)
2485 return false_rtx;
2486 right = SIMPLIFY_TEST_EXP (XEXP (exp, 1), insn_code, insn_index);
2487 if (right == false_rtx)
2488 return false_rtx;
2490 if (GET_CODE (left) == EQ_ATTR_ALT
2491 && GET_CODE (right) == EQ_ATTR_ALT)
2493 exp = attr_alt_intersection (left, right);
2494 return simplify_test_exp (exp, insn_code, insn_index);
2497 /* If either side is an IOR and we have (eq_attr "alternative" ..")
2498 present on both sides, apply the distributive law since this will
2499 yield simplifications. */
2500 if ((GET_CODE (left) == IOR || GET_CODE (right) == IOR)
2501 && compute_alternative_mask (left, IOR)
2502 && compute_alternative_mask (right, IOR))
2504 if (GET_CODE (left) == IOR)
2506 rtx tem = left;
2507 left = right;
2508 right = tem;
2511 newexp = attr_rtx (IOR,
2512 attr_rtx (AND, left, XEXP (right, 0)),
2513 attr_rtx (AND, left, XEXP (right, 1)));
2515 return SIMPLIFY_TEST_EXP (newexp, insn_code, insn_index);
2518 /* Try with the term on both sides. */
2519 right = simplify_and_tree (right, &left, insn_code, insn_index);
2520 if (left == XEXP (exp, 0) && right == XEXP (exp, 1))
2521 left = simplify_and_tree (left, &right, insn_code, insn_index);
2523 if (left == false_rtx || right == false_rtx)
2524 return false_rtx;
2525 else if (left == true_rtx)
2527 return right;
2529 else if (right == true_rtx)
2531 return left;
2533 /* See if all or all but one of the insn's alternatives are specified
2534 in this tree. Optimize if so. */
2536 if (GET_CODE (left) == NOT)
2537 left_alt = (GET_CODE (XEXP (left, 0)) == EQ_ATTR
2538 && XSTR (XEXP (left, 0), 0) == alternative_name);
2539 else
2540 left_alt = (GET_CODE (left) == EQ_ATTR_ALT
2541 && XINT (left, 1));
2543 if (GET_CODE (right) == NOT)
2544 right_alt = (GET_CODE (XEXP (right, 0)) == EQ_ATTR
2545 && XSTR (XEXP (right, 0), 0) == alternative_name);
2546 else
2547 right_alt = (GET_CODE (right) == EQ_ATTR_ALT
2548 && XINT (right, 1));
2550 if (insn_code >= 0
2551 && (GET_CODE (left) == AND
2552 || left_alt
2553 || GET_CODE (right) == AND
2554 || right_alt))
2556 i = compute_alternative_mask (exp, AND);
2557 if (i & ~insn_alternatives[insn_code])
2558 fatal ("invalid alternative specified for pattern number %d",
2559 insn_index);
2561 /* If all alternatives are excluded, this is false. */
2562 i ^= insn_alternatives[insn_code];
2563 if (i == 0)
2564 return false_rtx;
2565 else if ((i & (i - 1)) == 0 && insn_alternatives[insn_code] > 1)
2567 /* If just one excluded, AND a comparison with that one to the
2568 front of the tree. The others will be eliminated by
2569 optimization. We do not want to do this if the insn has one
2570 alternative and we have tested none of them! */
2571 left = make_alternative_compare (i);
2572 right = simplify_and_tree (exp, &left, insn_code, insn_index);
2573 newexp = attr_rtx (AND, left, right);
2575 return SIMPLIFY_TEST_EXP (newexp, insn_code, insn_index);
2579 if (left != XEXP (exp, 0) || right != XEXP (exp, 1))
2581 newexp = attr_rtx (AND, left, right);
2582 return SIMPLIFY_TEST_EXP (newexp, insn_code, insn_index);
2584 break;
2586 case IOR:
2587 left = SIMPLIFY_TEST_EXP (XEXP (exp, 0), insn_code, insn_index);
2588 if (left == true_rtx)
2589 return true_rtx;
2590 right = SIMPLIFY_TEST_EXP (XEXP (exp, 1), insn_code, insn_index);
2591 if (right == true_rtx)
2592 return true_rtx;
2594 if (GET_CODE (left) == EQ_ATTR_ALT
2595 && GET_CODE (right) == EQ_ATTR_ALT)
2597 exp = attr_alt_union (left, right);
2598 return simplify_test_exp (exp, insn_code, insn_index);
2601 right = simplify_or_tree (right, &left, insn_code, insn_index);
2602 if (left == XEXP (exp, 0) && right == XEXP (exp, 1))
2603 left = simplify_or_tree (left, &right, insn_code, insn_index);
2605 if (right == true_rtx || left == true_rtx)
2606 return true_rtx;
2607 else if (left == false_rtx)
2609 return right;
2611 else if (right == false_rtx)
2613 return left;
2616 /* Test for simple cases where the distributive law is useful. I.e.,
2617 convert (ior (and (x) (y))
2618 (and (x) (z)))
2619 to (and (x)
2620 (ior (y) (z)))
2623 else if (GET_CODE (left) == AND && GET_CODE (right) == AND
2624 && attr_equal_p (XEXP (left, 0), XEXP (right, 0)))
2626 newexp = attr_rtx (IOR, XEXP (left, 1), XEXP (right, 1));
2628 left = XEXP (left, 0);
2629 right = newexp;
2630 newexp = attr_rtx (AND, left, right);
2631 return SIMPLIFY_TEST_EXP (newexp, insn_code, insn_index);
2634 /* See if all or all but one of the insn's alternatives are specified
2635 in this tree. Optimize if so. */
2637 else if (insn_code >= 0
2638 && (GET_CODE (left) == IOR
2639 || (GET_CODE (left) == EQ_ATTR_ALT
2640 && !XINT (left, 1))
2641 || (GET_CODE (left) == EQ_ATTR
2642 && XSTR (left, 0) == alternative_name)
2643 || GET_CODE (right) == IOR
2644 || (GET_CODE (right) == EQ_ATTR_ALT
2645 && !XINT (right, 1))
2646 || (GET_CODE (right) == EQ_ATTR
2647 && XSTR (right, 0) == alternative_name)))
2649 i = compute_alternative_mask (exp, IOR);
2650 if (i & ~insn_alternatives[insn_code])
2651 fatal ("invalid alternative specified for pattern number %d",
2652 insn_index);
2654 /* If all alternatives are included, this is true. */
2655 i ^= insn_alternatives[insn_code];
2656 if (i == 0)
2657 return true_rtx;
2658 else if ((i & (i - 1)) == 0 && insn_alternatives[insn_code] > 1)
2660 /* If just one excluded, IOR a comparison with that one to the
2661 front of the tree. The others will be eliminated by
2662 optimization. We do not want to do this if the insn has one
2663 alternative and we have tested none of them! */
2664 left = make_alternative_compare (i);
2665 right = simplify_and_tree (exp, &left, insn_code, insn_index);
2666 newexp = attr_rtx (IOR, attr_rtx (NOT, left), right);
2668 return SIMPLIFY_TEST_EXP (newexp, insn_code, insn_index);
2672 if (left != XEXP (exp, 0) || right != XEXP (exp, 1))
2674 newexp = attr_rtx (IOR, left, right);
2675 return SIMPLIFY_TEST_EXP (newexp, insn_code, insn_index);
2677 break;
2679 case NOT:
2680 if (GET_CODE (XEXP (exp, 0)) == NOT)
2682 left = SIMPLIFY_TEST_EXP (XEXP (XEXP (exp, 0), 0),
2683 insn_code, insn_index);
2684 return left;
2687 left = SIMPLIFY_TEST_EXP (XEXP (exp, 0), insn_code, insn_index);
2688 if (GET_CODE (left) == NOT)
2689 return XEXP (left, 0);
2691 if (left == false_rtx)
2692 return true_rtx;
2693 if (left == true_rtx)
2694 return false_rtx;
2696 if (GET_CODE (left) == EQ_ATTR_ALT)
2698 exp = attr_alt_complement (left);
2699 return simplify_test_exp (exp, insn_code, insn_index);
2702 /* Try to apply De`Morgan's laws. */
2703 if (GET_CODE (left) == IOR)
2705 newexp = attr_rtx (AND,
2706 attr_rtx (NOT, XEXP (left, 0)),
2707 attr_rtx (NOT, XEXP (left, 1)));
2709 newexp = SIMPLIFY_TEST_EXP (newexp, insn_code, insn_index);
2711 else if (GET_CODE (left) == AND)
2713 newexp = attr_rtx (IOR,
2714 attr_rtx (NOT, XEXP (left, 0)),
2715 attr_rtx (NOT, XEXP (left, 1)));
2717 newexp = SIMPLIFY_TEST_EXP (newexp, insn_code, insn_index);
2719 else if (left != XEXP (exp, 0))
2721 newexp = attr_rtx (NOT, left);
2723 break;
2725 case EQ_ATTR_ALT:
2726 if (!XINT (exp, 0))
2727 return XINT (exp, 1) ? true_rtx : false_rtx;
2728 break;
2730 case EQ_ATTR:
2731 if (XSTR (exp, 0) == alternative_name)
2733 newexp = mk_attr_alt (1 << atoi (XSTR (exp, 1)));
2734 break;
2737 /* Look at the value for this insn code in the specified attribute.
2738 We normally can replace this comparison with the condition that
2739 would give this insn the values being tested for. */
2740 if (insn_code >= 0
2741 && (attr = find_attr (&XSTR (exp, 0), 0)) != NULL)
2743 rtx x;
2745 av = NULL;
2746 if (insn_code_values)
2748 for (iv = insn_code_values[insn_code]; iv; iv = iv->next)
2749 if (iv->attr == attr)
2751 av = iv->av;
2752 break;
2755 else
2757 for (av = attr->first_value; av; av = av->next)
2758 for (ie = av->first_insn; ie; ie = ie->next)
2759 if (ie->def->insn_code == insn_code)
2760 goto got_av;
2763 if (av)
2765 got_av:
2766 x = evaluate_eq_attr (exp, attr, av->value,
2767 insn_code, insn_index);
2768 x = SIMPLIFY_TEST_EXP (x, insn_code, insn_index);
2769 if (attr_rtx_cost(x) < 20)
2770 return x;
2773 break;
2775 default:
2776 break;
2779 /* We have already simplified this expression. Simplifying it again
2780 won't buy anything unless we weren't given a valid insn code
2781 to process (i.e., we are canonicalizing something.). */
2782 if (insn_code != -2
2783 && ! ATTR_IND_SIMPLIFIED_P (newexp))
2784 return copy_rtx_unchanging (newexp);
2786 return newexp;
2789 /* Optimize the attribute lists by seeing if we can determine conditional
2790 values from the known values of other attributes. This will save subroutine
2791 calls during the compilation. */
2793 static void
2794 optimize_attrs (void)
2796 struct attr_desc *attr;
2797 struct attr_value *av;
2798 struct insn_ent *ie;
2799 rtx newexp;
2800 int i;
2801 struct attr_value_list *ivbuf;
2802 struct attr_value_list *iv;
2804 /* For each insn code, make a list of all the insn_ent's for it,
2805 for all values for all attributes. */
2807 if (num_insn_ents == 0)
2808 return;
2810 /* Make 2 extra elements, for "code" values -2 and -1. */
2811 insn_code_values = XCNEWVEC (struct attr_value_list *, insn_code_number + 2);
2813 /* Offset the table address so we can index by -2 or -1. */
2814 insn_code_values += 2;
2816 iv = ivbuf = XNEWVEC (struct attr_value_list, num_insn_ents);
2818 for (i = 0; i < MAX_ATTRS_INDEX; i++)
2819 for (attr = attrs[i]; attr; attr = attr->next)
2820 for (av = attr->first_value; av; av = av->next)
2821 for (ie = av->first_insn; ie; ie = ie->next)
2823 iv->attr = attr;
2824 iv->av = av;
2825 iv->ie = ie;
2826 iv->next = insn_code_values[ie->def->insn_code];
2827 insn_code_values[ie->def->insn_code] = iv;
2828 iv++;
2831 /* Sanity check on num_insn_ents. */
2832 gcc_assert (iv == ivbuf + num_insn_ents);
2834 /* Process one insn code at a time. */
2835 for (i = -2; i < insn_code_number; i++)
2837 /* Clear the ATTR_CURR_SIMPLIFIED_P flag everywhere relevant.
2838 We use it to mean "already simplified for this insn". */
2839 for (iv = insn_code_values[i]; iv; iv = iv->next)
2840 clear_struct_flag (iv->av->value);
2842 for (iv = insn_code_values[i]; iv; iv = iv->next)
2844 struct obstack *old = rtl_obstack;
2846 attr = iv->attr;
2847 av = iv->av;
2848 ie = iv->ie;
2849 if (GET_CODE (av->value) != COND)
2850 continue;
2852 rtl_obstack = temp_obstack;
2853 newexp = av->value;
2854 while (GET_CODE (newexp) == COND)
2856 rtx newexp2 = simplify_cond (newexp, ie->def->insn_code,
2857 ie->def->insn_index);
2858 if (newexp2 == newexp)
2859 break;
2860 newexp = newexp2;
2863 rtl_obstack = old;
2864 if (newexp != av->value)
2866 newexp = attr_copy_rtx (newexp);
2867 remove_insn_ent (av, ie);
2868 av = get_attr_value (newexp, attr, ie->def->insn_code);
2869 iv->av = av;
2870 insert_insn_ent (av, ie);
2875 free (ivbuf);
2876 free (insn_code_values - 2);
2877 insn_code_values = NULL;
2880 /* Clear the ATTR_CURR_SIMPLIFIED_P flag in EXP and its subexpressions. */
2882 static void
2883 clear_struct_flag (rtx x)
2885 int i;
2886 int j;
2887 enum rtx_code code;
2888 const char *fmt;
2890 ATTR_CURR_SIMPLIFIED_P (x) = 0;
2891 if (ATTR_IND_SIMPLIFIED_P (x))
2892 return;
2894 code = GET_CODE (x);
2896 switch (code)
2898 case REG:
2899 case CONST_INT:
2900 case CONST_DOUBLE:
2901 case CONST_VECTOR:
2902 case SYMBOL_REF:
2903 case CODE_LABEL:
2904 case PC:
2905 case CC0:
2906 case EQ_ATTR:
2907 case ATTR_FLAG:
2908 return;
2910 default:
2911 break;
2914 /* Compare the elements. If any pair of corresponding elements
2915 fail to match, return 0 for the whole things. */
2917 fmt = GET_RTX_FORMAT (code);
2918 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
2920 switch (fmt[i])
2922 case 'V':
2923 case 'E':
2924 for (j = 0; j < XVECLEN (x, i); j++)
2925 clear_struct_flag (XVECEXP (x, i, j));
2926 break;
2928 case 'e':
2929 clear_struct_flag (XEXP (x, i));
2930 break;
2935 /* Add attribute value NAME to the beginning of ATTR's list. */
2937 static void
2938 add_attr_value (struct attr_desc *attr, const char *name)
2940 struct attr_value *av;
2942 av = oballoc (struct attr_value);
2943 av->value = attr_rtx (CONST_STRING, name);
2944 av->next = attr->first_value;
2945 attr->first_value = av;
2946 av->first_insn = NULL;
2947 av->num_insns = 0;
2948 av->has_asm_insn = 0;
2951 /* Create table entries for DEFINE_ATTR or DEFINE_ENUM_ATTR. */
2953 static void
2954 gen_attr (rtx exp, int lineno)
2956 struct enum_type *et;
2957 struct enum_value *ev;
2958 struct attr_desc *attr;
2959 const char *name_ptr;
2960 char *p;
2962 /* Make a new attribute structure. Check for duplicate by looking at
2963 attr->default_val, since it is initialized by this routine. */
2964 attr = find_attr (&XSTR (exp, 0), 1);
2965 if (attr->default_val)
2967 error_with_line (lineno, "duplicate definition for attribute %s",
2968 attr->name);
2969 message_with_line (attr->lineno, "previous definition");
2970 return;
2972 attr->lineno = lineno;
2974 if (GET_CODE (exp) == DEFINE_ENUM_ATTR)
2976 attr->enum_name = XSTR (exp, 1);
2977 et = lookup_enum_type (XSTR (exp, 1));
2978 if (!et || !et->md_p)
2979 error_with_line (lineno, "No define_enum called `%s' defined",
2980 attr->name);
2981 for (ev = et->values; ev; ev = ev->next)
2982 add_attr_value (attr, ev->name);
2984 else if (*XSTR (exp, 1) == '\0')
2985 attr->is_numeric = 1;
2986 else
2988 name_ptr = XSTR (exp, 1);
2989 while ((p = next_comma_elt (&name_ptr)) != NULL)
2990 add_attr_value (attr, p);
2993 if (GET_CODE (XEXP (exp, 2)) == CONST)
2995 attr->is_const = 1;
2996 if (attr->is_numeric)
2997 error_with_line (lineno,
2998 "constant attributes may not take numeric values");
3000 /* Get rid of the CONST node. It is allowed only at top-level. */
3001 XEXP (exp, 2) = XEXP (XEXP (exp, 2), 0);
3004 if (! strcmp_check (attr->name, length_str) && ! attr->is_numeric)
3005 error_with_line (lineno, "`length' attribute must take numeric values");
3007 /* Set up the default value. */
3008 XEXP (exp, 2) = check_attr_value (XEXP (exp, 2), attr);
3009 attr->default_val = get_attr_value (XEXP (exp, 2), attr, -2);
3012 /* Given a pattern for DEFINE_PEEPHOLE or DEFINE_INSN, return the number of
3013 alternatives in the constraints. Assume all MATCH_OPERANDs have the same
3014 number of alternatives as this should be checked elsewhere. */
3016 static int
3017 count_alternatives (rtx exp)
3019 int i, j, n;
3020 const char *fmt;
3022 if (GET_CODE (exp) == MATCH_OPERAND)
3023 return n_comma_elts (XSTR (exp, 2));
3025 for (i = 0, fmt = GET_RTX_FORMAT (GET_CODE (exp));
3026 i < GET_RTX_LENGTH (GET_CODE (exp)); i++)
3027 switch (*fmt++)
3029 case 'e':
3030 case 'u':
3031 n = count_alternatives (XEXP (exp, i));
3032 if (n)
3033 return n;
3034 break;
3036 case 'E':
3037 case 'V':
3038 if (XVEC (exp, i) != NULL)
3039 for (j = 0; j < XVECLEN (exp, i); j++)
3041 n = count_alternatives (XVECEXP (exp, i, j));
3042 if (n)
3043 return n;
3047 return 0;
3050 /* Returns nonzero if the given expression contains an EQ_ATTR with the
3051 `alternative' attribute. */
3053 static int
3054 compares_alternatives_p (rtx exp)
3056 int i, j;
3057 const char *fmt;
3059 if (GET_CODE (exp) == EQ_ATTR && XSTR (exp, 0) == alternative_name)
3060 return 1;
3062 for (i = 0, fmt = GET_RTX_FORMAT (GET_CODE (exp));
3063 i < GET_RTX_LENGTH (GET_CODE (exp)); i++)
3064 switch (*fmt++)
3066 case 'e':
3067 case 'u':
3068 if (compares_alternatives_p (XEXP (exp, i)))
3069 return 1;
3070 break;
3072 case 'E':
3073 for (j = 0; j < XVECLEN (exp, i); j++)
3074 if (compares_alternatives_p (XVECEXP (exp, i, j)))
3075 return 1;
3076 break;
3079 return 0;
3082 /* Process DEFINE_PEEPHOLE, DEFINE_INSN, and DEFINE_ASM_ATTRIBUTES. */
3084 static void
3085 gen_insn (rtx exp, int lineno)
3087 struct insn_def *id;
3089 id = oballoc (struct insn_def);
3090 id->next = defs;
3091 defs = id;
3092 id->def = exp;
3093 id->lineno = lineno;
3095 switch (GET_CODE (exp))
3097 case DEFINE_INSN:
3098 id->insn_code = insn_code_number;
3099 id->insn_index = insn_index_number;
3100 id->num_alternatives = count_alternatives (exp);
3101 if (id->num_alternatives == 0)
3102 id->num_alternatives = 1;
3103 id->vec_idx = 4;
3104 break;
3106 case DEFINE_PEEPHOLE:
3107 id->insn_code = insn_code_number;
3108 id->insn_index = insn_index_number;
3109 id->num_alternatives = count_alternatives (exp);
3110 if (id->num_alternatives == 0)
3111 id->num_alternatives = 1;
3112 id->vec_idx = 3;
3113 break;
3115 case DEFINE_ASM_ATTRIBUTES:
3116 id->insn_code = -1;
3117 id->insn_index = -1;
3118 id->num_alternatives = 1;
3119 id->vec_idx = 0;
3120 got_define_asm_attributes = 1;
3121 break;
3123 default:
3124 gcc_unreachable ();
3128 /* Process a DEFINE_DELAY. Validate the vector length, check if annul
3129 true or annul false is specified, and make a `struct delay_desc'. */
3131 static void
3132 gen_delay (rtx def, int lineno)
3134 struct delay_desc *delay;
3135 int i;
3137 if (XVECLEN (def, 1) % 3 != 0)
3139 error_with_line (lineno,
3140 "number of elements in DEFINE_DELAY must"
3141 " be multiple of three");
3142 return;
3145 for (i = 0; i < XVECLEN (def, 1); i += 3)
3147 if (XVECEXP (def, 1, i + 1))
3148 have_annul_true = 1;
3149 if (XVECEXP (def, 1, i + 2))
3150 have_annul_false = 1;
3153 delay = oballoc (struct delay_desc);
3154 delay->def = def;
3155 delay->num = ++num_delays;
3156 delay->next = delays;
3157 delay->lineno = lineno;
3158 delays = delay;
3161 /* Names of attributes that could be possibly cached. */
3162 static const char *cached_attrs[32];
3163 /* Number of such attributes. */
3164 static int cached_attr_count;
3165 /* Bitmasks of possibly cached attributes. */
3166 static unsigned int attrs_seen_once, attrs_seen_more_than_once;
3167 static unsigned int attrs_to_cache;
3168 static unsigned int attrs_cached_inside, attrs_cached_after;
3170 /* Finds non-const attributes that could be possibly cached.
3171 When create is TRUE, fills in cached_attrs array.
3172 Computes ATTRS_SEEN_ONCE and ATTRS_SEEN_MORE_THAN_ONCE
3173 bitmasks. */
3175 static void
3176 find_attrs_to_cache (rtx exp, bool create)
3178 int i;
3179 const char *name;
3180 struct attr_desc *attr;
3182 if (exp == NULL)
3183 return;
3185 switch (GET_CODE (exp))
3187 case NOT:
3188 if (GET_CODE (XEXP (exp, 0)) == EQ_ATTR)
3189 find_attrs_to_cache (XEXP (exp, 0), create);
3190 return;
3192 case EQ_ATTR:
3193 name = XSTR (exp, 0);
3194 if (name == alternative_name)
3195 return;
3196 for (i = 0; i < cached_attr_count; i++)
3197 if (name == cached_attrs[i])
3199 if ((attrs_seen_once & (1U << i)) != 0)
3200 attrs_seen_more_than_once |= (1U << i);
3201 else
3202 attrs_seen_once |= (1U << i);
3203 return;
3205 if (!create)
3206 return;
3207 attr = find_attr (&name, 0);
3208 gcc_assert (attr);
3209 if (attr->is_const)
3210 return;
3211 if (cached_attr_count == 32)
3212 return;
3213 cached_attrs[cached_attr_count] = XSTR (exp, 0);
3214 attrs_seen_once |= (1U << cached_attr_count);
3215 cached_attr_count++;
3216 return;
3218 case AND:
3219 case IOR:
3220 find_attrs_to_cache (XEXP (exp, 0), create);
3221 find_attrs_to_cache (XEXP (exp, 1), create);
3222 return;
3224 case COND:
3225 for (i = 0; i < XVECLEN (exp, 0); i += 2)
3226 find_attrs_to_cache (XVECEXP (exp, 0, i), create);
3227 return;
3229 default:
3230 return;
3234 /* Given a piece of RTX, print a C expression to test its truth value.
3235 We use AND and IOR both for logical and bit-wise operations, so
3236 interpret them as logical unless they are inside a comparison expression. */
3238 /* Interpret AND/IOR as bit-wise operations instead of logical. */
3239 #define FLG_BITWISE 1
3240 /* Set if cached attribute will be known initialized in else block after
3241 this condition. This is true for LHS of toplevel && and || and
3242 even for RHS of ||, but not for RHS of &&. */
3243 #define FLG_AFTER 2
3244 /* Set if cached attribute will be known initialized in then block after
3245 this condition. This is true for LHS of toplevel && and || and
3246 even for RHS of &&, but not for RHS of ||. */
3247 #define FLG_INSIDE 4
3248 /* Cleared when an operand of &&. */
3249 #define FLG_OUTSIDE_AND 8
3251 static unsigned int
3252 write_test_expr (rtx exp, unsigned int attrs_cached, int flags)
3254 int comparison_operator = 0;
3255 RTX_CODE code;
3256 struct attr_desc *attr;
3258 /* In order not to worry about operator precedence, surround our part of
3259 the expression with parentheses. */
3261 printf ("(");
3262 code = GET_CODE (exp);
3263 switch (code)
3265 /* Binary operators. */
3266 case GEU: case GTU:
3267 case LEU: case LTU:
3268 printf ("(unsigned) ");
3269 /* Fall through. */
3271 case EQ: case NE:
3272 case GE: case GT:
3273 case LE: case LT:
3274 comparison_operator = FLG_BITWISE;
3276 case PLUS: case MINUS: case MULT: case DIV: case MOD:
3277 case AND: case IOR: case XOR:
3278 case ASHIFT: case LSHIFTRT: case ASHIFTRT:
3279 if ((code != AND && code != IOR) || (flags & FLG_BITWISE))
3281 flags &= ~(FLG_AFTER | FLG_INSIDE | FLG_OUTSIDE_AND);
3282 write_test_expr (XEXP (exp, 0), attrs_cached,
3283 flags | comparison_operator);
3285 else
3287 if (code == AND)
3288 flags &= ~FLG_OUTSIDE_AND;
3289 if (GET_CODE (XEXP (exp, 0)) == code
3290 || GET_CODE (XEXP (exp, 0)) == EQ_ATTR
3291 || (GET_CODE (XEXP (exp, 0)) == NOT
3292 && GET_CODE (XEXP (XEXP (exp, 0), 0)) == EQ_ATTR))
3293 attrs_cached
3294 = write_test_expr (XEXP (exp, 0), attrs_cached, flags);
3295 else
3296 write_test_expr (XEXP (exp, 0), attrs_cached, flags);
3298 switch (code)
3300 case EQ:
3301 printf (" == ");
3302 break;
3303 case NE:
3304 printf (" != ");
3305 break;
3306 case GE:
3307 printf (" >= ");
3308 break;
3309 case GT:
3310 printf (" > ");
3311 break;
3312 case GEU:
3313 printf (" >= (unsigned) ");
3314 break;
3315 case GTU:
3316 printf (" > (unsigned) ");
3317 break;
3318 case LE:
3319 printf (" <= ");
3320 break;
3321 case LT:
3322 printf (" < ");
3323 break;
3324 case LEU:
3325 printf (" <= (unsigned) ");
3326 break;
3327 case LTU:
3328 printf (" < (unsigned) ");
3329 break;
3330 case PLUS:
3331 printf (" + ");
3332 break;
3333 case MINUS:
3334 printf (" - ");
3335 break;
3336 case MULT:
3337 printf (" * ");
3338 break;
3339 case DIV:
3340 printf (" / ");
3341 break;
3342 case MOD:
3343 printf (" %% ");
3344 break;
3345 case AND:
3346 if (flags & FLG_BITWISE)
3347 printf (" & ");
3348 else
3349 printf (" && ");
3350 break;
3351 case IOR:
3352 if (flags & FLG_BITWISE)
3353 printf (" | ");
3354 else
3355 printf (" || ");
3356 break;
3357 case XOR:
3358 printf (" ^ ");
3359 break;
3360 case ASHIFT:
3361 printf (" << ");
3362 break;
3363 case LSHIFTRT:
3364 case ASHIFTRT:
3365 printf (" >> ");
3366 break;
3367 default:
3368 gcc_unreachable ();
3371 if (code == AND)
3373 /* For if (something && (cached_x = get_attr_x (insn)) == X)
3374 cached_x is only known to be initialized in then block. */
3375 flags &= ~FLG_AFTER;
3377 else if (code == IOR)
3379 if (flags & FLG_OUTSIDE_AND)
3380 /* For if (something || (cached_x = get_attr_x (insn)) == X)
3381 cached_x is only known to be initialized in else block
3382 and else if conditions. */
3383 flags &= ~FLG_INSIDE;
3384 else
3385 /* For if ((something || (cached_x = get_attr_x (insn)) == X)
3386 && something_else)
3387 cached_x is not know to be initialized anywhere. */
3388 flags &= ~(FLG_AFTER | FLG_INSIDE);
3390 if ((code == AND || code == IOR)
3391 && (GET_CODE (XEXP (exp, 1)) == code
3392 || GET_CODE (XEXP (exp, 1)) == EQ_ATTR
3393 || (GET_CODE (XEXP (exp, 1)) == NOT
3394 && GET_CODE (XEXP (XEXP (exp, 1), 0)) == EQ_ATTR)))
3395 attrs_cached
3396 = write_test_expr (XEXP (exp, 1), attrs_cached, flags);
3397 else
3398 write_test_expr (XEXP (exp, 1), attrs_cached,
3399 flags | comparison_operator);
3400 break;
3402 case NOT:
3403 /* Special-case (not (eq_attrq "alternative" "x")) */
3404 if (! (flags & FLG_BITWISE) && GET_CODE (XEXP (exp, 0)) == EQ_ATTR)
3406 if (XSTR (XEXP (exp, 0), 0) == alternative_name)
3408 printf ("which_alternative != %s", XSTR (XEXP (exp, 0), 1));
3409 break;
3412 printf ("! ");
3413 attrs_cached = write_test_expr (XEXP (exp, 0), attrs_cached, flags);
3414 break;
3417 /* Otherwise, fall through to normal unary operator. */
3419 /* Unary operators. */
3420 case ABS: case NEG:
3421 switch (code)
3423 case NOT:
3424 if (flags & FLG_BITWISE)
3425 printf ("~ ");
3426 else
3427 printf ("! ");
3428 break;
3429 case ABS:
3430 printf ("abs ");
3431 break;
3432 case NEG:
3433 printf ("-");
3434 break;
3435 default:
3436 gcc_unreachable ();
3439 flags &= ~(FLG_AFTER | FLG_INSIDE | FLG_OUTSIDE_AND);
3440 write_test_expr (XEXP (exp, 0), attrs_cached, flags);
3441 break;
3443 case EQ_ATTR_ALT:
3445 int set = XINT (exp, 0), bit = 0;
3447 if (flags & FLG_BITWISE)
3448 fatal ("EQ_ATTR_ALT not valid inside comparison");
3450 if (!set)
3451 fatal ("Empty EQ_ATTR_ALT should be optimized out");
3453 if (!(set & (set - 1)))
3455 if (!(set & 0xffff))
3457 bit += 16;
3458 set >>= 16;
3460 if (!(set & 0xff))
3462 bit += 8;
3463 set >>= 8;
3465 if (!(set & 0xf))
3467 bit += 4;
3468 set >>= 4;
3470 if (!(set & 0x3))
3472 bit += 2;
3473 set >>= 2;
3475 if (!(set & 1))
3476 bit++;
3478 printf ("which_alternative %s= %d",
3479 XINT (exp, 1) ? "!" : "=", bit);
3481 else
3483 printf ("%s((1 << which_alternative) & %#x)",
3484 XINT (exp, 1) ? "!" : "", set);
3487 break;
3489 /* Comparison test of an attribute with a value. Most of these will
3490 have been removed by optimization. Handle "alternative"
3491 specially and give error if EQ_ATTR present inside a comparison. */
3492 case EQ_ATTR:
3493 if (flags & FLG_BITWISE)
3494 fatal ("EQ_ATTR not valid inside comparison");
3496 if (XSTR (exp, 0) == alternative_name)
3498 printf ("which_alternative == %s", XSTR (exp, 1));
3499 break;
3502 attr = find_attr (&XSTR (exp, 0), 0);
3503 gcc_assert (attr);
3505 /* Now is the time to expand the value of a constant attribute. */
3506 if (attr->is_const)
3508 write_test_expr (evaluate_eq_attr (exp, attr,
3509 attr->default_val->value, -2, -2),
3510 attrs_cached, 0);
3512 else
3514 int i;
3515 for (i = 0; i < cached_attr_count; i++)
3516 if (attr->name == cached_attrs[i])
3517 break;
3518 if (i < cached_attr_count && (attrs_cached & (1U << i)) != 0)
3519 printf ("cached_%s", attr->name);
3520 else if (i < cached_attr_count && (attrs_to_cache & (1U << i)) != 0)
3522 printf ("(cached_%s = get_attr_%s (insn))",
3523 attr->name, attr->name);
3524 if (flags & FLG_AFTER)
3525 attrs_cached_after |= (1U << i);
3526 if (flags & FLG_INSIDE)
3527 attrs_cached_inside |= (1U << i);
3528 attrs_cached |= (1U << i);
3530 else
3531 printf ("get_attr_%s (insn)", attr->name);
3532 printf (" == ");
3533 write_attr_valueq (attr, XSTR (exp, 1));
3535 break;
3537 /* Comparison test of flags for define_delays. */
3538 case ATTR_FLAG:
3539 if (flags & FLG_BITWISE)
3540 fatal ("ATTR_FLAG not valid inside comparison");
3541 printf ("(flags & ATTR_FLAG_%s) != 0", XSTR (exp, 0));
3542 break;
3544 /* See if an operand matches a predicate. */
3545 case MATCH_OPERAND:
3546 /* If only a mode is given, just ensure the mode matches the operand.
3547 If neither a mode nor predicate is given, error. */
3548 if (XSTR (exp, 1) == NULL || *XSTR (exp, 1) == '\0')
3550 if (GET_MODE (exp) == VOIDmode)
3551 fatal ("null MATCH_OPERAND specified as test");
3552 else
3553 printf ("GET_MODE (operands[%d]) == %smode",
3554 XINT (exp, 0), GET_MODE_NAME (GET_MODE (exp)));
3556 else
3557 printf ("%s (operands[%d], %smode)",
3558 XSTR (exp, 1), XINT (exp, 0), GET_MODE_NAME (GET_MODE (exp)));
3559 break;
3561 /* Constant integer. */
3562 case CONST_INT:
3563 printf (HOST_WIDE_INT_PRINT_DEC, XWINT (exp, 0));
3564 break;
3566 /* A random C expression. */
3567 case SYMBOL_REF:
3568 print_c_condition (XSTR (exp, 0));
3569 break;
3571 /* The address of the branch target. */
3572 case MATCH_DUP:
3573 printf ("INSN_ADDRESSES_SET_P () ? INSN_ADDRESSES (INSN_UID (GET_CODE (operands[%d]) == LABEL_REF ? XEXP (operands[%d], 0) : operands[%d])) : 0",
3574 XINT (exp, 0), XINT (exp, 0), XINT (exp, 0));
3575 break;
3577 case PC:
3578 /* The address of the current insn. We implement this actually as the
3579 address of the current insn for backward branches, but the last
3580 address of the next insn for forward branches, and both with
3581 adjustments that account for the worst-case possible stretching of
3582 intervening alignments between this insn and its destination. */
3583 printf ("insn_current_reference_address (insn)");
3584 break;
3586 case CONST_STRING:
3587 printf ("%s", XSTR (exp, 0));
3588 break;
3590 case IF_THEN_ELSE:
3591 write_test_expr (XEXP (exp, 0), attrs_cached, 0);
3592 printf (" ? ");
3593 write_test_expr (XEXP (exp, 1), attrs_cached, FLG_BITWISE);
3594 printf (" : ");
3595 write_test_expr (XEXP (exp, 2), attrs_cached, FLG_BITWISE);
3596 break;
3598 default:
3599 fatal ("bad RTX code `%s' in attribute calculation\n",
3600 GET_RTX_NAME (code));
3603 printf (")");
3604 return attrs_cached;
3607 /* Given an attribute value, return the maximum CONST_STRING argument
3608 encountered. Set *UNKNOWNP and return INT_MAX if the value is unknown. */
3610 static int
3611 max_attr_value (rtx exp, int *unknownp)
3613 int current_max;
3614 int i, n;
3616 switch (GET_CODE (exp))
3618 case CONST_STRING:
3619 current_max = atoi (XSTR (exp, 0));
3620 break;
3622 case COND:
3623 current_max = max_attr_value (XEXP (exp, 1), unknownp);
3624 for (i = 0; i < XVECLEN (exp, 0); i += 2)
3626 n = max_attr_value (XVECEXP (exp, 0, i + 1), unknownp);
3627 if (n > current_max)
3628 current_max = n;
3630 break;
3632 case IF_THEN_ELSE:
3633 current_max = max_attr_value (XEXP (exp, 1), unknownp);
3634 n = max_attr_value (XEXP (exp, 2), unknownp);
3635 if (n > current_max)
3636 current_max = n;
3637 break;
3639 default:
3640 *unknownp = 1;
3641 current_max = INT_MAX;
3642 break;
3645 return current_max;
3648 /* Given an attribute value, return the minimum CONST_STRING argument
3649 encountered. Set *UNKNOWNP and return 0 if the value is unknown. */
3651 static int
3652 min_attr_value (rtx exp, int *unknownp)
3654 int current_min;
3655 int i, n;
3657 switch (GET_CODE (exp))
3659 case CONST_STRING:
3660 current_min = atoi (XSTR (exp, 0));
3661 break;
3663 case COND:
3664 current_min = min_attr_value (XEXP (exp, 1), unknownp);
3665 for (i = 0; i < XVECLEN (exp, 0); i += 2)
3667 n = min_attr_value (XVECEXP (exp, 0, i + 1), unknownp);
3668 if (n < current_min)
3669 current_min = n;
3671 break;
3673 case IF_THEN_ELSE:
3674 current_min = min_attr_value (XEXP (exp, 1), unknownp);
3675 n = min_attr_value (XEXP (exp, 2), unknownp);
3676 if (n < current_min)
3677 current_min = n;
3678 break;
3680 default:
3681 *unknownp = 1;
3682 current_min = INT_MAX;
3683 break;
3686 return current_min;
3689 /* Given an attribute value, return the result of ORing together all
3690 CONST_STRING arguments encountered. Set *UNKNOWNP and return -1
3691 if the numeric value is not known. */
3693 static int
3694 or_attr_value (rtx exp, int *unknownp)
3696 int current_or;
3697 int i;
3699 switch (GET_CODE (exp))
3701 case CONST_STRING:
3702 current_or = atoi (XSTR (exp, 0));
3703 break;
3705 case COND:
3706 current_or = or_attr_value (XEXP (exp, 1), unknownp);
3707 for (i = 0; i < XVECLEN (exp, 0); i += 2)
3708 current_or |= or_attr_value (XVECEXP (exp, 0, i + 1), unknownp);
3709 break;
3711 case IF_THEN_ELSE:
3712 current_or = or_attr_value (XEXP (exp, 1), unknownp);
3713 current_or |= or_attr_value (XEXP (exp, 2), unknownp);
3714 break;
3716 default:
3717 *unknownp = 1;
3718 current_or = -1;
3719 break;
3722 return current_or;
3725 /* Scan an attribute value, possibly a conditional, and record what actions
3726 will be required to do any conditional tests in it.
3728 Specifically, set
3729 `must_extract' if we need to extract the insn operands
3730 `must_constrain' if we must compute `which_alternative'
3731 `address_used' if an address expression was used
3732 `length_used' if an (eq_attr "length" ...) was used
3735 static void
3736 walk_attr_value (rtx exp)
3738 int i, j;
3739 const char *fmt;
3740 RTX_CODE code;
3742 if (exp == NULL)
3743 return;
3745 code = GET_CODE (exp);
3746 switch (code)
3748 case SYMBOL_REF:
3749 if (! ATTR_IND_SIMPLIFIED_P (exp))
3750 /* Since this is an arbitrary expression, it can look at anything.
3751 However, constant expressions do not depend on any particular
3752 insn. */
3753 must_extract = must_constrain = 1;
3754 return;
3756 case MATCH_OPERAND:
3757 must_extract = 1;
3758 return;
3760 case EQ_ATTR_ALT:
3761 must_extract = must_constrain = 1;
3762 break;
3764 case EQ_ATTR:
3765 if (XSTR (exp, 0) == alternative_name)
3766 must_extract = must_constrain = 1;
3767 else if (strcmp_check (XSTR (exp, 0), length_str) == 0)
3768 length_used = 1;
3769 return;
3771 case MATCH_DUP:
3772 must_extract = 1;
3773 address_used = 1;
3774 return;
3776 case PC:
3777 address_used = 1;
3778 return;
3780 case ATTR_FLAG:
3781 return;
3783 default:
3784 break;
3787 for (i = 0, fmt = GET_RTX_FORMAT (code); i < GET_RTX_LENGTH (code); i++)
3788 switch (*fmt++)
3790 case 'e':
3791 case 'u':
3792 walk_attr_value (XEXP (exp, i));
3793 break;
3795 case 'E':
3796 if (XVEC (exp, i) != NULL)
3797 for (j = 0; j < XVECLEN (exp, i); j++)
3798 walk_attr_value (XVECEXP (exp, i, j));
3799 break;
3803 /* Write out a function to obtain the attribute for a given INSN. */
3805 static void
3806 write_attr_get (struct attr_desc *attr)
3808 struct attr_value *av, *common_av;
3809 int i, j;
3811 /* Find the most used attribute value. Handle that as the `default' of the
3812 switch we will generate. */
3813 common_av = find_most_used (attr);
3815 /* Write out start of function, then all values with explicit `case' lines,
3816 then a `default', then the value with the most uses. */
3817 if (attr->enum_name)
3818 printf ("enum %s\n", attr->enum_name);
3819 else if (!attr->is_numeric)
3820 printf ("enum attr_%s\n", attr->name);
3821 else
3822 printf ("int\n");
3824 /* If the attribute name starts with a star, the remainder is the name of
3825 the subroutine to use, instead of `get_attr_...'. */
3826 if (attr->name[0] == '*')
3827 printf ("%s (rtx insn ATTRIBUTE_UNUSED)\n", &attr->name[1]);
3828 else if (attr->is_const == 0)
3829 printf ("get_attr_%s (rtx insn ATTRIBUTE_UNUSED)\n", attr->name);
3830 else
3832 printf ("get_attr_%s (void)\n", attr->name);
3833 printf ("{\n");
3835 for (av = attr->first_value; av; av = av->next)
3836 if (av->num_insns == 1)
3837 write_attr_set (attr, 2, av->value, "return", ";",
3838 true_rtx, av->first_insn->def->insn_code,
3839 av->first_insn->def->insn_index, 0);
3840 else if (av->num_insns != 0)
3841 write_attr_set (attr, 2, av->value, "return", ";",
3842 true_rtx, -2, 0, 0);
3844 printf ("}\n\n");
3845 return;
3848 printf ("{\n");
3850 /* Find attributes that are worth caching in the conditions. */
3851 cached_attr_count = 0;
3852 attrs_seen_more_than_once = 0;
3853 for (av = attr->first_value; av; av = av->next)
3855 attrs_seen_once = 0;
3856 find_attrs_to_cache (av->value, true);
3858 /* Remove those that aren't worth caching from the array. */
3859 for (i = 0, j = 0; i < cached_attr_count; i++)
3860 if ((attrs_seen_more_than_once & (1U << i)) != 0)
3862 const char *name = cached_attrs[i];
3863 struct attr_desc *cached_attr;
3864 if (i != j)
3865 cached_attrs[j] = name;
3866 cached_attr = find_attr (&name, 0);
3867 gcc_assert (cached_attr && cached_attr->is_const == 0);
3868 if (cached_attr->enum_name)
3869 printf (" enum %s", cached_attr->enum_name);
3870 else if (!cached_attr->is_numeric)
3871 printf (" enum attr_%s", cached_attr->name);
3872 else
3873 printf (" int");
3874 printf (" cached_%s ATTRIBUTE_UNUSED;\n", name);
3875 j++;
3877 cached_attr_count = j;
3878 if (cached_attr_count)
3879 printf ("\n");
3881 printf (" switch (recog_memoized (insn))\n");
3882 printf (" {\n");
3884 for (av = attr->first_value; av; av = av->next)
3885 if (av != common_av)
3886 write_attr_case (attr, av, 1, "return", ";", 4, true_rtx);
3888 write_attr_case (attr, common_av, 0, "return", ";", 4, true_rtx);
3889 printf (" }\n}\n\n");
3890 cached_attr_count = 0;
3893 /* Given an AND tree of known true terms (because we are inside an `if' with
3894 that as the condition or are in an `else' clause) and an expression,
3895 replace any known true terms with TRUE. Use `simplify_and_tree' to do
3896 the bulk of the work. */
3898 static rtx
3899 eliminate_known_true (rtx known_true, rtx exp, int insn_code, int insn_index)
3901 rtx term;
3903 known_true = SIMPLIFY_TEST_EXP (known_true, insn_code, insn_index);
3905 if (GET_CODE (known_true) == AND)
3907 exp = eliminate_known_true (XEXP (known_true, 0), exp,
3908 insn_code, insn_index);
3909 exp = eliminate_known_true (XEXP (known_true, 1), exp,
3910 insn_code, insn_index);
3912 else
3914 term = known_true;
3915 exp = simplify_and_tree (exp, &term, insn_code, insn_index);
3918 return exp;
3921 /* Write out a series of tests and assignment statements to perform tests and
3922 sets of an attribute value. We are passed an indentation amount and prefix
3923 and suffix strings to write around each attribute value (e.g., "return"
3924 and ";"). */
3926 static void
3927 write_attr_set (struct attr_desc *attr, int indent, rtx value,
3928 const char *prefix, const char *suffix, rtx known_true,
3929 int insn_code, int insn_index, unsigned int attrs_cached)
3931 if (GET_CODE (value) == COND)
3933 /* Assume the default value will be the default of the COND unless we
3934 find an always true expression. */
3935 rtx default_val = XEXP (value, 1);
3936 rtx our_known_true = known_true;
3937 rtx newexp;
3938 int first_if = 1;
3939 int i;
3941 if (cached_attr_count)
3943 attrs_seen_once = 0;
3944 attrs_seen_more_than_once = 0;
3945 for (i = 0; i < XVECLEN (value, 0); i += 2)
3946 find_attrs_to_cache (XVECEXP (value, 0, i), false);
3947 attrs_to_cache |= attrs_seen_more_than_once;
3950 for (i = 0; i < XVECLEN (value, 0); i += 2)
3952 rtx testexp;
3953 rtx inner_true;
3955 testexp = eliminate_known_true (our_known_true,
3956 XVECEXP (value, 0, i),
3957 insn_code, insn_index);
3958 newexp = attr_rtx (NOT, testexp);
3959 newexp = insert_right_side (AND, our_known_true, newexp,
3960 insn_code, insn_index);
3962 /* If the test expression is always true or if the next `known_true'
3963 expression is always false, this is the last case, so break
3964 out and let this value be the `else' case. */
3965 if (testexp == true_rtx || newexp == false_rtx)
3967 default_val = XVECEXP (value, 0, i + 1);
3968 break;
3971 /* Compute the expression to pass to our recursive call as being
3972 known true. */
3973 inner_true = insert_right_side (AND, our_known_true,
3974 testexp, insn_code, insn_index);
3976 /* If this is always false, skip it. */
3977 if (inner_true == false_rtx)
3978 continue;
3980 attrs_cached_inside = attrs_cached;
3981 attrs_cached_after = attrs_cached;
3982 write_indent (indent);
3983 printf ("%sif ", first_if ? "" : "else ");
3984 first_if = 0;
3985 write_test_expr (testexp, attrs_cached,
3986 (FLG_AFTER | FLG_INSIDE | FLG_OUTSIDE_AND));
3987 attrs_cached = attrs_cached_after;
3988 printf ("\n");
3989 write_indent (indent + 2);
3990 printf ("{\n");
3992 write_attr_set (attr, indent + 4,
3993 XVECEXP (value, 0, i + 1), prefix, suffix,
3994 inner_true, insn_code, insn_index,
3995 attrs_cached_inside);
3996 write_indent (indent + 2);
3997 printf ("}\n");
3998 our_known_true = newexp;
4001 if (! first_if)
4003 write_indent (indent);
4004 printf ("else\n");
4005 write_indent (indent + 2);
4006 printf ("{\n");
4009 write_attr_set (attr, first_if ? indent : indent + 4, default_val,
4010 prefix, suffix, our_known_true, insn_code, insn_index,
4011 attrs_cached);
4013 if (! first_if)
4015 write_indent (indent + 2);
4016 printf ("}\n");
4019 else
4021 write_indent (indent);
4022 printf ("%s ", prefix);
4023 write_attr_value (attr, value);
4024 printf ("%s\n", suffix);
4028 /* Write a series of case statements for every instruction in list IE.
4029 INDENT is the amount of indentation to write before each case. */
4031 static void
4032 write_insn_cases (struct insn_ent *ie, int indent)
4034 for (; ie != 0; ie = ie->next)
4035 if (ie->def->insn_code != -1)
4037 write_indent (indent);
4038 if (GET_CODE (ie->def->def) == DEFINE_PEEPHOLE)
4039 printf ("case %d: /* define_peephole, line %d */\n",
4040 ie->def->insn_code, ie->def->lineno);
4041 else
4042 printf ("case %d: /* %s */\n",
4043 ie->def->insn_code, XSTR (ie->def->def, 0));
4047 /* Write out the computation for one attribute value. */
4049 static void
4050 write_attr_case (struct attr_desc *attr, struct attr_value *av,
4051 int write_case_lines, const char *prefix, const char *suffix,
4052 int indent, rtx known_true)
4054 if (av->num_insns == 0)
4055 return;
4057 if (av->has_asm_insn)
4059 write_indent (indent);
4060 printf ("case -1:\n");
4061 write_indent (indent + 2);
4062 printf ("if (GET_CODE (PATTERN (insn)) != ASM_INPUT\n");
4063 write_indent (indent + 2);
4064 printf (" && asm_noperands (PATTERN (insn)) < 0)\n");
4065 write_indent (indent + 2);
4066 printf (" fatal_insn_not_found (insn);\n");
4069 if (write_case_lines)
4070 write_insn_cases (av->first_insn, indent);
4071 else
4073 write_indent (indent);
4074 printf ("default:\n");
4077 /* See what we have to do to output this value. */
4078 must_extract = must_constrain = address_used = 0;
4079 walk_attr_value (av->value);
4081 if (must_constrain)
4083 write_indent (indent + 2);
4084 printf ("extract_constrain_insn_cached (insn);\n");
4086 else if (must_extract)
4088 write_indent (indent + 2);
4089 printf ("extract_insn_cached (insn);\n");
4092 attrs_to_cache = 0;
4093 if (av->num_insns == 1)
4094 write_attr_set (attr, indent + 2, av->value, prefix, suffix,
4095 known_true, av->first_insn->def->insn_code,
4096 av->first_insn->def->insn_index, 0);
4097 else
4098 write_attr_set (attr, indent + 2, av->value, prefix, suffix,
4099 known_true, -2, 0, 0);
4101 if (strncmp (prefix, "return", 6))
4103 write_indent (indent + 2);
4104 printf ("break;\n");
4106 printf ("\n");
4109 /* Utilities to write in various forms. */
4111 static void
4112 write_attr_valueq (struct attr_desc *attr, const char *s)
4114 if (attr->is_numeric)
4116 int num = atoi (s);
4118 printf ("%d", num);
4120 if (num > 9 || num < 0)
4121 printf (" /* %#x */", num);
4123 else
4125 write_upcase (attr->enum_name ? attr->enum_name : attr->name);
4126 printf ("_");
4127 write_upcase (s);
4131 static void
4132 write_attr_value (struct attr_desc *attr, rtx value)
4134 int op;
4136 switch (GET_CODE (value))
4138 case CONST_STRING:
4139 write_attr_valueq (attr, XSTR (value, 0));
4140 break;
4142 case CONST_INT:
4143 printf (HOST_WIDE_INT_PRINT_DEC, INTVAL (value));
4144 break;
4146 case SYMBOL_REF:
4147 print_c_condition (XSTR (value, 0));
4148 break;
4150 case ATTR:
4152 struct attr_desc *attr2 = find_attr (&XSTR (value, 0), 0);
4153 if (attr->enum_name)
4154 printf ("(enum %s)", attr->enum_name);
4155 else if (!attr->is_numeric)
4156 printf ("(enum attr_%s)", attr->name);
4157 else if (!attr2->is_numeric)
4158 printf ("(int)");
4160 printf ("get_attr_%s (%s)", attr2->name,
4161 (attr2->is_const ? "" : "insn"));
4163 break;
4165 case PLUS:
4166 op = '+';
4167 goto do_operator;
4168 case MINUS:
4169 op = '-';
4170 goto do_operator;
4171 case MULT:
4172 op = '*';
4173 goto do_operator;
4174 case DIV:
4175 op = '/';
4176 goto do_operator;
4177 case MOD:
4178 op = '%';
4179 goto do_operator;
4181 do_operator:
4182 write_attr_value (attr, XEXP (value, 0));
4183 putchar (' ');
4184 putchar (op);
4185 putchar (' ');
4186 write_attr_value (attr, XEXP (value, 1));
4187 break;
4189 default:
4190 gcc_unreachable ();
4194 static void
4195 write_upcase (const char *str)
4197 while (*str)
4199 /* The argument of TOUPPER should not have side effects. */
4200 putchar (TOUPPER(*str));
4201 str++;
4205 static void
4206 write_indent (int indent)
4208 for (; indent > 8; indent -= 8)
4209 printf ("\t");
4211 for (; indent; indent--)
4212 printf (" ");
4215 /* Write a subroutine that is given an insn that requires a delay slot, a
4216 delay slot ordinal, and a candidate insn. It returns nonzero if the
4217 candidate can be placed in the specified delay slot of the insn.
4219 We can write as many as three subroutines. `eligible_for_delay'
4220 handles normal delay slots, `eligible_for_annul_true' indicates that
4221 the specified insn can be annulled if the branch is true, and likewise
4222 for `eligible_for_annul_false'.
4224 KIND is a string distinguishing these three cases ("delay", "annul_true",
4225 or "annul_false"). */
4227 static void
4228 write_eligible_delay (const char *kind)
4230 struct delay_desc *delay;
4231 int max_slots;
4232 char str[50];
4233 const char *pstr;
4234 struct attr_desc *attr;
4235 struct attr_value *av, *common_av;
4236 int i;
4238 /* Compute the maximum number of delay slots required. We use the delay
4239 ordinal times this number plus one, plus the slot number as an index into
4240 the appropriate predicate to test. */
4242 for (delay = delays, max_slots = 0; delay; delay = delay->next)
4243 if (XVECLEN (delay->def, 1) / 3 > max_slots)
4244 max_slots = XVECLEN (delay->def, 1) / 3;
4246 /* Write function prelude. */
4248 printf ("int\n");
4249 printf ("eligible_for_%s (rtx delay_insn ATTRIBUTE_UNUSED, int slot, rtx candidate_insn, int flags ATTRIBUTE_UNUSED)\n",
4250 kind);
4251 printf ("{\n");
4252 printf (" rtx insn;\n");
4253 printf ("\n");
4254 printf (" gcc_assert (slot < %d);\n", max_slots);
4255 printf ("\n");
4256 /* Allow dbr_schedule to pass labels, etc. This can happen if try_split
4257 converts a compound instruction into a loop. */
4258 printf (" if (!INSN_P (candidate_insn))\n");
4259 printf (" return 0;\n");
4260 printf ("\n");
4262 /* If more than one delay type, find out which type the delay insn is. */
4264 if (num_delays > 1)
4266 attr = find_attr (&delay_type_str, 0);
4267 gcc_assert (attr);
4268 common_av = find_most_used (attr);
4270 printf (" insn = delay_insn;\n");
4271 printf (" switch (recog_memoized (insn))\n");
4272 printf (" {\n");
4274 sprintf (str, " * %d;\n break;", max_slots);
4275 for (av = attr->first_value; av; av = av->next)
4276 if (av != common_av)
4277 write_attr_case (attr, av, 1, "slot +=", str, 4, true_rtx);
4279 write_attr_case (attr, common_av, 0, "slot +=", str, 4, true_rtx);
4280 printf (" }\n\n");
4282 /* Ensure matched. Otherwise, shouldn't have been called. */
4283 printf (" gcc_assert (slot >= %d);\n\n", max_slots);
4286 /* If just one type of delay slot, write simple switch. */
4287 if (num_delays == 1 && max_slots == 1)
4289 printf (" insn = candidate_insn;\n");
4290 printf (" switch (recog_memoized (insn))\n");
4291 printf (" {\n");
4293 attr = find_attr (&delay_1_0_str, 0);
4294 gcc_assert (attr);
4295 common_av = find_most_used (attr);
4297 for (av = attr->first_value; av; av = av->next)
4298 if (av != common_av)
4299 write_attr_case (attr, av, 1, "return", ";", 4, true_rtx);
4301 write_attr_case (attr, common_av, 0, "return", ";", 4, true_rtx);
4302 printf (" }\n");
4305 else
4307 /* Write a nested CASE. The first indicates which condition we need to
4308 test, and the inner CASE tests the condition. */
4309 printf (" insn = candidate_insn;\n");
4310 printf (" switch (slot)\n");
4311 printf (" {\n");
4313 for (delay = delays; delay; delay = delay->next)
4314 for (i = 0; i < XVECLEN (delay->def, 1); i += 3)
4316 printf (" case %d:\n",
4317 (i / 3) + (num_delays == 1 ? 0 : delay->num * max_slots));
4318 printf (" switch (recog_memoized (insn))\n");
4319 printf ("\t{\n");
4321 sprintf (str, "*%s_%d_%d", kind, delay->num, i / 3);
4322 pstr = str;
4323 attr = find_attr (&pstr, 0);
4324 gcc_assert (attr);
4325 common_av = find_most_used (attr);
4327 for (av = attr->first_value; av; av = av->next)
4328 if (av != common_av)
4329 write_attr_case (attr, av, 1, "return", ";", 8, true_rtx);
4331 write_attr_case (attr, common_av, 0, "return", ";", 8, true_rtx);
4332 printf (" }\n");
4335 printf (" default:\n");
4336 printf (" gcc_unreachable ();\n");
4337 printf (" }\n");
4340 printf ("}\n\n");
4343 /* This page contains miscellaneous utility routines. */
4345 /* Given a pointer to a (char *), return a malloc'ed string containing the
4346 next comma-separated element. Advance the pointer to after the string
4347 scanned, or the end-of-string. Return NULL if at end of string. */
4349 static char *
4350 next_comma_elt (const char **pstr)
4352 const char *start;
4354 start = scan_comma_elt (pstr);
4356 if (start == NULL)
4357 return NULL;
4359 return attr_string (start, *pstr - start);
4362 /* Return a `struct attr_desc' pointer for a given named attribute. If CREATE
4363 is nonzero, build a new attribute, if one does not exist. *NAME_P is
4364 replaced by a pointer to a canonical copy of the string. */
4366 static struct attr_desc *
4367 find_attr (const char **name_p, int create)
4369 struct attr_desc *attr;
4370 int index;
4371 const char *name = *name_p;
4373 /* Before we resort to using `strcmp', see if the string address matches
4374 anywhere. In most cases, it should have been canonicalized to do so. */
4375 if (name == alternative_name)
4376 return NULL;
4378 index = name[0] & (MAX_ATTRS_INDEX - 1);
4379 for (attr = attrs[index]; attr; attr = attr->next)
4380 if (name == attr->name)
4381 return attr;
4383 /* Otherwise, do it the slow way. */
4384 for (attr = attrs[index]; attr; attr = attr->next)
4385 if (name[0] == attr->name[0] && ! strcmp (name, attr->name))
4387 *name_p = attr->name;
4388 return attr;
4391 if (! create)
4392 return NULL;
4394 attr = oballoc (struct attr_desc);
4395 attr->name = DEF_ATTR_STRING (name);
4396 attr->enum_name = 0;
4397 attr->first_value = attr->default_val = NULL;
4398 attr->is_numeric = attr->is_const = attr->is_special = 0;
4399 attr->next = attrs[index];
4400 attrs[index] = attr;
4402 *name_p = attr->name;
4404 return attr;
4407 /* Create internal attribute with the given default value. */
4409 static void
4410 make_internal_attr (const char *name, rtx value, int special)
4412 struct attr_desc *attr;
4414 attr = find_attr (&name, 1);
4415 gcc_assert (!attr->default_val);
4417 attr->is_numeric = 1;
4418 attr->is_const = 0;
4419 attr->is_special = (special & ATTR_SPECIAL) != 0;
4420 attr->default_val = get_attr_value (value, attr, -2);
4423 /* Find the most used value of an attribute. */
4425 static struct attr_value *
4426 find_most_used (struct attr_desc *attr)
4428 struct attr_value *av;
4429 struct attr_value *most_used;
4430 int nuses;
4432 most_used = NULL;
4433 nuses = -1;
4435 for (av = attr->first_value; av; av = av->next)
4436 if (av->num_insns > nuses)
4437 nuses = av->num_insns, most_used = av;
4439 return most_used;
4442 /* Return (attr_value "n") */
4444 static rtx
4445 make_numeric_value (int n)
4447 static rtx int_values[20];
4448 rtx exp;
4449 char *p;
4451 gcc_assert (n >= 0);
4453 if (n < 20 && int_values[n])
4454 return int_values[n];
4456 p = attr_printf (MAX_DIGITS, "%d", n);
4457 exp = attr_rtx (CONST_STRING, p);
4459 if (n < 20)
4460 int_values[n] = exp;
4462 return exp;
4465 static rtx
4466 copy_rtx_unchanging (rtx orig)
4468 if (ATTR_IND_SIMPLIFIED_P (orig) || ATTR_CURR_SIMPLIFIED_P (orig))
4469 return orig;
4471 ATTR_CURR_SIMPLIFIED_P (orig) = 1;
4472 return orig;
4475 /* Determine if an insn has a constant number of delay slots, i.e., the
4476 number of delay slots is not a function of the length of the insn. */
4478 static void
4479 write_const_num_delay_slots (void)
4481 struct attr_desc *attr = find_attr (&num_delay_slots_str, 0);
4482 struct attr_value *av;
4484 if (attr)
4486 printf ("int\nconst_num_delay_slots (rtx insn)\n");
4487 printf ("{\n");
4488 printf (" switch (recog_memoized (insn))\n");
4489 printf (" {\n");
4491 for (av = attr->first_value; av; av = av->next)
4493 length_used = 0;
4494 walk_attr_value (av->value);
4495 if (length_used)
4496 write_insn_cases (av->first_insn, 4);
4499 printf (" default:\n");
4500 printf (" return 1;\n");
4501 printf (" }\n}\n\n");
4505 /* Synthetic attributes used by insn-automata.c and the scheduler.
4506 These are primarily concerned with (define_insn_reservation)
4507 patterns. */
4509 struct insn_reserv
4511 struct insn_reserv *next;
4513 const char *name;
4514 int default_latency;
4515 rtx condexp;
4517 /* Sequence number of this insn. */
4518 int insn_num;
4520 /* Whether a (define_bypass) construct names this insn in its
4521 output list. */
4522 bool bypassed;
4525 static struct insn_reserv *all_insn_reservs = 0;
4526 static struct insn_reserv **last_insn_reserv_p = &all_insn_reservs;
4527 static size_t n_insn_reservs;
4529 /* Store information from a DEFINE_INSN_RESERVATION for future
4530 attribute generation. */
4531 static void
4532 gen_insn_reserv (rtx def)
4534 struct insn_reserv *decl = oballoc (struct insn_reserv);
4536 decl->name = DEF_ATTR_STRING (XSTR (def, 0));
4537 decl->default_latency = XINT (def, 1);
4538 decl->condexp = check_attr_test (XEXP (def, 2), 0, 0);
4539 decl->insn_num = n_insn_reservs;
4540 decl->bypassed = false;
4541 decl->next = 0;
4543 *last_insn_reserv_p = decl;
4544 last_insn_reserv_p = &decl->next;
4545 n_insn_reservs++;
4548 /* Store information from a DEFINE_BYPASS for future attribute
4549 generation. The only thing we care about is the list of output
4550 insns, which will later be used to tag reservation structures with
4551 a 'bypassed' bit. */
4553 struct bypass_list
4555 struct bypass_list *next;
4556 const char *insn;
4559 static struct bypass_list *all_bypasses;
4560 static size_t n_bypasses;
4562 static void
4563 gen_bypass_1 (const char *s, size_t len)
4565 struct bypass_list *b;
4567 if (len == 0)
4568 return;
4570 s = attr_string (s, len);
4571 for (b = all_bypasses; b; b = b->next)
4572 if (s == b->insn)
4573 return; /* already got that one */
4575 b = oballoc (struct bypass_list);
4576 b->insn = s;
4577 b->next = all_bypasses;
4578 all_bypasses = b;
4579 n_bypasses++;
4582 static void
4583 gen_bypass (rtx def)
4585 const char *p, *base;
4587 for (p = base = XSTR (def, 1); *p; p++)
4588 if (*p == ',')
4590 gen_bypass_1 (base, p - base);
4592 p++;
4593 while (ISSPACE (*p));
4594 base = p;
4596 gen_bypass_1 (base, p - base);
4599 /* Find and mark all of the bypassed insns. */
4600 static void
4601 process_bypasses (void)
4603 struct bypass_list *b;
4604 struct insn_reserv *r;
4606 /* The reservation list is likely to be much longer than the bypass
4607 list. */
4608 for (r = all_insn_reservs; r; r = r->next)
4609 for (b = all_bypasses; b; b = b->next)
4610 if (r->name == b->insn)
4611 r->bypassed = true;
4614 /* Check that attribute NAME is used in define_insn_reservation condition
4615 EXP. Return true if it is. */
4616 static bool
4617 check_tune_attr (const char *name, rtx exp)
4619 switch (GET_CODE (exp))
4621 case AND:
4622 if (check_tune_attr (name, XEXP (exp, 0)))
4623 return true;
4624 return check_tune_attr (name, XEXP (exp, 1));
4626 case IOR:
4627 return (check_tune_attr (name, XEXP (exp, 0))
4628 && check_tune_attr (name, XEXP (exp, 1)));
4630 case EQ_ATTR:
4631 return XSTR (exp, 0) == name;
4633 default:
4634 return false;
4638 /* Try to find a const attribute (usually cpu or tune) that is used
4639 in all define_insn_reservation conditions. */
4640 static struct attr_desc *
4641 find_tune_attr (rtx exp)
4643 struct attr_desc *attr;
4645 switch (GET_CODE (exp))
4647 case AND:
4648 case IOR:
4649 attr = find_tune_attr (XEXP (exp, 0));
4650 if (attr)
4651 return attr;
4652 return find_tune_attr (XEXP (exp, 1));
4654 case EQ_ATTR:
4655 if (XSTR (exp, 0) == alternative_name)
4656 return NULL;
4658 attr = find_attr (&XSTR (exp, 0), 0);
4659 gcc_assert (attr);
4661 if (attr->is_const && !attr->is_special)
4663 struct insn_reserv *decl;
4665 for (decl = all_insn_reservs; decl; decl = decl->next)
4666 if (! check_tune_attr (attr->name, decl->condexp))
4667 return NULL;
4668 return attr;
4670 return NULL;
4672 default:
4673 return NULL;
4677 /* Create all of the attributes that describe automaton properties. */
4678 static void
4679 make_automaton_attrs (void)
4681 int i;
4682 struct insn_reserv *decl;
4683 rtx code_exp, lats_exp, byps_exp;
4684 struct attr_desc *tune_attr;
4686 if (n_insn_reservs == 0)
4687 return;
4689 tune_attr = find_tune_attr (all_insn_reservs->condexp);
4690 if (tune_attr != NULL)
4692 rtx *condexps = XNEWVEC (rtx, n_insn_reservs * 3);
4693 struct attr_value *val;
4694 bool first = true;
4696 gcc_assert (tune_attr->is_const
4697 && !tune_attr->is_special
4698 && !tune_attr->is_numeric);
4699 for (val = tune_attr->first_value; val; val = val->next)
4701 if (val == tune_attr->default_val)
4702 continue;
4703 gcc_assert (GET_CODE (val->value) == CONST_STRING);
4704 printf ("static int internal_dfa_insn_code_%s (rtx);\n"
4705 "static int insn_default_latency_%s (rtx);\n",
4706 XSTR (val->value, 0), XSTR (val->value, 0));
4709 printf ("\n");
4710 printf ("int (*internal_dfa_insn_code) (rtx);\n");
4711 printf ("int (*insn_default_latency) (rtx);\n");
4712 printf ("\n");
4713 printf ("void\n");
4714 printf ("init_sched_attrs (void)\n");
4715 printf ("{\n");
4717 for (val = tune_attr->first_value; val; val = val->next)
4719 int j;
4720 char *name;
4721 rtx test = attr_rtx (EQ_ATTR, tune_attr->name, XSTR (val->value, 0));
4723 if (val == tune_attr->default_val)
4724 continue;
4725 for (decl = all_insn_reservs, i = 0;
4726 decl;
4727 decl = decl->next)
4729 rtx ctest = test;
4730 rtx condexp
4731 = simplify_and_tree (decl->condexp, &ctest, -2, 0);
4732 if (condexp == false_rtx)
4733 continue;
4734 if (condexp == true_rtx)
4735 break;
4736 condexps[i] = condexp;
4737 condexps[i + 1] = make_numeric_value (decl->insn_num);
4738 condexps[i + 2] = make_numeric_value (decl->default_latency);
4739 i += 3;
4742 code_exp = rtx_alloc (COND);
4743 lats_exp = rtx_alloc (COND);
4745 j = i / 3 * 2;
4746 XVEC (code_exp, 0) = rtvec_alloc (j);
4747 XVEC (lats_exp, 0) = rtvec_alloc (j);
4749 if (decl)
4751 XEXP (code_exp, 1) = make_numeric_value (decl->insn_num);
4752 XEXP (lats_exp, 1) = make_numeric_value (decl->default_latency);
4754 else
4756 XEXP (code_exp, 1) = make_numeric_value (n_insn_reservs + 1);
4757 XEXP (lats_exp, 1) = make_numeric_value (0);
4760 while (i > 0)
4762 i -= 3;
4763 j -= 2;
4764 XVECEXP (code_exp, 0, j) = condexps[i];
4765 XVECEXP (lats_exp, 0, j) = condexps[i];
4767 XVECEXP (code_exp, 0, j + 1) = condexps[i + 1];
4768 XVECEXP (lats_exp, 0, j + 1) = condexps[i + 2];
4771 name = XNEWVEC (char,
4772 sizeof ("*internal_dfa_insn_code_")
4773 + strlen (XSTR (val->value, 0)));
4774 strcpy (name, "*internal_dfa_insn_code_");
4775 strcat (name, XSTR (val->value, 0));
4776 make_internal_attr (name, code_exp, ATTR_NONE);
4777 strcpy (name, "*insn_default_latency_");
4778 strcat (name, XSTR (val->value, 0));
4779 make_internal_attr (name, lats_exp, ATTR_NONE);
4780 XDELETEVEC (name);
4782 if (first)
4784 printf (" if (");
4785 first = false;
4787 else
4788 printf (" else if (");
4789 write_test_expr (test, 0, 0);
4790 printf (")\n");
4791 printf (" {\n");
4792 printf (" internal_dfa_insn_code\n");
4793 printf (" = internal_dfa_insn_code_%s;\n",
4794 XSTR (val->value, 0));
4795 printf (" insn_default_latency\n");
4796 printf (" = insn_default_latency_%s;\n",
4797 XSTR (val->value, 0));
4798 printf (" }\n");
4801 printf (" else\n");
4802 printf (" gcc_unreachable ();\n");
4803 printf ("}\n");
4804 printf ("\n");
4806 XDELETEVEC (condexps);
4808 else
4810 code_exp = rtx_alloc (COND);
4811 lats_exp = rtx_alloc (COND);
4813 XVEC (code_exp, 0) = rtvec_alloc (n_insn_reservs * 2);
4814 XVEC (lats_exp, 0) = rtvec_alloc (n_insn_reservs * 2);
4816 XEXP (code_exp, 1) = make_numeric_value (n_insn_reservs + 1);
4817 XEXP (lats_exp, 1) = make_numeric_value (0);
4819 for (decl = all_insn_reservs, i = 0;
4820 decl;
4821 decl = decl->next, i += 2)
4823 XVECEXP (code_exp, 0, i) = decl->condexp;
4824 XVECEXP (lats_exp, 0, i) = decl->condexp;
4826 XVECEXP (code_exp, 0, i+1) = make_numeric_value (decl->insn_num);
4827 XVECEXP (lats_exp, 0, i+1)
4828 = make_numeric_value (decl->default_latency);
4830 make_internal_attr ("*internal_dfa_insn_code", code_exp, ATTR_NONE);
4831 make_internal_attr ("*insn_default_latency", lats_exp, ATTR_NONE);
4834 if (n_bypasses == 0)
4835 byps_exp = make_numeric_value (0);
4836 else
4838 process_bypasses ();
4840 byps_exp = rtx_alloc (COND);
4841 XVEC (byps_exp, 0) = rtvec_alloc (n_bypasses * 2);
4842 XEXP (byps_exp, 1) = make_numeric_value (0);
4843 for (decl = all_insn_reservs, i = 0;
4844 decl;
4845 decl = decl->next)
4846 if (decl->bypassed)
4848 XVECEXP (byps_exp, 0, i) = decl->condexp;
4849 XVECEXP (byps_exp, 0, i+1) = make_numeric_value (1);
4850 i += 2;
4854 make_internal_attr ("*bypass_p", byps_exp, ATTR_NONE);
4858 main (int argc, char **argv)
4860 rtx desc;
4861 struct attr_desc *attr;
4862 struct insn_def *id;
4863 rtx tem;
4864 int i;
4866 progname = "genattrtab";
4868 if (!init_rtx_reader_args (argc, argv))
4869 return (FATAL_EXIT_CODE);
4871 obstack_init (hash_obstack);
4872 obstack_init (temp_obstack);
4874 /* Set up true and false rtx's */
4875 true_rtx = rtx_alloc (CONST_INT);
4876 XWINT (true_rtx, 0) = 1;
4877 false_rtx = rtx_alloc (CONST_INT);
4878 XWINT (false_rtx, 0) = 0;
4879 ATTR_IND_SIMPLIFIED_P (true_rtx) = ATTR_IND_SIMPLIFIED_P (false_rtx) = 1;
4880 ATTR_PERMANENT_P (true_rtx) = ATTR_PERMANENT_P (false_rtx) = 1;
4882 alternative_name = DEF_ATTR_STRING ("alternative");
4883 length_str = DEF_ATTR_STRING ("length");
4884 delay_type_str = DEF_ATTR_STRING ("*delay_type");
4885 delay_1_0_str = DEF_ATTR_STRING ("*delay_1_0");
4886 num_delay_slots_str = DEF_ATTR_STRING ("*num_delay_slots");
4888 printf ("/* Generated automatically by the program `genattrtab'\n\
4889 from the machine description file `md'. */\n\n");
4891 /* Read the machine description. */
4893 while (1)
4895 int lineno;
4897 desc = read_md_rtx (&lineno, &insn_code_number);
4898 if (desc == NULL)
4899 break;
4901 switch (GET_CODE (desc))
4903 case DEFINE_INSN:
4904 case DEFINE_PEEPHOLE:
4905 case DEFINE_ASM_ATTRIBUTES:
4906 gen_insn (desc, lineno);
4907 break;
4909 case DEFINE_ATTR:
4910 case DEFINE_ENUM_ATTR:
4911 gen_attr (desc, lineno);
4912 break;
4914 case DEFINE_DELAY:
4915 gen_delay (desc, lineno);
4916 break;
4918 case DEFINE_INSN_RESERVATION:
4919 gen_insn_reserv (desc);
4920 break;
4922 case DEFINE_BYPASS:
4923 gen_bypass (desc);
4924 break;
4926 default:
4927 break;
4929 if (GET_CODE (desc) != DEFINE_ASM_ATTRIBUTES)
4930 insn_index_number++;
4933 if (have_error)
4934 return FATAL_EXIT_CODE;
4936 insn_code_number++;
4938 /* If we didn't have a DEFINE_ASM_ATTRIBUTES, make a null one. */
4939 if (! got_define_asm_attributes)
4941 tem = rtx_alloc (DEFINE_ASM_ATTRIBUTES);
4942 XVEC (tem, 0) = rtvec_alloc (0);
4943 gen_insn (tem, 0);
4946 /* Expand DEFINE_DELAY information into new attribute. */
4947 if (num_delays)
4948 expand_delays ();
4950 printf ("#include \"config.h\"\n");
4951 printf ("#include \"system.h\"\n");
4952 printf ("#include \"coretypes.h\"\n");
4953 printf ("#include \"tm.h\"\n");
4954 printf ("#include \"rtl.h\"\n");
4955 printf ("#include \"insn-attr.h\"\n");
4956 printf ("#include \"tm_p.h\"\n");
4957 printf ("#include \"insn-config.h\"\n");
4958 printf ("#include \"recog.h\"\n");
4959 printf ("#include \"regs.h\"\n");
4960 printf ("#include \"output.h\"\n");
4961 printf ("#include \"diagnostic-core.h\"\n");
4962 printf ("#include \"flags.h\"\n");
4963 printf ("#include \"function.h\"\n");
4964 printf ("\n");
4965 printf ("#define operands recog_data.operand\n\n");
4967 /* Make `insn_alternatives'. */
4968 insn_alternatives = oballocvec (int, insn_code_number);
4969 for (id = defs; id; id = id->next)
4970 if (id->insn_code >= 0)
4971 insn_alternatives[id->insn_code] = (1 << id->num_alternatives) - 1;
4973 /* Make `insn_n_alternatives'. */
4974 insn_n_alternatives = oballocvec (int, insn_code_number);
4975 for (id = defs; id; id = id->next)
4976 if (id->insn_code >= 0)
4977 insn_n_alternatives[id->insn_code] = id->num_alternatives;
4979 /* Construct extra attributes for automata. */
4980 make_automaton_attrs ();
4982 /* Prepare to write out attribute subroutines by checking everything stored
4983 away and building the attribute cases. */
4985 check_defs ();
4987 for (i = 0; i < MAX_ATTRS_INDEX; i++)
4988 for (attr = attrs[i]; attr; attr = attr->next)
4989 attr->default_val->value
4990 = check_attr_value (attr->default_val->value, attr);
4992 if (have_error)
4993 return FATAL_EXIT_CODE;
4995 for (i = 0; i < MAX_ATTRS_INDEX; i++)
4996 for (attr = attrs[i]; attr; attr = attr->next)
4997 fill_attr (attr);
4999 /* Construct extra attributes for `length'. */
5000 make_length_attrs ();
5002 /* Perform any possible optimizations to speed up compilation. */
5003 optimize_attrs ();
5005 /* Now write out all the `gen_attr_...' routines. Do these before the
5006 special routines so that they get defined before they are used. */
5008 for (i = 0; i < MAX_ATTRS_INDEX; i++)
5009 for (attr = attrs[i]; attr; attr = attr->next)
5011 if (! attr->is_special && ! attr->is_const)
5012 write_attr_get (attr);
5015 /* Write out delay eligibility information, if DEFINE_DELAY present.
5016 (The function to compute the number of delay slots will be written
5017 below.) */
5018 if (num_delays)
5020 write_eligible_delay ("delay");
5021 if (have_annul_true)
5022 write_eligible_delay ("annul_true");
5023 if (have_annul_false)
5024 write_eligible_delay ("annul_false");
5027 /* Write out constant delay slot info. */
5028 write_const_num_delay_slots ();
5030 write_length_unit_log ();
5032 fflush (stdout);
5033 return (ferror (stdout) != 0 ? FATAL_EXIT_CODE : SUCCESS_EXIT_CODE);