gcc/genattrtab.c

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