gcc/genattrtab.c

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