gcc/genattrtab.c

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