gcc/genattrtab.c

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