gcc/genattrtab.c

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