gcc/genattrtab.c

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