gcc/genattrtab.c

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