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