gcc/genattrtab.c

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