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