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