gcc/genattrtab.c

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