1 /* Generate code from machine description to compute values of attributes.
2 Copyright (C) 1991, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000 Free Software Foundation, Inc.
4 Contributed by Richard Kenner (kenner@vlsi1.ultra.nyu.edu)
6 This file is part of GNU CC.
8 GNU CC is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
13 GNU CC is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GNU CC; see the file COPYING. If not, write to
20 the Free Software Foundation, 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
23 /* This program handles insn attributes and the DEFINE_DELAY and
24 DEFINE_FUNCTION_UNIT definitions.
26 It produces a series of functions named `get_attr_...', one for each insn
27 attribute. Each of these is given the rtx for an insn and returns a member
28 of the enum for the attribute.
30 These subroutines have the form of a `switch' on the INSN_CODE (via
31 `recog_memoized'). Each case either returns a constant attribute value
32 or a value that depends on tests on other attributes, the form of
33 operands, or some random C expression (encoded with a SYMBOL_REF
36 If the attribute `alternative', or a random C expression is present,
37 `constrain_operands' is called. If either of these cases of a reference to
38 an operand is found, `extract_insn' is called.
40 The special attribute `length' is also recognized. For this operand,
41 expressions involving the address of an operand or the current insn,
42 (address (pc)), are valid. In this case, an initial pass is made to
43 set all lengths that do not depend on address. Those that do are set to
44 the maximum length. Then each insn that depends on an address is checked
45 and possibly has its length changed. The process repeats until no further
46 changed are made. The resulting lengths are saved for use by
49 A special form of DEFINE_ATTR, where the expression for default value is a
50 CONST expression, indicates an attribute that is constant for a given run
51 of the compiler. The subroutine generated for these attributes has no
52 parameters as it does not depend on any particular insn. Constant
53 attributes are typically used to specify which variety of processor is
56 Internal attributes are defined to handle DEFINE_DELAY and
57 DEFINE_FUNCTION_UNIT. Special routines are output for these cases.
59 This program works by keeping a list of possible values for each attribute.
60 These include the basic attribute choices, default values for attribute, and
61 all derived quantities.
63 As the description file is read, the definition for each insn is saved in a
64 `struct insn_def'. When the file reading is complete, a `struct insn_ent'
65 is created for each insn and chained to the corresponding attribute value,
66 either that specified, or the default.
68 An optimization phase is then run. This simplifies expressions for each
69 insn. EQ_ATTR tests are resolved, whenever possible, to a test that
70 indicates when the attribute has the specified value for the insn. This
71 avoids recursive calls during compilation.
73 The strategy used when processing DEFINE_DELAY and DEFINE_FUNCTION_UNIT
74 definitions is to create arbitrarily complex expressions and have the
75 optimization simplify them.
77 Once optimization is complete, any required routines and definitions
80 An optimization that is not yet implemented is to hoist the constant
81 expressions entirely out of the routines and definitions that are written.
82 A way to do this is to iterate over all possible combinations of values
83 for constant attributes and generate a set of functions for that given
84 combination. An initialization function would be written that evaluates
85 the attributes and installs the corresponding set of routines and
86 definitions (each would be accessed through a pointer).
88 We use the flags in an RTX as follows:
89 `unchanging' (RTX_UNCHANGING_P): This rtx is fully simplified
90 independent of the insn code.
91 `in_struct' (MEM_IN_STRUCT_P): This rtx is fully simplified
92 for the insn code currently being processed (see optimize_attrs).
93 `integrated' (RTX_INTEGRATED_P): This rtx is permanent and unique
95 `volatil' (MEM_VOLATILE_P): During simplify_by_exploding the value of an
96 EQ_ATTR rtx is true if !volatil and false if volatil. */
102 #include "gensupport.h"
104 #ifdef HAVE_SYS_RESOURCE_H
105 # include <sys/resource.h>
108 /* We must include obstack.h after <sys/time.h>, to avoid lossage with
109 /usr/include/sys/stdtypes.h on Sun OS 4.x. */
113 static struct obstack obstack1, obstack2;
114 struct obstack *hash_obstack = &obstack1;
115 struct obstack *temp_obstack = &obstack2;
117 #define obstack_chunk_alloc xmalloc
118 #define obstack_chunk_free free
120 /* enough space to reserve for printing out ints */
121 #define MAX_DIGITS (HOST_BITS_PER_INT * 3 / 10 + 3)
123 /* Define structures used to record attributes and values. */
125 /* As each DEFINE_INSN, DEFINE_PEEPHOLE, or DEFINE_ASM_ATTRIBUTES is
126 encountered, we store all the relevant information into a
127 `struct insn_def'. This is done to allow attribute definitions to occur
128 anywhere in the file. */
132 struct insn_def *next; /* Next insn in chain. */
133 rtx def; /* The DEFINE_... */
134 int insn_code; /* Instruction number. */
135 int insn_index; /* Expression numer in file, for errors. */
136 int lineno; /* Line number. */
137 int num_alternatives; /* Number of alternatives. */
138 int vec_idx; /* Index of attribute vector in `def'. */
141 /* Once everything has been read in, we store in each attribute value a list
142 of insn codes that have that value. Here is the structure used for the
147 struct insn_ent *next; /* Next in chain. */
148 int insn_code; /* Instruction number. */
149 int insn_index; /* Index of definition in file */
150 int lineno; /* Line number. */
153 /* Each value of an attribute (either constant or computed) is assigned a
154 structure which is used as the listhead of the insns that have that
159 rtx value; /* Value of attribute. */
160 struct attr_value *next; /* Next attribute value in chain. */
161 struct insn_ent *first_insn; /* First insn with this value. */
162 int num_insns; /* Number of insns with this value. */
163 int has_asm_insn; /* True if this value used for `asm' insns */
166 /* Structure for each attribute. */
170 char *name; /* Name of attribute. */
171 struct attr_desc *next; /* Next attribute. */
172 unsigned is_numeric : 1; /* Values of this attribute are numeric. */
173 unsigned negative_ok : 1; /* Allow negative numeric values. */
174 unsigned unsigned_p : 1; /* Make the output function unsigned int. */
175 unsigned is_const : 1; /* Attribute value constant for each run. */
176 unsigned is_special : 1; /* Don't call `write_attr_set'. */
177 unsigned func_units_p : 1; /* this is the function_units attribute */
178 unsigned blockage_p : 1; /* this is the blockage range function */
179 struct attr_value *first_value; /* First value of this attribute. */
180 struct attr_value *default_val; /* Default value for this attribute. */
181 int lineno; /* Line number. */
184 #define NULL_ATTR (struct attr_desc *) NULL
186 /* A range of values. */
194 /* Structure for each DEFINE_DELAY. */
198 rtx def; /* DEFINE_DELAY expression. */
199 struct delay_desc *next; /* Next DEFINE_DELAY. */
200 int num; /* Number of DEFINE_DELAY, starting at 1. */
201 int lineno; /* Line number. */
204 /* Record information about each DEFINE_FUNCTION_UNIT. */
206 struct function_unit_op
208 rtx condexp; /* Expression TRUE for applicable insn. */
209 struct function_unit_op *next; /* Next operation for this function unit. */
210 int num; /* Ordinal for this operation type in unit. */
211 int ready; /* Cost until data is ready. */
212 int issue_delay; /* Cost until unit can accept another insn. */
213 rtx conflict_exp; /* Expression TRUE for insns incurring issue delay. */
214 rtx issue_exp; /* Expression computing issue delay. */
215 int lineno; /* Line number. */
218 /* Record information about each function unit mentioned in a
219 DEFINE_FUNCTION_UNIT. */
223 const char *name; /* Function unit name. */
224 struct function_unit *next; /* Next function unit. */
225 int num; /* Ordinal of this unit type. */
226 int multiplicity; /* Number of units of this type. */
227 int simultaneity; /* Maximum number of simultaneous insns
228 on this function unit or 0 if unlimited. */
229 rtx condexp; /* Expression TRUE for insn needing unit. */
230 int num_opclasses; /* Number of different operation types. */
231 struct function_unit_op *ops; /* Pointer to first operation type. */
232 int needs_conflict_function; /* Nonzero if a conflict function required. */
233 int needs_blockage_function; /* Nonzero if a blockage function required. */
234 int needs_range_function; /* Nonzero if blockage range function needed.*/
235 rtx default_cost; /* Conflict cost, if constant. */
236 struct range issue_delay; /* Range of issue delay values. */
237 int max_blockage; /* Maximum time an insn blocks the unit. */
238 int first_lineno; /* First seen line number. */
241 /* Listheads of above structures. */
243 /* This one is indexed by the first character of the attribute name. */
244 #define MAX_ATTRS_INDEX 256
245 static struct attr_desc *attrs[MAX_ATTRS_INDEX];
246 static struct insn_def *defs;
247 static struct delay_desc *delays;
248 static struct function_unit *units;
250 /* An expression where all the unknown terms are EQ_ATTR tests can be
251 rearranged into a COND provided we can enumerate all possible
252 combinations of the unknown values. The set of combinations become the
253 tests of the COND; the value of the expression given that combination is
254 computed and becomes the corresponding value. To do this, we must be
255 able to enumerate all values for each attribute used in the expression
256 (currently, we give up if we find a numeric attribute).
258 If the set of EQ_ATTR tests used in an expression tests the value of N
259 different attributes, the list of all possible combinations can be made
260 by walking the N-dimensional attribute space defined by those
261 attributes. We record each of these as a struct dimension.
263 The algorithm relies on sharing EQ_ATTR nodes: if two nodes in an
264 expression are the same, the will also have the same address. We find
265 all the EQ_ATTR nodes by marking them MEM_VOLATILE_P. This bit later
266 represents the value of an EQ_ATTR node, so once all nodes are marked,
267 they are also given an initial value of FALSE.
269 We then separate the set of EQ_ATTR nodes into dimensions for each
270 attribute and put them on the VALUES list. Terms are added as needed by
271 `add_values_to_cover' so that all possible values of the attribute are
274 Each dimension also has a current value. This is the node that is
275 currently considered to be TRUE. If this is one of the nodes added by
276 `add_values_to_cover', all the EQ_ATTR tests in the original expression
277 will be FALSE. Otherwise, only the CURRENT_VALUE will be true.
279 NUM_VALUES is simply the length of the VALUES list and is there for
282 Once the dimensions are created, the algorithm enumerates all possible
283 values and computes the current value of the given expression. */
287 struct attr_desc *attr; /* Attribute for this dimension. */
288 rtx values; /* List of attribute values used. */
289 rtx current_value; /* Position in the list for the TRUE value. */
290 int num_values; /* Length of the values list. */
293 /* Other variables. */
295 static int insn_code_number;
296 static int insn_index_number;
297 static int got_define_asm_attributes;
298 static int must_extract;
299 static int must_constrain;
300 static int address_used;
301 static int length_used;
302 static int num_delays;
303 static int have_annul_true, have_annul_false;
304 static int num_units, num_unit_opclasses;
305 static int num_insn_ents;
307 /* Used as operand to `operate_exp': */
309 enum operator {PLUS_OP, MINUS_OP, POS_MINUS_OP, EQ_OP, OR_OP, ORX_OP, MAX_OP, MIN_OP, RANGE_OP};
311 /* Stores, for each insn code, the number of constraint alternatives. */
313 static int *insn_n_alternatives;
315 /* Stores, for each insn code, a bitmap that has bits on for each possible
318 static int *insn_alternatives;
320 /* If nonzero, assume that the `alternative' attr has this value.
321 This is the hashed, unique string for the numeral
322 whose value is chosen alternative. */
324 static const char *current_alternative_string;
326 /* Used to simplify expressions. */
328 static rtx true_rtx, false_rtx;
330 /* Used to reduce calls to `strcmp' */
332 static char *alternative_name;
334 /* Indicate that REG_DEAD notes are valid if dead_or_set_p is ever
337 int reload_completed = 0;
339 /* Some machines test `optimize' in macros called from rtlanal.c, so we need
340 to define it here. */
344 /* Simplify an expression. Only call the routine if there is something to
346 #define SIMPLIFY_TEST_EXP(EXP,INSN_CODE,INSN_INDEX) \
347 (RTX_UNCHANGING_P (EXP) || MEM_IN_STRUCT_P (EXP) ? (EXP) \
348 : simplify_test_exp (EXP, INSN_CODE, INSN_INDEX))
350 /* Simplify (eq_attr ("alternative") ...)
351 when we are working with a particular alternative. */
352 #define SIMPLIFY_ALTERNATIVE(EXP) \
353 if (current_alternative_string \
354 && GET_CODE ((EXP)) == EQ_ATTR \
355 && XSTR ((EXP), 0) == alternative_name) \
356 (EXP) = (XSTR ((EXP), 1) == current_alternative_string \
357 ? true_rtx : false_rtx);
359 /* These are referenced by rtlanal.c and hence need to be defined somewhere.
360 They won't actually be used. */
362 rtx global_rtl[GR_MAX];
363 rtx pic_offset_table_rtx;
365 static void attr_hash_add_rtx PARAMS ((int, rtx));
366 static void attr_hash_add_string PARAMS ((int, char *));
367 static rtx attr_rtx PARAMS ((enum rtx_code, ...));
368 static char *attr_printf PARAMS ((int, const char *, ...))
370 static char *attr_string PARAMS ((const char *, int));
371 static rtx check_attr_test PARAMS ((rtx, int, int));
372 static rtx check_attr_value PARAMS ((rtx, struct attr_desc *));
373 static rtx convert_set_attr_alternative PARAMS ((rtx, struct insn_def *));
374 static rtx convert_set_attr PARAMS ((rtx, struct insn_def *));
375 static void check_defs PARAMS ((void));
377 static rtx convert_const_symbol_ref PARAMS ((rtx, struct attr_desc *));
379 static rtx make_canonical PARAMS ((struct attr_desc *, rtx));
380 static struct attr_value *get_attr_value PARAMS ((rtx, struct attr_desc *, int));
381 static rtx copy_rtx_unchanging PARAMS ((rtx));
382 static rtx copy_boolean PARAMS ((rtx));
383 static void expand_delays PARAMS ((void));
384 static rtx operate_exp PARAMS ((enum operator, rtx, rtx));
385 static void expand_units PARAMS ((void));
386 static rtx simplify_knowing PARAMS ((rtx, rtx));
387 static rtx encode_units_mask PARAMS ((rtx));
388 static void fill_attr PARAMS ((struct attr_desc *));
389 /* dpx2 compiler chokes if we specify the arg types of the args. */
390 static rtx substitute_address PARAMS ((rtx, rtx (*) (rtx), rtx (*) (rtx)));
391 static void make_length_attrs PARAMS ((void));
392 static rtx identity_fn PARAMS ((rtx));
393 static rtx zero_fn PARAMS ((rtx));
394 static rtx one_fn PARAMS ((rtx));
395 static rtx max_fn PARAMS ((rtx));
396 static void write_length_unit_log PARAMS ((void));
397 static rtx simplify_cond PARAMS ((rtx, int, int));
399 static rtx simplify_by_alternatives PARAMS ((rtx, int, int));
401 static rtx simplify_by_exploding PARAMS ((rtx));
402 static int find_and_mark_used_attributes PARAMS ((rtx, rtx *, int *));
403 static void unmark_used_attributes PARAMS ((rtx, struct dimension *, int));
404 static int add_values_to_cover PARAMS ((struct dimension *));
405 static int increment_current_value PARAMS ((struct dimension *, int));
406 static rtx test_for_current_value PARAMS ((struct dimension *, int));
407 static rtx simplify_with_current_value PARAMS ((rtx, struct dimension *, int));
408 static rtx simplify_with_current_value_aux PARAMS ((rtx));
409 static void clear_struct_flag PARAMS ((rtx));
410 static int count_sub_rtxs PARAMS ((rtx, int));
411 static void remove_insn_ent PARAMS ((struct attr_value *, struct insn_ent *));
412 static void insert_insn_ent PARAMS ((struct attr_value *, struct insn_ent *));
413 static rtx insert_right_side PARAMS ((enum rtx_code, rtx, rtx, int, int));
414 static rtx make_alternative_compare PARAMS ((int));
415 static int compute_alternative_mask PARAMS ((rtx, enum rtx_code));
416 static rtx evaluate_eq_attr PARAMS ((rtx, rtx, int, int));
417 static rtx simplify_and_tree PARAMS ((rtx, rtx *, int, int));
418 static rtx simplify_or_tree PARAMS ((rtx, rtx *, int, int));
419 static rtx simplify_test_exp PARAMS ((rtx, int, int));
420 static void optimize_attrs PARAMS ((void));
421 static void gen_attr PARAMS ((rtx, int));
422 static int count_alternatives PARAMS ((rtx));
423 static int compares_alternatives_p PARAMS ((rtx));
424 static int contained_in_p PARAMS ((rtx, rtx));
425 static void gen_insn PARAMS ((rtx, int));
426 static void gen_delay PARAMS ((rtx, int));
427 static void gen_unit PARAMS ((rtx, int));
428 static void write_test_expr PARAMS ((rtx, int));
429 static int max_attr_value PARAMS ((rtx, int*));
430 static int or_attr_value PARAMS ((rtx, int*));
431 static void walk_attr_value PARAMS ((rtx));
432 static void write_attr_get PARAMS ((struct attr_desc *));
433 static rtx eliminate_known_true PARAMS ((rtx, rtx, int, int));
434 static void write_attr_set PARAMS ((struct attr_desc *, int, rtx,
435 const char *, const char *, rtx,
437 static void write_attr_case PARAMS ((struct attr_desc *, struct attr_value *,
438 int, const char *, const char *, int, rtx));
439 static void write_unit_name PARAMS ((const char *, int, const char *));
440 static void write_attr_valueq PARAMS ((struct attr_desc *, const char *));
441 static void write_attr_value PARAMS ((struct attr_desc *, rtx));
442 static void write_upcase PARAMS ((const char *));
443 static void write_indent PARAMS ((int));
444 static void write_eligible_delay PARAMS ((const char *));
445 static void write_function_unit_info PARAMS ((void));
446 static void write_complex_function PARAMS ((struct function_unit *, const char *,
448 static int write_expr_attr_cache PARAMS ((rtx, struct attr_desc *));
449 static void write_toplevel_expr PARAMS ((rtx));
450 static void write_const_num_delay_slots PARAMS ((void));
451 static int n_comma_elts PARAMS ((const char *));
452 static char *next_comma_elt PARAMS ((const char **));
453 static struct attr_desc *find_attr PARAMS ((const char *, int));
454 static void make_internal_attr PARAMS ((const char *, rtx, int));
455 static struct attr_value *find_most_used PARAMS ((struct attr_desc *));
456 static rtx find_single_value PARAMS ((struct attr_desc *));
457 static rtx make_numeric_value PARAMS ((int));
458 static void extend_range PARAMS ((struct range *, int, int));
459 static rtx attr_eq PARAMS ((const char *, const char *));
460 static const char *attr_numeral PARAMS ((int));
461 static int attr_equal_p PARAMS ((rtx, rtx));
462 static rtx attr_copy_rtx PARAMS ((rtx));
464 #define oballoc(size) obstack_alloc (hash_obstack, size)
466 /* Hash table for sharing RTL and strings. */
468 /* Each hash table slot is a bucket containing a chain of these structures.
469 Strings are given negative hash codes; RTL expressions are given positive
474 struct attr_hash *next; /* Next structure in the bucket. */
475 int hashcode; /* Hash code of this rtx or string. */
478 char *str; /* The string (negative hash codes) */
479 rtx rtl; /* or the RTL recorded here. */
483 /* Now here is the hash table. When recording an RTL, it is added to
484 the slot whose index is the hash code mod the table size. Note
485 that the hash table is used for several kinds of RTL (see attr_rtx)
486 and for strings. While all these live in the same table, they are
487 completely independent, and the hash code is computed differently
490 #define RTL_HASH_SIZE 4093
491 struct attr_hash *attr_hash_table[RTL_HASH_SIZE];
493 /* Here is how primitive or already-shared RTL's hash
495 #define RTL_HASH(RTL) ((long) (RTL) & 0777777)
497 /* Add an entry to the hash table for RTL with hash code HASHCODE. */
500 attr_hash_add_rtx (hashcode, rtl)
504 register struct attr_hash *h;
506 h = (struct attr_hash *) obstack_alloc (hash_obstack,
507 sizeof (struct attr_hash));
508 h->hashcode = hashcode;
510 h->next = attr_hash_table[hashcode % RTL_HASH_SIZE];
511 attr_hash_table[hashcode % RTL_HASH_SIZE] = h;
514 /* Add an entry to the hash table for STRING with hash code HASHCODE. */
517 attr_hash_add_string (hashcode, str)
521 register struct attr_hash *h;
523 h = (struct attr_hash *) obstack_alloc (hash_obstack,
524 sizeof (struct attr_hash));
525 h->hashcode = -hashcode;
527 h->next = attr_hash_table[hashcode % RTL_HASH_SIZE];
528 attr_hash_table[hashcode % RTL_HASH_SIZE] = h;
531 /* Generate an RTL expression, but avoid duplicates.
532 Set the RTX_INTEGRATED_P flag for these permanent objects.
534 In some cases we cannot uniquify; then we return an ordinary
535 impermanent rtx with RTX_INTEGRATED_P clear.
537 Args are like gen_rtx, but without the mode:
539 rtx attr_rtx (code, [element1, ..., elementn]) */
542 attr_rtx VPARAMS ((enum rtx_code code, ...))
544 #ifndef ANSI_PROTOTYPES
548 register int i; /* Array indices... */
549 register const char *fmt; /* Current rtx's format... */
550 register rtx rt_val = NULL_RTX;/* RTX to return to caller... */
552 register struct attr_hash *h;
553 struct obstack *old_obstack = rtl_obstack;
557 #ifndef ANSI_PROTOTYPES
558 code = va_arg (p, enum rtx_code);
561 /* For each of several cases, search the hash table for an existing entry.
562 Use that entry if one is found; otherwise create a new RTL and add it
565 if (GET_RTX_CLASS (code) == '1')
567 rtx arg0 = va_arg (p, rtx);
569 /* A permanent object cannot point to impermanent ones. */
570 if (! RTX_INTEGRATED_P (arg0))
572 rt_val = rtx_alloc (code);
573 XEXP (rt_val, 0) = arg0;
578 hashcode = ((HOST_WIDE_INT) code + RTL_HASH (arg0));
579 for (h = attr_hash_table[hashcode % RTL_HASH_SIZE]; h; h = h->next)
580 if (h->hashcode == hashcode
581 && GET_CODE (h->u.rtl) == code
582 && XEXP (h->u.rtl, 0) == arg0)
587 rtl_obstack = hash_obstack;
588 rt_val = rtx_alloc (code);
589 XEXP (rt_val, 0) = arg0;
592 else if (GET_RTX_CLASS (code) == 'c'
593 || GET_RTX_CLASS (code) == '2'
594 || GET_RTX_CLASS (code) == '<')
596 rtx arg0 = va_arg (p, rtx);
597 rtx arg1 = va_arg (p, rtx);
599 /* A permanent object cannot point to impermanent ones. */
600 if (! RTX_INTEGRATED_P (arg0) || ! RTX_INTEGRATED_P (arg1))
602 rt_val = rtx_alloc (code);
603 XEXP (rt_val, 0) = arg0;
604 XEXP (rt_val, 1) = arg1;
609 hashcode = ((HOST_WIDE_INT) code + RTL_HASH (arg0) + RTL_HASH (arg1));
610 for (h = attr_hash_table[hashcode % RTL_HASH_SIZE]; h; h = h->next)
611 if (h->hashcode == hashcode
612 && GET_CODE (h->u.rtl) == code
613 && XEXP (h->u.rtl, 0) == arg0
614 && XEXP (h->u.rtl, 1) == arg1)
619 rtl_obstack = hash_obstack;
620 rt_val = rtx_alloc (code);
621 XEXP (rt_val, 0) = arg0;
622 XEXP (rt_val, 1) = arg1;
625 else if (GET_RTX_LENGTH (code) == 1
626 && GET_RTX_FORMAT (code)[0] == 's')
628 char *arg0 = va_arg (p, char *);
630 if (code == SYMBOL_REF)
631 arg0 = attr_string (arg0, strlen (arg0));
633 hashcode = ((HOST_WIDE_INT) code + RTL_HASH (arg0));
634 for (h = attr_hash_table[hashcode % RTL_HASH_SIZE]; h; h = h->next)
635 if (h->hashcode == hashcode
636 && GET_CODE (h->u.rtl) == code
637 && XSTR (h->u.rtl, 0) == arg0)
642 rtl_obstack = hash_obstack;
643 rt_val = rtx_alloc (code);
644 XSTR (rt_val, 0) = arg0;
647 else if (GET_RTX_LENGTH (code) == 2
648 && GET_RTX_FORMAT (code)[0] == 's'
649 && GET_RTX_FORMAT (code)[1] == 's')
651 char *arg0 = va_arg (p, char *);
652 char *arg1 = va_arg (p, char *);
654 hashcode = ((HOST_WIDE_INT) code + RTL_HASH (arg0) + RTL_HASH (arg1));
655 for (h = attr_hash_table[hashcode % RTL_HASH_SIZE]; h; h = h->next)
656 if (h->hashcode == hashcode
657 && GET_CODE (h->u.rtl) == code
658 && XSTR (h->u.rtl, 0) == arg0
659 && XSTR (h->u.rtl, 1) == arg1)
664 rtl_obstack = hash_obstack;
665 rt_val = rtx_alloc (code);
666 XSTR (rt_val, 0) = arg0;
667 XSTR (rt_val, 1) = arg1;
670 else if (code == CONST_INT)
672 HOST_WIDE_INT arg0 = va_arg (p, HOST_WIDE_INT);
688 rt_val = rtx_alloc (code); /* Allocate the storage space. */
690 fmt = GET_RTX_FORMAT (code); /* Find the right format... */
691 for (i = 0; i < GET_RTX_LENGTH (code); i++)
695 case '0': /* Unused field. */
698 case 'i': /* An integer? */
699 XINT (rt_val, i) = va_arg (p, int);
702 case 'w': /* A wide integer? */
703 XWINT (rt_val, i) = va_arg (p, HOST_WIDE_INT);
706 case 's': /* A string? */
707 XSTR (rt_val, i) = va_arg (p, char *);
710 case 'e': /* An expression? */
711 case 'u': /* An insn? Same except when printing. */
712 XEXP (rt_val, i) = va_arg (p, rtx);
715 case 'E': /* An RTX vector? */
716 XVEC (rt_val, i) = va_arg (p, rtvec);
727 rtl_obstack = old_obstack;
729 attr_hash_add_rtx (hashcode, rt_val);
730 RTX_INTEGRATED_P (rt_val) = 1;
738 /* Create a new string printed with the printf line arguments into a space
739 of at most LEN bytes:
741 rtx attr_printf (len, format, [arg1, ..., argn]) */
744 attr_printf VPARAMS ((register int len, const char *fmt, ...))
746 #ifndef ANSI_PROTOTYPES
755 #ifndef ANSI_PROTOTYPES
756 len = va_arg (p, int);
757 fmt = va_arg (p, const char *);
760 /* Print the string into a temporary location. */
761 str = (char *) alloca (len);
762 vsprintf (str, fmt, p);
765 return attr_string (str, strlen (str));
769 attr_eq (name, value)
770 const char *name, *value;
772 return attr_rtx (EQ_ATTR, attr_string (name, strlen (name)),
773 attr_string (value, strlen (value)));
780 return XSTR (make_numeric_value (n), 0);
783 /* Return a permanent (possibly shared) copy of a string STR (not assumed
784 to be null terminated) with LEN bytes. */
787 attr_string (str, len)
791 register struct attr_hash *h;
794 register char *new_str;
796 /* Compute the hash code. */
797 hashcode = (len + 1) * 613 + (unsigned) str[0];
798 for (i = 1; i <= len; i += 2)
799 hashcode = ((hashcode * 613) + (unsigned) str[i]);
801 hashcode = -hashcode;
803 /* Search the table for the string. */
804 for (h = attr_hash_table[hashcode % RTL_HASH_SIZE]; h; h = h->next)
805 if (h->hashcode == -hashcode && h->u.str[0] == str[0]
806 && !strncmp (h->u.str, str, len))
807 return h->u.str; /* <-- return if found. */
809 /* Not found; create a permanent copy and add it to the hash table. */
810 new_str = (char *) obstack_alloc (hash_obstack, len + 1);
811 bcopy (str, new_str, len);
813 attr_hash_add_string (hashcode, new_str);
815 return new_str; /* Return the new string. */
818 /* Check two rtx's for equality of contents,
819 taking advantage of the fact that if both are hashed
820 then they can't be equal unless they are the same object. */
826 return (x == y || (! (RTX_INTEGRATED_P (x) && RTX_INTEGRATED_P (y))
827 && rtx_equal_p (x, y)));
830 /* Copy an attribute value expression,
831 descending to all depths, but not copying any
832 permanent hashed subexpressions. */
840 register RTX_CODE code;
841 register const char *format_ptr;
843 /* No need to copy a permanent object. */
844 if (RTX_INTEGRATED_P (orig))
847 code = GET_CODE (orig);
865 copy = rtx_alloc (code);
866 PUT_MODE (copy, GET_MODE (orig));
867 copy->in_struct = orig->in_struct;
868 copy->volatil = orig->volatil;
869 copy->unchanging = orig->unchanging;
870 copy->integrated = orig->integrated;
872 format_ptr = GET_RTX_FORMAT (GET_CODE (copy));
874 for (i = 0; i < GET_RTX_LENGTH (GET_CODE (copy)); i++)
876 switch (*format_ptr++)
879 XEXP (copy, i) = XEXP (orig, i);
880 if (XEXP (orig, i) != NULL)
881 XEXP (copy, i) = attr_copy_rtx (XEXP (orig, i));
886 XVEC (copy, i) = XVEC (orig, i);
887 if (XVEC (orig, i) != NULL)
889 XVEC (copy, i) = rtvec_alloc (XVECLEN (orig, i));
890 for (j = 0; j < XVECLEN (copy, i); j++)
891 XVECEXP (copy, i, j) = attr_copy_rtx (XVECEXP (orig, i, j));
897 XINT (copy, i) = XINT (orig, i);
901 XWINT (copy, i) = XWINT (orig, i);
906 XSTR (copy, i) = XSTR (orig, i);
916 /* Given a test expression for an attribute, ensure it is validly formed.
917 IS_CONST indicates whether the expression is constant for each compiler
918 run (a constant expression may not test any particular insn).
920 Convert (eq_attr "att" "a1,a2") to (ior (eq_attr ... ) (eq_attrq ..))
921 and (eq_attr "att" "!a1") to (not (eq_attr "att" "a1")). Do the latter
922 test first so that (eq_attr "att" "!a1,a2,a3") works as expected.
924 Update the string address in EQ_ATTR expression to be the same used
925 in the attribute (or `alternative_name') to speed up subsequent
926 `find_attr' calls and eliminate most `strcmp' calls.
928 Return the new expression, if any. */
931 check_attr_test (exp, is_const, lineno)
936 struct attr_desc *attr;
937 struct attr_value *av;
938 const char *name_ptr, *p;
941 switch (GET_CODE (exp))
944 /* Handle negation test. */
945 if (XSTR (exp, 1)[0] == '!')
946 return check_attr_test (attr_rtx (NOT,
947 attr_eq (XSTR (exp, 0),
951 else if (n_comma_elts (XSTR (exp, 1)) == 1)
953 attr = find_attr (XSTR (exp, 0), 0);
956 if (! strcmp (XSTR (exp, 0), "alternative"))
958 XSTR (exp, 0) = alternative_name;
959 /* This can't be simplified any further. */
960 RTX_UNCHANGING_P (exp) = 1;
964 fatal ("Unknown attribute `%s' in EQ_ATTR", XSTR (exp, 0));
967 if (is_const && ! attr->is_const)
968 fatal ("Constant expression uses insn attribute `%s' in EQ_ATTR",
971 /* Copy this just to make it permanent,
972 so expressions using it can be permanent too. */
973 exp = attr_eq (XSTR (exp, 0), XSTR (exp, 1));
975 /* It shouldn't be possible to simplify the value given to a
976 constant attribute, so don't expand this until it's time to
977 write the test expression. */
979 RTX_UNCHANGING_P (exp) = 1;
981 if (attr->is_numeric)
983 for (p = XSTR (exp, 1); *p; p++)
984 if (*p < '0' || *p > '9')
985 fatal ("Attribute `%s' takes only numeric values",
990 for (av = attr->first_value; av; av = av->next)
991 if (GET_CODE (av->value) == CONST_STRING
992 && ! strcmp (XSTR (exp, 1), XSTR (av->value, 0)))
996 fatal ("Unknown value `%s' for `%s' attribute",
997 XSTR (exp, 1), XSTR (exp, 0));
1002 /* Make an IOR tree of the possible values. */
1004 name_ptr = XSTR (exp, 1);
1005 while ((p = next_comma_elt (&name_ptr)) != NULL)
1007 newexp = attr_eq (XSTR (exp, 0), p);
1008 orexp = insert_right_side (IOR, orexp, newexp, -2, -2);
1011 return check_attr_test (orexp, is_const, lineno);
1019 /* Either TRUE or FALSE. */
1027 XEXP (exp, 0) = check_attr_test (XEXP (exp, 0), is_const, lineno);
1028 XEXP (exp, 1) = check_attr_test (XEXP (exp, 1), is_const, lineno);
1032 XEXP (exp, 0) = check_attr_test (XEXP (exp, 0), is_const, lineno);
1038 fatal ("RTL operator \"%s\" not valid in constant attribute test",
1039 GET_RTX_NAME (GET_CODE (exp)));
1040 /* These cases can't be simplified. */
1041 RTX_UNCHANGING_P (exp) = 1;
1044 case LE: case LT: case GT: case GE:
1045 case LEU: case LTU: case GTU: case GEU:
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;
1059 /* These cases are valid for constant attributes, but can't be
1061 exp = attr_rtx (SYMBOL_REF, XSTR (exp, 0));
1062 RTX_UNCHANGING_P (exp) = 1;
1066 fatal ("RTL operator \"%s\" not valid in attribute test",
1067 GET_RTX_NAME (GET_CODE (exp)));
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.
1077 Return a perhaps modified replacement expression for the value. */
1080 check_attr_value (exp, attr)
1082 struct attr_desc *attr;
1084 struct attr_value *av;
1088 switch (GET_CODE (exp))
1091 if (attr && ! attr->is_numeric)
1093 message_with_line (attr->lineno,
1094 "CONST_INT not valid for non-numeric attribute %s",
1100 if (INTVAL (exp) < 0 && ! attr->negative_ok)
1102 message_with_line (attr->lineno,
1103 "negative numeric value specified for attribute %s",
1111 if (! strcmp (XSTR (exp, 0), "*"))
1114 if (attr == 0 || attr->is_numeric)
1117 if (attr && attr->negative_ok && *p == '-')
1120 if (*p > '9' || *p < '0')
1122 message_with_line (attr ? attr->lineno : 0,
1123 "non-numeric value for numeric attribute %s",
1124 attr ? attr->name : "internal");
1131 for (av = attr->first_value; av; av = av->next)
1132 if (GET_CODE (av->value) == CONST_STRING
1133 && ! strcmp (XSTR (av->value, 0), XSTR (exp, 0)))
1138 message_with_line (attr->lineno,
1139 "unknown value `%s' for `%s' attribute",
1140 XSTR (exp, 0), attr ? attr->name : "internal");
1146 XEXP (exp, 0) = check_attr_test (XEXP (exp, 0),
1147 attr ? attr->is_const : 0,
1148 attr ? attr->lineno : 0);
1149 XEXP (exp, 1) = check_attr_value (XEXP (exp, 1), attr);
1150 XEXP (exp, 2) = check_attr_value (XEXP (exp, 2), attr);
1158 if (attr && !attr->is_numeric)
1160 message_with_line (attr->lineno,
1161 "invalid operation `%s' for non-numeric attribute value",
1162 GET_RTX_NAME (GET_CODE (exp)));
1170 XEXP (exp, 0) = check_attr_value (XEXP (exp, 0), attr);
1171 XEXP (exp, 1) = check_attr_value (XEXP (exp, 1), attr);
1175 XEXP (exp, 0) = check_attr_value (XEXP (exp, 0), attr);
1179 if (XVECLEN (exp, 0) % 2 != 0)
1181 message_with_line (attr->lineno,
1182 "first operand of COND must have even length");
1187 for (i = 0; i < XVECLEN (exp, 0); i += 2)
1189 XVECEXP (exp, 0, i) = check_attr_test (XVECEXP (exp, 0, i),
1190 attr ? attr->is_const : 0,
1191 attr ? attr->lineno : 0);
1192 XVECEXP (exp, 0, i + 1)
1193 = check_attr_value (XVECEXP (exp, 0, i + 1), attr);
1196 XEXP (exp, 1) = check_attr_value (XEXP (exp, 1), attr);
1201 struct attr_desc *attr2 = find_attr (XSTR (exp, 0), 0);
1204 message_with_line (attr ? attr->lineno : 0,
1205 "unknown attribute `%s' in ATTR",
1209 else if (attr && attr->is_const && ! attr2->is_const)
1211 message_with_line (attr->lineno,
1212 "non-constant attribute `%s' referenced from `%s'",
1213 XSTR (exp, 0), attr->name);
1217 && (attr->is_numeric != attr2->is_numeric
1218 || (! attr->negative_ok && attr2->negative_ok)))
1220 message_with_line (attr->lineno,
1221 "numeric attribute mismatch calling `%s' from `%s'",
1222 XSTR (exp, 0), attr->name);
1229 /* A constant SYMBOL_REF is valid as a constant attribute test and
1230 is expanded later by make_canonical into a COND. In a non-constant
1231 attribute test, it is left be. */
1232 return attr_rtx (SYMBOL_REF, XSTR (exp, 0));
1235 message_with_line (attr ? attr->lineno : 0,
1236 "invalid operation `%s' for attribute value",
1237 GET_RTX_NAME (GET_CODE (exp)));
1245 /* Given an SET_ATTR_ALTERNATIVE expression, convert to the canonical SET.
1246 It becomes a COND with each test being (eq_attr "alternative "n") */
1249 convert_set_attr_alternative (exp, id)
1251 struct insn_def *id;
1253 int num_alt = id->num_alternatives;
1257 if (XVECLEN (exp, 1) != num_alt)
1259 message_with_line (id->lineno,
1260 "bad number of entries in SET_ATTR_ALTERNATIVE");
1265 /* Make a COND with all tests but the last. Select the last value via the
1267 condexp = rtx_alloc (COND);
1268 XVEC (condexp, 0) = rtvec_alloc ((num_alt - 1) * 2);
1270 for (i = 0; i < num_alt - 1; i++)
1273 p = attr_numeral (i);
1275 XVECEXP (condexp, 0, 2 * i) = attr_eq (alternative_name, p);
1276 XVECEXP (condexp, 0, 2 * i + 1) = XVECEXP (exp, 1, i);
1279 XEXP (condexp, 1) = XVECEXP (exp, 1, i);
1281 return attr_rtx (SET, attr_rtx (ATTR, XSTR (exp, 0)), condexp);
1284 /* Given a SET_ATTR, convert to the appropriate SET. If a comma-separated
1285 list of values is given, convert to SET_ATTR_ALTERNATIVE first. */
1288 convert_set_attr (exp, id)
1290 struct insn_def *id;
1293 const char *name_ptr;
1297 /* See how many alternative specified. */
1298 n = n_comma_elts (XSTR (exp, 1));
1300 return attr_rtx (SET,
1301 attr_rtx (ATTR, XSTR (exp, 0)),
1302 attr_rtx (CONST_STRING, XSTR (exp, 1)));
1304 newexp = rtx_alloc (SET_ATTR_ALTERNATIVE);
1305 XSTR (newexp, 0) = XSTR (exp, 0);
1306 XVEC (newexp, 1) = rtvec_alloc (n);
1308 /* Process each comma-separated name. */
1309 name_ptr = XSTR (exp, 1);
1311 while ((p = next_comma_elt (&name_ptr)) != NULL)
1312 XVECEXP (newexp, 1, n++) = attr_rtx (CONST_STRING, p);
1314 return convert_set_attr_alternative (newexp, id);
1317 /* Scan all definitions, checking for validity. Also, convert any SET_ATTR
1318 and SET_ATTR_ALTERNATIVE expressions to the corresponding SET
1324 struct insn_def *id;
1325 struct attr_desc *attr;
1329 for (id = defs; id; id = id->next)
1331 if (XVEC (id->def, id->vec_idx) == NULL)
1334 for (i = 0; i < XVECLEN (id->def, id->vec_idx); i++)
1336 value = XVECEXP (id->def, id->vec_idx, i);
1337 switch (GET_CODE (value))
1340 if (GET_CODE (XEXP (value, 0)) != ATTR)
1342 message_with_line (id->lineno, "bad attribute set");
1348 case SET_ATTR_ALTERNATIVE:
1349 value = convert_set_attr_alternative (value, id);
1353 value = convert_set_attr (value, id);
1357 message_with_line (id->lineno, "invalid attribute code %s",
1358 GET_RTX_NAME (GET_CODE (value)));
1362 if (value == NULL_RTX)
1365 if ((attr = find_attr (XSTR (XEXP (value, 0), 0), 0)) == NULL)
1367 message_with_line (id->lineno, "unknown attribute %s",
1368 XSTR (XEXP (value, 0), 0));
1373 XVECEXP (id->def, id->vec_idx, i) = value;
1374 XEXP (value, 1) = check_attr_value (XEXP (value, 1), attr);
1380 /* Given a constant SYMBOL_REF expression, convert to a COND that
1381 explicitly tests each enumerated value. */
1384 convert_const_symbol_ref (exp, attr)
1386 struct attr_desc *attr;
1389 struct attr_value *av;
1393 for (av = attr->first_value; av; av = av->next)
1396 /* Make a COND with all tests but the last, and in the original order.
1397 Select the last value via the default. Note that the attr values
1398 are constructed in reverse order. */
1400 condexp = rtx_alloc (COND);
1401 XVEC (condexp, 0) = rtvec_alloc ((num_alt - 1) * 2);
1402 av = attr->first_value;
1403 XEXP (condexp, 1) = av->value;
1405 for (i = num_alt - 2; av = av->next, i >= 0; i--)
1410 string = p = (char *) oballoc (2
1411 + strlen (attr->name)
1412 + strlen (XSTR (av->value, 0)));
1413 strcpy (p, attr->name);
1415 strcat (p, XSTR (av->value, 0));
1416 for (; *p != '\0'; p++)
1419 value = attr_rtx (SYMBOL_REF, string);
1420 RTX_UNCHANGING_P (value) = 1;
1422 XVECEXP (condexp, 0, 2 * i) = attr_rtx (EQ, exp, value);
1424 XVECEXP (condexp, 0, 2 * i + 1) = av->value;
1431 /* Given a valid expression for an attribute value, remove any IF_THEN_ELSE
1432 expressions by converting them into a COND. This removes cases from this
1433 program. Also, replace an attribute value of "*" with the default attribute
1437 make_canonical (attr, exp)
1438 struct attr_desc *attr;
1444 switch (GET_CODE (exp))
1447 exp = make_numeric_value (INTVAL (exp));
1451 if (! strcmp (XSTR (exp, 0), "*"))
1453 if (attr == 0 || attr->default_val == 0)
1454 fatal ("(attr_value \"*\") used in invalid context.");
1455 exp = attr->default_val->value;
1461 if (!attr->is_const || RTX_UNCHANGING_P (exp))
1463 /* The SYMBOL_REF is constant for a given run, so mark it as unchanging.
1464 This makes the COND something that won't be considered an arbitrary
1465 expression by walk_attr_value. */
1466 RTX_UNCHANGING_P (exp) = 1;
1468 /* ??? Why do we do this? With attribute values { A B C D E }, this
1469 tends to generate (!(x==A) && !(x==B) && !(x==C) && !(x==D)) rather
1471 exp = convert_const_symbol_ref (exp, attr);
1472 RTX_UNCHANGING_P (exp) = 1;
1473 exp = check_attr_value (exp, attr);
1474 /* Goto COND case since this is now a COND. Note that while the
1475 new expression is rescanned, all symbol_ref notes are marked as
1479 exp = check_attr_value (exp, attr);
1484 newexp = rtx_alloc (COND);
1485 XVEC (newexp, 0) = rtvec_alloc (2);
1486 XVECEXP (newexp, 0, 0) = XEXP (exp, 0);
1487 XVECEXP (newexp, 0, 1) = XEXP (exp, 1);
1489 XEXP (newexp, 1) = XEXP (exp, 2);
1492 /* Fall through to COND case since this is now a COND. */
1499 /* First, check for degenerate COND. */
1500 if (XVECLEN (exp, 0) == 0)
1501 return make_canonical (attr, XEXP (exp, 1));
1502 defval = XEXP (exp, 1) = make_canonical (attr, XEXP (exp, 1));
1504 for (i = 0; i < XVECLEN (exp, 0); i += 2)
1506 XVECEXP (exp, 0, i) = copy_boolean (XVECEXP (exp, 0, i));
1507 XVECEXP (exp, 0, i + 1)
1508 = make_canonical (attr, XVECEXP (exp, 0, i + 1));
1509 if (! rtx_equal_p (XVECEXP (exp, 0, i + 1), defval))
1528 if (GET_CODE (exp) == AND || GET_CODE (exp) == IOR)
1529 return attr_rtx (GET_CODE (exp), copy_boolean (XEXP (exp, 0)),
1530 copy_boolean (XEXP (exp, 1)));
1534 /* Given a value and an attribute description, return a `struct attr_value *'
1535 that represents that value. This is either an existing structure, if the
1536 value has been previously encountered, or a newly-created structure.
1538 `insn_code' is the code of an insn whose attribute has the specified
1539 value (-2 if not processing an insn). We ensure that all insns for
1540 a given value have the same number of alternatives if the value checks
1543 static struct attr_value *
1544 get_attr_value (value, attr, insn_code)
1546 struct attr_desc *attr;
1549 struct attr_value *av;
1552 value = make_canonical (attr, value);
1553 if (compares_alternatives_p (value))
1555 if (insn_code < 0 || insn_alternatives == NULL)
1556 fatal ("(eq_attr \"alternatives\" ...) used in non-insn context");
1558 num_alt = insn_alternatives[insn_code];
1561 for (av = attr->first_value; av; av = av->next)
1562 if (rtx_equal_p (value, av->value)
1563 && (num_alt == 0 || av->first_insn == NULL
1564 || insn_alternatives[av->first_insn->insn_code]))
1567 av = (struct attr_value *) oballoc (sizeof (struct attr_value));
1569 av->next = attr->first_value;
1570 attr->first_value = av;
1571 av->first_insn = NULL;
1573 av->has_asm_insn = 0;
1578 /* After all DEFINE_DELAYs have been read in, create internal attributes
1579 to generate the required routines.
1581 First, we compute the number of delay slots for each insn (as a COND of
1582 each of the test expressions in DEFINE_DELAYs). Then, if more than one
1583 delay type is specified, we compute a similar function giving the
1584 DEFINE_DELAY ordinal for each insn.
1586 Finally, for each [DEFINE_DELAY, slot #] pair, we compute an attribute that
1587 tells whether a given insn can be in that delay slot.
1589 Normal attribute filling and optimization expands these to contain the
1590 information needed to handle delay slots. */
1595 struct delay_desc *delay;
1601 /* First, generate data for `num_delay_slots' function. */
1603 condexp = rtx_alloc (COND);
1604 XVEC (condexp, 0) = rtvec_alloc (num_delays * 2);
1605 XEXP (condexp, 1) = make_numeric_value (0);
1607 for (i = 0, delay = delays; delay; i += 2, delay = delay->next)
1609 XVECEXP (condexp, 0, i) = XEXP (delay->def, 0);
1610 XVECEXP (condexp, 0, i + 1)
1611 = make_numeric_value (XVECLEN (delay->def, 1) / 3);
1614 make_internal_attr ("*num_delay_slots", condexp, 0);
1616 /* If more than one delay type, do the same for computing the delay type. */
1619 condexp = rtx_alloc (COND);
1620 XVEC (condexp, 0) = rtvec_alloc (num_delays * 2);
1621 XEXP (condexp, 1) = make_numeric_value (0);
1623 for (i = 0, delay = delays; delay; i += 2, delay = delay->next)
1625 XVECEXP (condexp, 0, i) = XEXP (delay->def, 0);
1626 XVECEXP (condexp, 0, i + 1) = make_numeric_value (delay->num);
1629 make_internal_attr ("*delay_type", condexp, 1);
1632 /* For each delay possibility and delay slot, compute an eligibility
1633 attribute for non-annulled insns and for each type of annulled (annul
1634 if true and annul if false). */
1635 for (delay = delays; delay; delay = delay->next)
1637 for (i = 0; i < XVECLEN (delay->def, 1); i += 3)
1639 condexp = XVECEXP (delay->def, 1, i);
1641 condexp = false_rtx;
1642 newexp = attr_rtx (IF_THEN_ELSE, condexp,
1643 make_numeric_value (1), make_numeric_value (0));
1645 p = attr_printf (sizeof ("*delay__") + MAX_DIGITS * 2,
1648 make_internal_attr (p, newexp, 1);
1650 if (have_annul_true)
1652 condexp = XVECEXP (delay->def, 1, i + 1);
1653 if (condexp == 0) condexp = false_rtx;
1654 newexp = attr_rtx (IF_THEN_ELSE, condexp,
1655 make_numeric_value (1),
1656 make_numeric_value (0));
1657 p = attr_printf (sizeof ("*annul_true__") + MAX_DIGITS * 2,
1658 "*annul_true_%d_%d", delay->num, i / 3);
1659 make_internal_attr (p, newexp, 1);
1662 if (have_annul_false)
1664 condexp = XVECEXP (delay->def, 1, i + 2);
1665 if (condexp == 0) condexp = false_rtx;
1666 newexp = attr_rtx (IF_THEN_ELSE, condexp,
1667 make_numeric_value (1),
1668 make_numeric_value (0));
1669 p = attr_printf (sizeof ("*annul_false__") + MAX_DIGITS * 2,
1670 "*annul_false_%d_%d", delay->num, i / 3);
1671 make_internal_attr (p, newexp, 1);
1677 /* This function is given a left and right side expression and an operator.
1678 Each side is a conditional expression, each alternative of which has a
1679 numerical value. The function returns another conditional expression
1680 which, for every possible set of condition values, returns a value that is
1681 the operator applied to the values of the two sides.
1683 Since this is called early, it must also support IF_THEN_ELSE. */
1686 operate_exp (op, left, right)
1690 int left_value, right_value;
1694 /* If left is a string, apply operator to it and the right side. */
1695 if (GET_CODE (left) == CONST_STRING)
1697 /* If right is also a string, just perform the operation. */
1698 if (GET_CODE (right) == CONST_STRING)
1700 left_value = atoi (XSTR (left, 0));
1701 right_value = atoi (XSTR (right, 0));
1705 i = left_value + right_value;
1709 i = left_value - right_value;
1712 case POS_MINUS_OP: /* The positive part of LEFT - RIGHT. */
1713 if (left_value > right_value)
1714 i = left_value - right_value;
1721 i = left_value | right_value;
1725 i = left_value == right_value;
1729 i = (left_value << (HOST_BITS_PER_INT / 2)) | right_value;
1733 if (left_value > right_value)
1740 if (left_value < right_value)
1750 if (i == left_value)
1752 if (i == right_value)
1754 return make_numeric_value (i);
1756 else if (GET_CODE (right) == IF_THEN_ELSE)
1758 /* Apply recursively to all values within. */
1759 rtx newleft = operate_exp (op, left, XEXP (right, 1));
1760 rtx newright = operate_exp (op, left, XEXP (right, 2));
1761 if (rtx_equal_p (newleft, newright))
1763 return attr_rtx (IF_THEN_ELSE, XEXP (right, 0), newleft, newright);
1765 else if (GET_CODE (right) == COND)
1770 newexp = rtx_alloc (COND);
1771 XVEC (newexp, 0) = rtvec_alloc (XVECLEN (right, 0));
1772 defval = XEXP (newexp, 1) = operate_exp (op, left, XEXP (right, 1));
1774 for (i = 0; i < XVECLEN (right, 0); i += 2)
1776 XVECEXP (newexp, 0, i) = XVECEXP (right, 0, i);
1777 XVECEXP (newexp, 0, i + 1)
1778 = operate_exp (op, left, XVECEXP (right, 0, i + 1));
1779 if (! rtx_equal_p (XVECEXP (newexp, 0, i + 1),
1784 /* If the resulting cond is trivial (all alternatives
1785 give the same value), optimize it away. */
1789 obstack_free (rtl_obstack, newexp);
1790 return operate_exp (op, left, XEXP (right, 1));
1793 /* If the result is the same as the RIGHT operand,
1795 if (rtx_equal_p (newexp, right))
1798 obstack_free (rtl_obstack, newexp);
1805 fatal ("Badly formed attribute value");
1808 /* A hack to prevent expand_units from completely blowing up: ORX_OP does
1809 not associate through IF_THEN_ELSE. */
1810 else if (op == ORX_OP && GET_CODE (right) == IF_THEN_ELSE)
1812 return attr_rtx (IOR, left, right);
1815 /* Otherwise, do recursion the other way. */
1816 else if (GET_CODE (left) == IF_THEN_ELSE)
1818 rtx newleft = operate_exp (op, XEXP (left, 1), right);
1819 rtx newright = operate_exp (op, XEXP (left, 2), right);
1820 if (rtx_equal_p (newleft, newright))
1822 return attr_rtx (IF_THEN_ELSE, XEXP (left, 0), newleft, newright);
1824 else if (GET_CODE (left) == COND)
1829 newexp = rtx_alloc (COND);
1830 XVEC (newexp, 0) = rtvec_alloc (XVECLEN (left, 0));
1831 defval = XEXP (newexp, 1) = operate_exp (op, XEXP (left, 1), right);
1833 for (i = 0; i < XVECLEN (left, 0); i += 2)
1835 XVECEXP (newexp, 0, i) = XVECEXP (left, 0, i);
1836 XVECEXP (newexp, 0, i + 1)
1837 = operate_exp (op, XVECEXP (left, 0, i + 1), right);
1838 if (! rtx_equal_p (XVECEXP (newexp, 0, i + 1),
1843 /* If the cond is trivial (all alternatives give the same value),
1844 optimize it away. */
1848 obstack_free (rtl_obstack, newexp);
1849 return operate_exp (op, XEXP (left, 1), right);
1852 /* If the result is the same as the LEFT operand,
1854 if (rtx_equal_p (newexp, left))
1857 obstack_free (rtl_obstack, newexp);
1865 fatal ("Badly formed attribute value.");
1870 /* Once all attributes and DEFINE_FUNCTION_UNITs have been read, we
1871 construct a number of attributes.
1873 The first produces a function `function_units_used' which is given an
1874 insn and produces an encoding showing which function units are required
1875 for the execution of that insn. If the value is non-negative, the insn
1876 uses that unit; otherwise, the value is a one's compliment mask of units
1879 The second produces a function `result_ready_cost' which is used to
1880 determine the time that the result of an insn will be ready and hence
1881 a worst-case schedule.
1883 Both of these produce quite complex expressions which are then set as the
1884 default value of internal attributes. Normal attribute simplification
1885 should produce reasonable expressions.
1887 For each unit, a `<name>_unit_ready_cost' function will take an
1888 insn and give the delay until that unit will be ready with the result
1889 and a `<name>_unit_conflict_cost' function is given an insn already
1890 executing on the unit and a candidate to execute and will give the
1891 cost from the time the executing insn started until the candidate
1892 can start (ignore limitations on the number of simultaneous insns).
1894 For each unit, a `<name>_unit_blockage' function is given an insn
1895 already executing on the unit and a candidate to execute and will
1896 give the delay incurred due to function unit conflicts. The range of
1897 blockage cost values for a given executing insn is given by the
1898 `<name>_unit_blockage_range' function. These values are encoded in
1899 an int where the upper half gives the minimum value and the lower
1900 half gives the maximum value. */
1905 struct function_unit *unit, **unit_num;
1906 struct function_unit_op *op, **op_array, ***unit_ops;
1911 int i, j, u, num, nvalues;
1913 /* Rebuild the condition for the unit to share the RTL expressions.
1914 Sharing is required by simplify_by_exploding. Build the issue delay
1915 expressions. Validate the expressions we were given for the conditions
1916 and conflict vector. Then make attributes for use in the conflict
1919 for (unit = units; unit; unit = unit->next)
1921 unit->condexp = check_attr_test (unit->condexp, 0, unit->first_lineno);
1923 for (op = unit->ops; op; op = op->next)
1925 rtx issue_delay = make_numeric_value (op->issue_delay);
1926 rtx issue_exp = issue_delay;
1928 /* Build, validate, and simplify the issue delay expression. */
1929 if (op->conflict_exp != true_rtx)
1930 issue_exp = attr_rtx (IF_THEN_ELSE, op->conflict_exp,
1931 issue_exp, make_numeric_value (0));
1932 issue_exp = check_attr_value (make_canonical (NULL_ATTR,
1935 issue_exp = simplify_knowing (issue_exp, unit->condexp);
1936 op->issue_exp = issue_exp;
1938 /* Make an attribute for use in the conflict function if needed. */
1939 unit->needs_conflict_function = (unit->issue_delay.min
1940 != unit->issue_delay.max);
1941 if (unit->needs_conflict_function)
1943 str = attr_printf (strlen (unit->name) + sizeof ("*_cost_") + MAX_DIGITS,
1944 "*%s_cost_%d", unit->name, op->num);
1945 make_internal_attr (str, issue_exp, 1);
1948 /* Validate the condition. */
1949 op->condexp = check_attr_test (op->condexp, 0, op->lineno);
1953 /* Compute the mask of function units used. Initially, the unitsmask is
1954 zero. Set up a conditional to compute each unit's contribution. */
1955 unitsmask = make_numeric_value (0);
1956 newexp = rtx_alloc (IF_THEN_ELSE);
1957 XEXP (newexp, 2) = make_numeric_value (0);
1959 /* If we have just a few units, we may be all right expanding the whole
1960 thing. But the expansion is 2**N in space on the number of opclasses,
1961 so we can't do this for very long -- Alpha and MIPS in particular have
1962 problems with this. So in that situation, we fall back on an alternate
1963 implementation method. */
1964 #define NUM_UNITOP_CUTOFF 20
1966 if (num_unit_opclasses < NUM_UNITOP_CUTOFF)
1968 /* Merge each function unit into the unit mask attributes. */
1969 for (unit = units; unit; unit = unit->next)
1971 XEXP (newexp, 0) = unit->condexp;
1972 XEXP (newexp, 1) = make_numeric_value (1 << unit->num);
1973 unitsmask = operate_exp (OR_OP, unitsmask, newexp);
1978 /* Merge each function unit into the unit mask attributes. */
1979 for (unit = units; unit; unit = unit->next)
1981 XEXP (newexp, 0) = unit->condexp;
1982 XEXP (newexp, 1) = make_numeric_value (1 << unit->num);
1983 unitsmask = operate_exp (ORX_OP, unitsmask, attr_copy_rtx (newexp));
1987 /* Simplify the unit mask expression, encode it, and make an attribute
1988 for the function_units_used function. */
1989 unitsmask = simplify_by_exploding (unitsmask);
1991 if (num_unit_opclasses < NUM_UNITOP_CUTOFF)
1992 unitsmask = encode_units_mask (unitsmask);
1995 /* We can no longer encode unitsmask at compile time, so emit code to
1996 calculate it at runtime. Rather, put a marker for where we'd do
1997 the code, and actually output it in write_attr_get(). */
1998 unitsmask = attr_rtx (FFS, unitsmask);
2001 make_internal_attr ("*function_units_used", unitsmask, 10);
2003 /* Create an array of ops for each unit. Add an extra unit for the
2004 result_ready_cost function that has the ops of all other units. */
2005 unit_ops = (struct function_unit_op ***)
2006 alloca ((num_units + 1) * sizeof (struct function_unit_op **));
2007 unit_num = (struct function_unit **)
2008 alloca ((num_units + 1) * sizeof (struct function_unit *));
2010 unit_num[num_units] = unit = (struct function_unit *)
2011 alloca (sizeof (struct function_unit));
2012 unit->num = num_units;
2013 unit->num_opclasses = 0;
2015 for (unit = units; unit; unit = unit->next)
2017 unit_num[num_units]->num_opclasses += unit->num_opclasses;
2018 unit_num[unit->num] = unit;
2019 unit_ops[unit->num] = op_array = (struct function_unit_op **)
2020 alloca (unit->num_opclasses * sizeof (struct function_unit_op *));
2022 for (op = unit->ops; op; op = op->next)
2023 op_array[op->num] = op;
2026 /* Compose the array of ops for the extra unit. */
2027 unit_ops[num_units] = op_array = (struct function_unit_op **)
2028 alloca (unit_num[num_units]->num_opclasses
2029 * sizeof (struct function_unit_op *));
2031 for (unit = units, i = 0; unit; i += unit->num_opclasses, unit = unit->next)
2032 bcopy ((char *) unit_ops[unit->num], (char *) &op_array[i],
2033 unit->num_opclasses * sizeof (struct function_unit_op *));
2035 /* Compute the ready cost function for each unit by computing the
2036 condition for each non-default value. */
2037 for (u = 0; u <= num_units; u++)
2043 op_array = unit_ops[unit->num];
2044 num = unit->num_opclasses;
2046 /* Sort the array of ops into increasing ready cost order. */
2047 for (i = 0; i < num; i++)
2048 for (j = num - 1; j > i; j--)
2049 if (op_array[j - 1]->ready < op_array[j]->ready)
2052 op_array[j] = op_array[j - 1];
2053 op_array[j - 1] = op;
2056 /* Determine how many distinct non-default ready cost values there
2057 are. We use a default ready cost value of 1. */
2058 nvalues = 0; value = 1;
2059 for (i = num - 1; i >= 0; i--)
2060 if (op_array[i]->ready > value)
2062 value = op_array[i]->ready;
2067 readycost = make_numeric_value (1);
2070 /* Construct the ready cost expression as a COND of each value from
2071 the largest to the smallest. */
2072 readycost = rtx_alloc (COND);
2073 XVEC (readycost, 0) = rtvec_alloc (nvalues * 2);
2074 XEXP (readycost, 1) = make_numeric_value (1);
2078 value = op_array[0]->ready;
2079 for (i = 0; i < num; i++)
2084 else if (op->ready == value)
2085 orexp = insert_right_side (IOR, orexp, op->condexp, -2, -2);
2088 XVECEXP (readycost, 0, nvalues * 2) = orexp;
2089 XVECEXP (readycost, 0, nvalues * 2 + 1)
2090 = make_numeric_value (value);
2093 orexp = op->condexp;
2096 XVECEXP (readycost, 0, nvalues * 2) = orexp;
2097 XVECEXP (readycost, 0, nvalues * 2 + 1) = make_numeric_value (value);
2102 rtx max_blockage = 0, min_blockage = 0;
2104 /* Simplify the readycost expression by only considering insns
2105 that use the unit. */
2106 readycost = simplify_knowing (readycost, unit->condexp);
2108 /* Determine the blockage cost the executing insn (E) given
2109 the candidate insn (C). This is the maximum of the issue
2110 delay, the pipeline delay, and the simultaneity constraint.
2111 Each function_unit_op represents the characteristics of the
2112 candidate insn, so in the expressions below, C is a known
2113 term and E is an unknown term.
2115 We compute the blockage cost for each E for every possible C.
2116 Thus OP represents E, and READYCOST is a list of values for
2119 The issue delay function for C is op->issue_exp and is used to
2120 write the `<name>_unit_conflict_cost' function. Symbolicly
2121 this is "ISSUE-DELAY (E,C)".
2123 The pipeline delay results form the FIFO constraint on the
2124 function unit and is "READY-COST (E) + 1 - READY-COST (C)".
2126 The simultaneity constraint is based on how long it takes to
2127 fill the unit given the minimum issue delay. FILL-TIME is the
2128 constant "MIN (ISSUE-DELAY (*,*)) * (SIMULTANEITY - 1)", and
2129 the simultaneity constraint is "READY-COST (E) - FILL-TIME"
2130 if SIMULTANEITY is non-zero and zero otherwise.
2132 Thus, BLOCKAGE (E,C) when SIMULTANEITY is zero is
2134 MAX (ISSUE-DELAY (E,C),
2135 READY-COST (E) - (READY-COST (C) - 1))
2139 MAX (ISSUE-DELAY (E,C),
2140 READY-COST (E) - (READY-COST (C) - 1),
2141 READY-COST (E) - FILL-TIME)
2143 The `<name>_unit_blockage' function is computed by determining
2144 this value for each candidate insn. As these values are
2145 computed, we also compute the upper and lower bounds for
2146 BLOCKAGE (E,*). These are combined to form the function
2147 `<name>_unit_blockage_range'. Finally, the maximum blockage
2148 cost, MAX (BLOCKAGE (*,*)), is computed. */
2150 for (op = unit->ops; op; op = op->next)
2152 rtx blockage = op->issue_exp;
2153 blockage = simplify_knowing (blockage, unit->condexp);
2155 /* Add this op's contribution to MAX (BLOCKAGE (E,*)) and
2156 MIN (BLOCKAGE (E,*)). */
2157 if (max_blockage == 0)
2158 max_blockage = min_blockage = blockage;
2162 = simplify_knowing (operate_exp (MAX_OP, max_blockage,
2166 = simplify_knowing (operate_exp (MIN_OP, min_blockage,
2171 /* Make an attribute for use in the blockage function. */
2172 str = attr_printf (strlen (unit->name) + sizeof ("*_block_") + MAX_DIGITS,
2173 "*%s_block_%d", unit->name, op->num);
2174 make_internal_attr (str, blockage, 1);
2177 /* Record MAX (BLOCKAGE (*,*)). */
2180 unit->max_blockage = max_attr_value (max_blockage, &unknown);
2183 /* See if the upper and lower bounds of BLOCKAGE (E,*) are the
2184 same. If so, the blockage function carries no additional
2185 information and is not written. */
2186 newexp = operate_exp (EQ_OP, max_blockage, min_blockage);
2187 newexp = simplify_knowing (newexp, unit->condexp);
2188 unit->needs_blockage_function
2189 = (GET_CODE (newexp) != CONST_STRING
2190 || atoi (XSTR (newexp, 0)) != 1);
2192 /* If the all values of BLOCKAGE (E,C) have the same value,
2193 neither blockage function is written. */
2194 unit->needs_range_function
2195 = (unit->needs_blockage_function
2196 || GET_CODE (max_blockage) != CONST_STRING);
2198 if (unit->needs_range_function)
2200 /* Compute the blockage range function and make an attribute
2201 for writing its value. */
2202 newexp = operate_exp (RANGE_OP, min_blockage, max_blockage);
2203 newexp = simplify_knowing (newexp, unit->condexp);
2205 str = attr_printf (strlen (unit->name) + sizeof ("*_unit_blockage_range"),
2206 "*%s_unit_blockage_range", unit->name);
2207 make_internal_attr (str, newexp, 20);
2210 str = attr_printf (strlen (unit->name) + sizeof ("*_unit_ready_cost"),
2211 "*%s_unit_ready_cost", unit->name);
2214 str = "*result_ready_cost";
2216 /* Make an attribute for the ready_cost function. Simplifying
2217 further with simplify_by_exploding doesn't win. */
2218 make_internal_attr (str, readycost, 0);
2221 /* For each unit that requires a conflict cost function, make an attribute
2222 that maps insns to the operation number. */
2223 for (unit = units; unit; unit = unit->next)
2227 if (! unit->needs_conflict_function
2228 && ! unit->needs_blockage_function)
2231 caseexp = rtx_alloc (COND);
2232 XVEC (caseexp, 0) = rtvec_alloc ((unit->num_opclasses - 1) * 2);
2234 for (op = unit->ops; op; op = op->next)
2236 /* Make our adjustment to the COND being computed. If we are the
2237 last operation class, place our values into the default of the
2239 if (op->num == unit->num_opclasses - 1)
2241 XEXP (caseexp, 1) = make_numeric_value (op->num);
2245 XVECEXP (caseexp, 0, op->num * 2) = op->condexp;
2246 XVECEXP (caseexp, 0, op->num * 2 + 1)
2247 = make_numeric_value (op->num);
2251 /* Simplifying caseexp with simplify_by_exploding doesn't win. */
2252 str = attr_printf (strlen (unit->name) + sizeof ("*_cases"),
2253 "*%s_cases", unit->name);
2254 make_internal_attr (str, caseexp, 1);
2258 /* Simplify EXP given KNOWN_TRUE. */
2261 simplify_knowing (exp, known_true)
2262 rtx exp, known_true;
2264 if (GET_CODE (exp) != CONST_STRING)
2266 int unknown = 0, max;
2267 max = max_attr_value (exp, &unknown);
2270 exp = attr_rtx (IF_THEN_ELSE, known_true, exp,
2271 make_numeric_value (max));
2272 exp = simplify_by_exploding (exp);
2278 /* Translate the CONST_STRING expressions in X to change the encoding of
2279 value. On input, the value is a bitmask with a one bit for each unit
2280 used; on output, the value is the unit number (zero based) if one
2281 and only one unit is used or the one's compliment of the bitmask. */
2284 encode_units_mask (x)
2289 register enum rtx_code code;
2290 register const char *fmt;
2292 code = GET_CODE (x);
2297 i = atoi (XSTR (x, 0));
2299 /* The sign bit encodes a one's compliment mask. */
2301 else if (i != 0 && i == (i & -i))
2302 /* Only one bit is set, so yield that unit number. */
2303 for (j = 0; (i >>= 1) != 0; j++)
2307 return attr_rtx (CONST_STRING, attr_printf (MAX_DIGITS, "%d", j));
2324 /* Compare the elements. If any pair of corresponding elements
2325 fail to match, return 0 for the whole things. */
2327 fmt = GET_RTX_FORMAT (code);
2328 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
2334 for (j = 0; j < XVECLEN (x, i); j++)
2335 XVECEXP (x, i, j) = encode_units_mask (XVECEXP (x, i, j));
2339 XEXP (x, i) = encode_units_mask (XEXP (x, i));
2346 /* Once all attributes and insns have been read and checked, we construct for
2347 each attribute value a list of all the insns that have that value for
2352 struct attr_desc *attr;
2354 struct attr_value *av;
2355 struct insn_ent *ie;
2356 struct insn_def *id;
2360 /* Don't fill constant attributes. The value is independent of
2361 any particular insn. */
2365 for (id = defs; id; id = id->next)
2367 /* If no value is specified for this insn for this attribute, use the
2370 if (XVEC (id->def, id->vec_idx))
2371 for (i = 0; i < XVECLEN (id->def, id->vec_idx); i++)
2372 if (! strcmp (XSTR (XEXP (XVECEXP (id->def, id->vec_idx, i), 0), 0),
2374 value = XEXP (XVECEXP (id->def, id->vec_idx, i), 1);
2377 av = attr->default_val;
2379 av = get_attr_value (value, attr, id->insn_code);
2381 ie = (struct insn_ent *) oballoc (sizeof (struct insn_ent));
2382 ie->insn_code = id->insn_code;
2383 ie->insn_index = id->insn_code;
2384 insert_insn_ent (av, ie);
2388 /* Given an expression EXP, see if it is a COND or IF_THEN_ELSE that has a
2389 test that checks relative positions of insns (uses MATCH_DUP or PC).
2390 If so, replace it with what is obtained by passing the expression to
2391 ADDRESS_FN. If not but it is a COND or IF_THEN_ELSE, call this routine
2392 recursively on each value (including the default value). Otherwise,
2393 return the value returned by NO_ADDRESS_FN applied to EXP. */
2396 substitute_address (exp, no_address_fn, address_fn)
2398 rtx (*no_address_fn) PARAMS ((rtx));
2399 rtx (*address_fn) PARAMS ((rtx));
2404 if (GET_CODE (exp) == COND)
2406 /* See if any tests use addresses. */
2408 for (i = 0; i < XVECLEN (exp, 0); i += 2)
2409 walk_attr_value (XVECEXP (exp, 0, i));
2412 return (*address_fn) (exp);
2414 /* Make a new copy of this COND, replacing each element. */
2415 newexp = rtx_alloc (COND);
2416 XVEC (newexp, 0) = rtvec_alloc (XVECLEN (exp, 0));
2417 for (i = 0; i < XVECLEN (exp, 0); i += 2)
2419 XVECEXP (newexp, 0, i) = XVECEXP (exp, 0, i);
2420 XVECEXP (newexp, 0, i + 1)
2421 = substitute_address (XVECEXP (exp, 0, i + 1),
2422 no_address_fn, address_fn);
2425 XEXP (newexp, 1) = substitute_address (XEXP (exp, 1),
2426 no_address_fn, address_fn);
2431 else if (GET_CODE (exp) == IF_THEN_ELSE)
2434 walk_attr_value (XEXP (exp, 0));
2436 return (*address_fn) (exp);
2438 return attr_rtx (IF_THEN_ELSE,
2439 substitute_address (XEXP (exp, 0),
2440 no_address_fn, address_fn),
2441 substitute_address (XEXP (exp, 1),
2442 no_address_fn, address_fn),
2443 substitute_address (XEXP (exp, 2),
2444 no_address_fn, address_fn));
2447 return (*no_address_fn) (exp);
2450 /* Make new attributes from the `length' attribute. The following are made,
2451 each corresponding to a function called from `shorten_branches' or
2454 *insn_default_length This is the length of the insn to be returned
2455 by `get_attr_length' before `shorten_branches'
2456 has been called. In each case where the length
2457 depends on relative addresses, the largest
2458 possible is used. This routine is also used
2459 to compute the initial size of the insn.
2461 *insn_variable_length_p This returns 1 if the insn's length depends
2462 on relative addresses, zero otherwise.
2464 *insn_current_length This is only called when it is known that the
2465 insn has a variable length and returns the
2466 current length, based on relative addresses.
2470 make_length_attrs ()
2472 static const char *new_names[] = {"*insn_default_length",
2473 "*insn_variable_length_p",
2474 "*insn_current_length"};
2475 static rtx (*no_address_fn[]) PARAMS ((rtx)) = {identity_fn, zero_fn, zero_fn};
2476 static rtx (*address_fn[]) PARAMS ((rtx)) = {max_fn, one_fn, identity_fn};
2478 struct attr_desc *length_attr, *new_attr;
2479 struct attr_value *av, *new_av;
2480 struct insn_ent *ie, *new_ie;
2482 /* See if length attribute is defined. If so, it must be numeric. Make
2483 it special so we don't output anything for it. */
2484 length_attr = find_attr ("length", 0);
2485 if (length_attr == 0)
2488 if (! length_attr->is_numeric)
2489 fatal ("length attribute must be numeric.");
2491 length_attr->is_const = 0;
2492 length_attr->is_special = 1;
2494 /* Make each new attribute, in turn. */
2495 for (i = 0; i < ARRAY_SIZE (new_names); i++)
2497 make_internal_attr (new_names[i],
2498 substitute_address (length_attr->default_val->value,
2499 no_address_fn[i], address_fn[i]),
2501 new_attr = find_attr (new_names[i], 0);
2502 for (av = length_attr->first_value; av; av = av->next)
2503 for (ie = av->first_insn; ie; ie = ie->next)
2505 new_av = get_attr_value (substitute_address (av->value,
2508 new_attr, ie->insn_code);
2509 new_ie = (struct insn_ent *) oballoc (sizeof (struct insn_ent));
2510 new_ie->insn_code = ie->insn_code;
2511 new_ie->insn_index = ie->insn_index;
2512 insert_insn_ent (new_av, new_ie);
2517 /* Utility functions called from above routine. */
2528 rtx exp ATTRIBUTE_UNUSED;
2530 return make_numeric_value (0);
2535 rtx exp ATTRIBUTE_UNUSED;
2537 return make_numeric_value (1);
2545 return make_numeric_value (max_attr_value (exp, &unknown));
2549 write_length_unit_log ()
2551 struct attr_desc *length_attr = find_attr ("length", 0);
2552 struct attr_value *av;
2553 struct insn_ent *ie;
2554 unsigned int length_unit_log, length_or;
2557 if (length_attr == 0)
2559 length_or = or_attr_value (length_attr->default_val->value, &unknown);
2560 for (av = length_attr->first_value; av; av = av->next)
2561 for (ie = av->first_insn; ie; ie = ie->next)
2562 length_or |= or_attr_value (av->value, &unknown);
2565 length_unit_log = 0;
2568 length_or = ~length_or;
2569 for (length_unit_log = 0; length_or & 1; length_or >>= 1)
2572 printf ("int length_unit_log = %u;\n", length_unit_log);
2575 /* Take a COND expression and see if any of the conditions in it can be
2576 simplified. If any are known true or known false for the particular insn
2577 code, the COND can be further simplified.
2579 Also call ourselves on any COND operations that are values of this COND.
2581 We do not modify EXP; rather, we make and return a new rtx. */
2584 simplify_cond (exp, insn_code, insn_index)
2586 int insn_code, insn_index;
2589 /* We store the desired contents here,
2590 then build a new expression if they don't match EXP. */
2591 rtx defval = XEXP (exp, 1);
2592 rtx new_defval = XEXP (exp, 1);
2593 int len = XVECLEN (exp, 0);
2594 rtx *tests = (rtx *) alloca (len * sizeof (rtx));
2598 /* This lets us free all storage allocated below, if appropriate. */
2599 first_spacer = (char *) obstack_finish (rtl_obstack);
2601 bcopy ((char *) XVEC (exp, 0)->elem, (char *) tests, len * sizeof (rtx));
2603 /* See if default value needs simplification. */
2604 if (GET_CODE (defval) == COND)
2605 new_defval = simplify_cond (defval, insn_code, insn_index);
2607 /* Simplify the subexpressions, and see what tests we can get rid of. */
2609 for (i = 0; i < len; i += 2)
2611 rtx newtest, newval;
2613 /* Simplify this test. */
2614 newtest = SIMPLIFY_TEST_EXP (tests[i], insn_code, insn_index);
2617 newval = tests[i + 1];
2618 /* See if this value may need simplification. */
2619 if (GET_CODE (newval) == COND)
2620 newval = simplify_cond (newval, insn_code, insn_index);
2622 /* Look for ways to delete or combine this test. */
2623 if (newtest == true_rtx)
2625 /* If test is true, make this value the default
2626 and discard this + any following tests. */
2628 defval = tests[i + 1];
2629 new_defval = newval;
2632 else if (newtest == false_rtx)
2634 /* If test is false, discard it and its value. */
2635 for (j = i; j < len - 2; j++)
2636 tests[j] = tests[j + 2];
2640 else if (i > 0 && attr_equal_p (newval, tests[i - 1]))
2642 /* If this value and the value for the prev test are the same,
2646 = insert_right_side (IOR, tests[i - 2], newtest,
2647 insn_code, insn_index);
2649 /* Delete this test/value. */
2650 for (j = i; j < len - 2; j++)
2651 tests[j] = tests[j + 2];
2656 tests[i + 1] = newval;
2659 /* If the last test in a COND has the same value
2660 as the default value, that test isn't needed. */
2662 while (len > 0 && attr_equal_p (tests[len - 1], new_defval))
2665 /* See if we changed anything. */
2666 if (len != XVECLEN (exp, 0) || new_defval != XEXP (exp, 1))
2669 for (i = 0; i < len; i++)
2670 if (! attr_equal_p (tests[i], XVECEXP (exp, 0, i)))
2679 obstack_free (rtl_obstack, first_spacer);
2680 if (GET_CODE (defval) == COND)
2681 return simplify_cond (defval, insn_code, insn_index);
2687 obstack_free (rtl_obstack, first_spacer);
2692 rtx newexp = rtx_alloc (COND);
2694 XVEC (newexp, 0) = rtvec_alloc (len);
2695 bcopy ((char *) tests, (char *) XVEC (newexp, 0)->elem,
2696 len * sizeof (rtx));
2697 XEXP (newexp, 1) = new_defval;
2702 /* Remove an insn entry from an attribute value. */
2705 remove_insn_ent (av, ie)
2706 struct attr_value *av;
2707 struct insn_ent *ie;
2709 struct insn_ent *previe;
2711 if (av->first_insn == ie)
2712 av->first_insn = ie->next;
2715 for (previe = av->first_insn; previe->next != ie; previe = previe->next)
2717 previe->next = ie->next;
2721 if (ie->insn_code == -1)
2722 av->has_asm_insn = 0;
2727 /* Insert an insn entry in an attribute value list. */
2730 insert_insn_ent (av, ie)
2731 struct attr_value *av;
2732 struct insn_ent *ie;
2734 ie->next = av->first_insn;
2735 av->first_insn = ie;
2737 if (ie->insn_code == -1)
2738 av->has_asm_insn = 1;
2743 /* This is a utility routine to take an expression that is a tree of either
2744 AND or IOR expressions and insert a new term. The new term will be
2745 inserted at the right side of the first node whose code does not match
2746 the root. A new node will be created with the root's code. Its left
2747 side will be the old right side and its right side will be the new
2750 If the `term' is itself a tree, all its leaves will be inserted. */
2753 insert_right_side (code, exp, term, insn_code, insn_index)
2757 int insn_code, insn_index;
2761 /* Avoid consing in some special cases. */
2762 if (code == AND && term == true_rtx)
2764 if (code == AND && term == false_rtx)
2766 if (code == AND && exp == true_rtx)
2768 if (code == AND && exp == false_rtx)
2770 if (code == IOR && term == true_rtx)
2772 if (code == IOR && term == false_rtx)
2774 if (code == IOR && exp == true_rtx)
2776 if (code == IOR && exp == false_rtx)
2778 if (attr_equal_p (exp, term))
2781 if (GET_CODE (term) == code)
2783 exp = insert_right_side (code, exp, XEXP (term, 0),
2784 insn_code, insn_index);
2785 exp = insert_right_side (code, exp, XEXP (term, 1),
2786 insn_code, insn_index);
2791 if (GET_CODE (exp) == code)
2793 rtx new = insert_right_side (code, XEXP (exp, 1),
2794 term, insn_code, insn_index);
2795 if (new != XEXP (exp, 1))
2796 /* Make a copy of this expression and call recursively. */
2797 newexp = attr_rtx (code, XEXP (exp, 0), new);
2803 /* Insert the new term. */
2804 newexp = attr_rtx (code, exp, term);
2807 return SIMPLIFY_TEST_EXP (newexp, insn_code, insn_index);
2810 /* If we have an expression which AND's a bunch of
2811 (not (eq_attrq "alternative" "n"))
2812 terms, we may have covered all or all but one of the possible alternatives.
2813 If so, we can optimize. Similarly for IOR's of EQ_ATTR.
2815 This routine is passed an expression and either AND or IOR. It returns a
2816 bitmask indicating which alternatives are mentioned within EXP. */
2819 compute_alternative_mask (exp, code)
2824 if (GET_CODE (exp) == code)
2825 return compute_alternative_mask (XEXP (exp, 0), code)
2826 | compute_alternative_mask (XEXP (exp, 1), code);
2828 else if (code == AND && GET_CODE (exp) == NOT
2829 && GET_CODE (XEXP (exp, 0)) == EQ_ATTR
2830 && XSTR (XEXP (exp, 0), 0) == alternative_name)
2831 string = XSTR (XEXP (exp, 0), 1);
2833 else if (code == IOR && GET_CODE (exp) == EQ_ATTR
2834 && XSTR (exp, 0) == alternative_name)
2835 string = XSTR (exp, 1);
2841 return 1 << (string[0] - '0');
2842 return 1 << atoi (string);
2845 /* Given I, a single-bit mask, return RTX to compare the `alternative'
2846 attribute with the value represented by that bit. */
2849 make_alternative_compare (mask)
2856 for (i = 0; (mask & (1 << i)) == 0; i++)
2859 newexp = attr_rtx (EQ_ATTR, alternative_name, attr_numeral (i));
2860 RTX_UNCHANGING_P (newexp) = 1;
2865 /* If we are processing an (eq_attr "attr" "value") test, we find the value
2866 of "attr" for this insn code. From that value, we can compute a test
2867 showing when the EQ_ATTR will be true. This routine performs that
2868 computation. If a test condition involves an address, we leave the EQ_ATTR
2869 intact because addresses are only valid for the `length' attribute.
2871 EXP is the EQ_ATTR expression and VALUE is the value of that attribute
2872 for the insn corresponding to INSN_CODE and INSN_INDEX. */
2875 evaluate_eq_attr (exp, value, insn_code, insn_index)
2878 int insn_code, insn_index;
2885 if (GET_CODE (value) == CONST_STRING)
2887 if (! strcmp (XSTR (value, 0), XSTR (exp, 1)))
2892 else if (GET_CODE (value) == SYMBOL_REF)
2896 if (GET_CODE (exp) != EQ_ATTR)
2899 string = (char *) alloca (2 + strlen (XSTR (exp, 0))
2900 + strlen (XSTR (exp, 1)));
2901 strcpy (string, XSTR (exp, 0));
2902 strcat (string, "_");
2903 strcat (string, XSTR (exp, 1));
2904 for (p = string; *p; p++)
2907 newexp = attr_rtx (EQ, value,
2908 attr_rtx (SYMBOL_REF,
2909 attr_string (string, strlen (string))));
2911 else if (GET_CODE (value) == COND)
2913 /* We construct an IOR of all the cases for which the requested attribute
2914 value is present. Since we start with FALSE, if it is not present,
2915 FALSE will be returned.
2917 Each case is the AND of the NOT's of the previous conditions with the
2918 current condition; in the default case the current condition is TRUE.
2920 For each possible COND value, call ourselves recursively.
2922 The extra TRUE and FALSE expressions will be eliminated by another
2923 call to the simplification routine. */
2928 if (current_alternative_string)
2929 clear_struct_flag (value);
2931 for (i = 0; i < XVECLEN (value, 0); i += 2)
2933 rtx this = SIMPLIFY_TEST_EXP (XVECEXP (value, 0, i),
2934 insn_code, insn_index);
2936 SIMPLIFY_ALTERNATIVE (this);
2938 right = insert_right_side (AND, andexp, this,
2939 insn_code, insn_index);
2940 right = insert_right_side (AND, right,
2941 evaluate_eq_attr (exp,
2944 insn_code, insn_index),
2945 insn_code, insn_index);
2946 orexp = insert_right_side (IOR, orexp, right,
2947 insn_code, insn_index);
2949 /* Add this condition into the AND expression. */
2950 newexp = attr_rtx (NOT, this);
2951 andexp = insert_right_side (AND, andexp, newexp,
2952 insn_code, insn_index);
2955 /* Handle the default case. */
2956 right = insert_right_side (AND, andexp,
2957 evaluate_eq_attr (exp, XEXP (value, 1),
2958 insn_code, insn_index),
2959 insn_code, insn_index);
2960 newexp = insert_right_side (IOR, orexp, right, insn_code, insn_index);
2965 /* If uses an address, must return original expression. But set the
2966 RTX_UNCHANGING_P bit so we don't try to simplify it again. */
2969 walk_attr_value (newexp);
2973 /* This had `&& current_alternative_string', which seems to be wrong. */
2974 if (! RTX_UNCHANGING_P (exp))
2975 return copy_rtx_unchanging (exp);
2982 /* This routine is called when an AND of a term with a tree of AND's is
2983 encountered. If the term or its complement is present in the tree, it
2984 can be replaced with TRUE or FALSE, respectively.
2986 Note that (eq_attr "att" "v1") and (eq_attr "att" "v2") cannot both
2987 be true and hence are complementary.
2989 There is one special case: If we see
2990 (and (not (eq_attr "att" "v1"))
2991 (eq_attr "att" "v2"))
2992 this can be replaced by (eq_attr "att" "v2"). To do this we need to
2993 replace the term, not anything in the AND tree. So we pass a pointer to
2997 simplify_and_tree (exp, pterm, insn_code, insn_index)
3000 int insn_code, insn_index;
3005 int left_eliminates_term, right_eliminates_term;
3007 if (GET_CODE (exp) == AND)
3009 left = simplify_and_tree (XEXP (exp, 0), pterm, insn_code, insn_index);
3010 right = simplify_and_tree (XEXP (exp, 1), pterm, insn_code, insn_index);
3011 if (left != XEXP (exp, 0) || right != XEXP (exp, 1))
3013 newexp = attr_rtx (GET_CODE (exp), left, right);
3015 exp = SIMPLIFY_TEST_EXP (newexp, insn_code, insn_index);
3019 else if (GET_CODE (exp) == IOR)
3021 /* For the IOR case, we do the same as above, except that we can
3022 only eliminate `term' if both sides of the IOR would do so. */
3024 left = simplify_and_tree (XEXP (exp, 0), &temp, insn_code, insn_index);
3025 left_eliminates_term = (temp == true_rtx);
3028 right = simplify_and_tree (XEXP (exp, 1), &temp, insn_code, insn_index);
3029 right_eliminates_term = (temp == true_rtx);
3031 if (left_eliminates_term && right_eliminates_term)
3034 if (left != XEXP (exp, 0) || right != XEXP (exp, 1))
3036 newexp = attr_rtx (GET_CODE (exp), left, right);
3038 exp = SIMPLIFY_TEST_EXP (newexp, insn_code, insn_index);
3042 /* Check for simplifications. Do some extra checking here since this
3043 routine is called so many times. */
3048 else if (GET_CODE (exp) == NOT && XEXP (exp, 0) == *pterm)
3051 else if (GET_CODE (*pterm) == NOT && exp == XEXP (*pterm, 0))
3054 else if (GET_CODE (exp) == EQ_ATTR && GET_CODE (*pterm) == EQ_ATTR)
3056 if (XSTR (exp, 0) != XSTR (*pterm, 0))
3059 if (! strcmp (XSTR (exp, 1), XSTR (*pterm, 1)))
3065 else if (GET_CODE (*pterm) == EQ_ATTR && GET_CODE (exp) == NOT
3066 && GET_CODE (XEXP (exp, 0)) == EQ_ATTR)
3068 if (XSTR (*pterm, 0) != XSTR (XEXP (exp, 0), 0))
3071 if (! strcmp (XSTR (*pterm, 1), XSTR (XEXP (exp, 0), 1)))
3077 else if (GET_CODE (exp) == EQ_ATTR && GET_CODE (*pterm) == NOT
3078 && GET_CODE (XEXP (*pterm, 0)) == EQ_ATTR)
3080 if (XSTR (exp, 0) != XSTR (XEXP (*pterm, 0), 0))
3083 if (! strcmp (XSTR (exp, 1), XSTR (XEXP (*pterm, 0), 1)))
3089 else if (GET_CODE (exp) == NOT && GET_CODE (*pterm) == NOT)
3091 if (attr_equal_p (XEXP (exp, 0), XEXP (*pterm, 0)))
3095 else if (GET_CODE (exp) == NOT)
3097 if (attr_equal_p (XEXP (exp, 0), *pterm))
3101 else if (GET_CODE (*pterm) == NOT)
3103 if (attr_equal_p (XEXP (*pterm, 0), exp))
3107 else if (attr_equal_p (exp, *pterm))
3113 /* Similar to `simplify_and_tree', but for IOR trees. */
3116 simplify_or_tree (exp, pterm, insn_code, insn_index)
3119 int insn_code, insn_index;
3124 int left_eliminates_term, right_eliminates_term;
3126 if (GET_CODE (exp) == IOR)
3128 left = simplify_or_tree (XEXP (exp, 0), pterm, insn_code, insn_index);
3129 right = simplify_or_tree (XEXP (exp, 1), pterm, insn_code, insn_index);
3130 if (left != XEXP (exp, 0) || right != XEXP (exp, 1))
3132 newexp = attr_rtx (GET_CODE (exp), left, right);
3134 exp = SIMPLIFY_TEST_EXP (newexp, insn_code, insn_index);
3138 else if (GET_CODE (exp) == AND)
3140 /* For the AND case, we do the same as above, except that we can
3141 only eliminate `term' if both sides of the AND would do so. */
3143 left = simplify_or_tree (XEXP (exp, 0), &temp, insn_code, insn_index);
3144 left_eliminates_term = (temp == false_rtx);
3147 right = simplify_or_tree (XEXP (exp, 1), &temp, insn_code, insn_index);
3148 right_eliminates_term = (temp == false_rtx);
3150 if (left_eliminates_term && right_eliminates_term)
3153 if (left != XEXP (exp, 0) || right != XEXP (exp, 1))
3155 newexp = attr_rtx (GET_CODE (exp), left, right);
3157 exp = SIMPLIFY_TEST_EXP (newexp, insn_code, insn_index);
3161 if (attr_equal_p (exp, *pterm))
3164 else if (GET_CODE (exp) == NOT && attr_equal_p (XEXP (exp, 0), *pterm))
3167 else if (GET_CODE (*pterm) == NOT && attr_equal_p (XEXP (*pterm, 0), exp))
3170 else if (GET_CODE (*pterm) == EQ_ATTR && GET_CODE (exp) == NOT
3171 && GET_CODE (XEXP (exp, 0)) == EQ_ATTR
3172 && XSTR (*pterm, 0) == XSTR (XEXP (exp, 0), 0))
3175 else if (GET_CODE (exp) == EQ_ATTR && GET_CODE (*pterm) == NOT
3176 && GET_CODE (XEXP (*pterm, 0)) == EQ_ATTR
3177 && XSTR (exp, 0) == XSTR (XEXP (*pterm, 0), 0))
3183 /* Given an expression, see if it can be simplified for a particular insn
3184 code based on the values of other attributes being tested. This can
3185 eliminate nested get_attr_... calls.
3187 Note that if an endless recursion is specified in the patterns, the
3188 optimization will loop. However, it will do so in precisely the cases where
3189 an infinite recursion loop could occur during compilation. It's better that
3193 simplify_test_exp (exp, insn_code, insn_index)
3195 int insn_code, insn_index;
3198 struct attr_desc *attr;
3199 struct attr_value *av;
3200 struct insn_ent *ie;
3203 char *spacer = (char *) obstack_finish (rtl_obstack);
3205 /* Don't re-simplify something we already simplified. */
3206 if (RTX_UNCHANGING_P (exp) || MEM_IN_STRUCT_P (exp))
3209 switch (GET_CODE (exp))
3212 left = SIMPLIFY_TEST_EXP (XEXP (exp, 0), insn_code, insn_index);
3213 SIMPLIFY_ALTERNATIVE (left);
3214 if (left == false_rtx)
3217 obstack_free (rtl_obstack, spacer);
3220 right = SIMPLIFY_TEST_EXP (XEXP (exp, 1), insn_code, insn_index);
3221 SIMPLIFY_ALTERNATIVE (right);
3222 if (left == false_rtx)
3225 obstack_free (rtl_obstack, spacer);
3229 /* If either side is an IOR and we have (eq_attr "alternative" ..")
3230 present on both sides, apply the distributive law since this will
3231 yield simplifications. */
3232 if ((GET_CODE (left) == IOR || GET_CODE (right) == IOR)
3233 && compute_alternative_mask (left, IOR)
3234 && compute_alternative_mask (right, IOR))
3236 if (GET_CODE (left) == IOR)
3243 newexp = attr_rtx (IOR,
3244 attr_rtx (AND, left, XEXP (right, 0)),
3245 attr_rtx (AND, left, XEXP (right, 1)));
3247 return SIMPLIFY_TEST_EXP (newexp, insn_code, insn_index);
3250 /* Try with the term on both sides. */
3251 right = simplify_and_tree (right, &left, insn_code, insn_index);
3252 if (left == XEXP (exp, 0) && right == XEXP (exp, 1))
3253 left = simplify_and_tree (left, &right, insn_code, insn_index);
3255 if (left == false_rtx || right == false_rtx)
3258 obstack_free (rtl_obstack, spacer);
3261 else if (left == true_rtx)
3265 else if (right == true_rtx)
3269 /* See if all or all but one of the insn's alternatives are specified
3270 in this tree. Optimize if so. */
3272 else if (insn_code >= 0
3273 && (GET_CODE (left) == AND
3274 || (GET_CODE (left) == NOT
3275 && GET_CODE (XEXP (left, 0)) == EQ_ATTR
3276 && XSTR (XEXP (left, 0), 0) == alternative_name)
3277 || GET_CODE (right) == AND
3278 || (GET_CODE (right) == NOT
3279 && GET_CODE (XEXP (right, 0)) == EQ_ATTR
3280 && XSTR (XEXP (right, 0), 0) == alternative_name)))
3282 i = compute_alternative_mask (exp, AND);
3283 if (i & ~insn_alternatives[insn_code])
3284 fatal ("Invalid alternative specified for pattern number %d",
3287 /* If all alternatives are excluded, this is false. */
3288 i ^= insn_alternatives[insn_code];
3291 else if ((i & (i - 1)) == 0 && insn_alternatives[insn_code] > 1)
3293 /* If just one excluded, AND a comparison with that one to the
3294 front of the tree. The others will be eliminated by
3295 optimization. We do not want to do this if the insn has one
3296 alternative and we have tested none of them! */
3297 left = make_alternative_compare (i);
3298 right = simplify_and_tree (exp, &left, insn_code, insn_index);
3299 newexp = attr_rtx (AND, left, right);
3301 return SIMPLIFY_TEST_EXP (newexp, insn_code, insn_index);
3305 if (left != XEXP (exp, 0) || right != XEXP (exp, 1))
3307 newexp = attr_rtx (AND, left, right);
3308 return SIMPLIFY_TEST_EXP (newexp, insn_code, insn_index);
3313 left = SIMPLIFY_TEST_EXP (XEXP (exp, 0), insn_code, insn_index);
3314 SIMPLIFY_ALTERNATIVE (left);
3315 if (left == true_rtx)
3318 obstack_free (rtl_obstack, spacer);
3321 right = SIMPLIFY_TEST_EXP (XEXP (exp, 1), insn_code, insn_index);
3322 SIMPLIFY_ALTERNATIVE (right);
3323 if (right == true_rtx)
3326 obstack_free (rtl_obstack, spacer);
3330 right = simplify_or_tree (right, &left, insn_code, insn_index);
3331 if (left == XEXP (exp, 0) && right == XEXP (exp, 1))
3332 left = simplify_or_tree (left, &right, insn_code, insn_index);
3334 if (right == true_rtx || left == true_rtx)
3337 obstack_free (rtl_obstack, spacer);
3340 else if (left == false_rtx)
3344 else if (right == false_rtx)
3349 /* Test for simple cases where the distributive law is useful. I.e.,
3350 convert (ior (and (x) (y))
3356 else if (GET_CODE (left) == AND && GET_CODE (right) == AND
3357 && attr_equal_p (XEXP (left, 0), XEXP (right, 0)))
3359 newexp = attr_rtx (IOR, XEXP (left, 1), XEXP (right, 1));
3361 left = XEXP (left, 0);
3363 newexp = attr_rtx (AND, left, right);
3364 return SIMPLIFY_TEST_EXP (newexp, insn_code, insn_index);
3367 /* See if all or all but one of the insn's alternatives are specified
3368 in this tree. Optimize if so. */
3370 else if (insn_code >= 0
3371 && (GET_CODE (left) == IOR
3372 || (GET_CODE (left) == EQ_ATTR
3373 && XSTR (left, 0) == alternative_name)
3374 || GET_CODE (right) == IOR
3375 || (GET_CODE (right) == EQ_ATTR
3376 && XSTR (right, 0) == alternative_name)))
3378 i = compute_alternative_mask (exp, IOR);
3379 if (i & ~insn_alternatives[insn_code])
3380 fatal ("Invalid alternative specified for pattern number %d",
3383 /* If all alternatives are included, this is true. */
3384 i ^= insn_alternatives[insn_code];
3387 else if ((i & (i - 1)) == 0 && insn_alternatives[insn_code] > 1)
3389 /* If just one excluded, IOR a comparison with that one to the
3390 front of the tree. The others will be eliminated by
3391 optimization. We do not want to do this if the insn has one
3392 alternative and we have tested none of them! */
3393 left = make_alternative_compare (i);
3394 right = simplify_and_tree (exp, &left, insn_code, insn_index);
3395 newexp = attr_rtx (IOR, attr_rtx (NOT, left), right);
3397 return SIMPLIFY_TEST_EXP (newexp, insn_code, insn_index);
3401 if (left != XEXP (exp, 0) || right != XEXP (exp, 1))
3403 newexp = attr_rtx (IOR, left, right);
3404 return SIMPLIFY_TEST_EXP (newexp, insn_code, insn_index);
3409 if (GET_CODE (XEXP (exp, 0)) == NOT)
3411 left = SIMPLIFY_TEST_EXP (XEXP (XEXP (exp, 0), 0),
3412 insn_code, insn_index);
3413 SIMPLIFY_ALTERNATIVE (left);
3417 left = SIMPLIFY_TEST_EXP (XEXP (exp, 0), insn_code, insn_index);
3418 SIMPLIFY_ALTERNATIVE (left);
3419 if (GET_CODE (left) == NOT)
3420 return XEXP (left, 0);
3422 if (left == false_rtx)
3425 obstack_free (rtl_obstack, spacer);
3428 else if (left == true_rtx)
3431 obstack_free (rtl_obstack, spacer);
3435 /* Try to apply De`Morgan's laws. */
3436 else if (GET_CODE (left) == IOR)
3438 newexp = attr_rtx (AND,
3439 attr_rtx (NOT, XEXP (left, 0)),
3440 attr_rtx (NOT, XEXP (left, 1)));
3442 newexp = SIMPLIFY_TEST_EXP (newexp, insn_code, insn_index);
3444 else if (GET_CODE (left) == AND)
3446 newexp = attr_rtx (IOR,
3447 attr_rtx (NOT, XEXP (left, 0)),
3448 attr_rtx (NOT, XEXP (left, 1)));
3450 newexp = SIMPLIFY_TEST_EXP (newexp, insn_code, insn_index);
3452 else if (left != XEXP (exp, 0))
3454 newexp = attr_rtx (NOT, left);
3459 if (current_alternative_string && XSTR (exp, 0) == alternative_name)
3460 return (XSTR (exp, 1) == current_alternative_string
3461 ? true_rtx : false_rtx);
3463 /* Look at the value for this insn code in the specified attribute.
3464 We normally can replace this comparison with the condition that
3465 would give this insn the values being tested for. */
3466 if (XSTR (exp, 0) != alternative_name
3467 && (attr = find_attr (XSTR (exp, 0), 0)) != NULL)
3468 for (av = attr->first_value; av; av = av->next)
3469 for (ie = av->first_insn; ie; ie = ie->next)
3470 if (ie->insn_code == insn_code)
3471 return evaluate_eq_attr (exp, av->value, insn_code, insn_index);
3478 /* We have already simplified this expression. Simplifying it again
3479 won't buy anything unless we weren't given a valid insn code
3480 to process (i.e., we are canonicalizing something.). */
3481 if (insn_code != -2 /* Seems wrong: && current_alternative_string. */
3482 && ! RTX_UNCHANGING_P (newexp))
3483 return copy_rtx_unchanging (newexp);
3488 /* Optimize the attribute lists by seeing if we can determine conditional
3489 values from the known values of other attributes. This will save subroutine
3490 calls during the compilation. */
3495 struct attr_desc *attr;
3496 struct attr_value *av;
3497 struct insn_ent *ie;
3499 int something_changed = 1;
3501 struct attr_value_list
3503 struct attr_value *av;
3504 struct insn_ent *ie;
3505 struct attr_desc *attr;
3506 struct attr_value_list *next;
3508 struct attr_value_list **insn_code_values;
3509 struct attr_value_list *ivbuf;
3510 struct attr_value_list *iv;
3512 /* For each insn code, make a list of all the insn_ent's for it,
3513 for all values for all attributes. */
3515 if (num_insn_ents == 0)
3518 /* Make 2 extra elements, for "code" values -2 and -1. */
3520 = (struct attr_value_list **) alloca ((insn_code_number + 2)
3521 * sizeof (struct attr_value_list *));
3522 bzero ((char *) insn_code_values,
3523 (insn_code_number + 2) * sizeof (struct attr_value_list *));
3525 /* Offset the table address so we can index by -2 or -1. */
3526 insn_code_values += 2;
3528 /* Allocate the attr_value_list structures using xmalloc rather than
3529 alloca, because using alloca can overflow the maximum permitted
3530 stack limit on SPARC Lynx. */
3531 iv = ivbuf = ((struct attr_value_list *)
3532 xmalloc (num_insn_ents * sizeof (struct attr_value_list)));
3534 for (i = 0; i < MAX_ATTRS_INDEX; i++)
3535 for (attr = attrs[i]; attr; attr = attr->next)
3536 for (av = attr->first_value; av; av = av->next)
3537 for (ie = av->first_insn; ie; ie = ie->next)
3542 iv->next = insn_code_values[ie->insn_code];
3543 insn_code_values[ie->insn_code] = iv;
3547 /* Sanity check on num_insn_ents. */
3548 if (iv != ivbuf + num_insn_ents)
3551 /* Process one insn code at a time. */
3552 for (i = -2; i < insn_code_number; i++)
3554 /* Clear the MEM_IN_STRUCT_P flag everywhere relevant.
3555 We use it to mean "already simplified for this insn". */
3556 for (iv = insn_code_values[i]; iv; iv = iv->next)
3557 clear_struct_flag (iv->av->value);
3559 /* Loop until nothing changes for one iteration. */
3560 something_changed = 1;
3561 while (something_changed)
3563 something_changed = 0;
3564 for (iv = insn_code_values[i]; iv; iv = iv->next)
3566 struct obstack *old = rtl_obstack;
3567 char *spacer = (char *) obstack_finish (temp_obstack);
3572 if (GET_CODE (av->value) != COND)
3575 rtl_obstack = temp_obstack;
3576 #if 0 /* This was intended as a speed up, but it was slower. */
3577 if (insn_n_alternatives[ie->insn_code] > 6
3578 && count_sub_rtxs (av->value, 200) >= 200)
3579 newexp = simplify_by_alternatives (av->value, ie->insn_code,
3583 newexp = simplify_cond (av->value, ie->insn_code,
3587 if (newexp != av->value)
3589 newexp = attr_copy_rtx (newexp);
3590 remove_insn_ent (av, ie);
3591 av = get_attr_value (newexp, attr, ie->insn_code);
3593 insert_insn_ent (av, ie);
3594 something_changed = 1;
3597 obstack_free (temp_obstack, spacer);
3607 simplify_by_alternatives (exp, insn_code, insn_index)
3609 int insn_code, insn_index;
3612 int len = insn_n_alternatives[insn_code];
3613 rtx newexp = rtx_alloc (COND);
3616 XVEC (newexp, 0) = rtvec_alloc (len * 2);
3618 /* It will not matter what value we use as the default value
3619 of the new COND, since that default will never be used.
3620 Choose something of the right type. */
3621 for (ultimate = exp; GET_CODE (ultimate) == COND;)
3622 ultimate = XEXP (ultimate, 1);
3623 XEXP (newexp, 1) = ultimate;
3625 for (i = 0; i < insn_n_alternatives[insn_code]; i++)
3627 current_alternative_string = attr_numeral (i);
3628 XVECEXP (newexp, 0, i * 2) = make_alternative_compare (1 << i);
3629 XVECEXP (newexp, 0, i * 2 + 1)
3630 = simplify_cond (exp, insn_code, insn_index);
3633 current_alternative_string = 0;
3634 return simplify_cond (newexp, insn_code, insn_index);
3638 /* If EXP is a suitable expression, reorganize it by constructing an
3639 equivalent expression that is a COND with the tests being all combinations
3640 of attribute values and the values being simple constants. */
3643 simplify_by_exploding (exp)
3646 rtx list = 0, link, condexp, defval = NULL_RTX;
3647 struct dimension *space;
3648 rtx *condtest, *condval;
3649 int i, j, total, ndim = 0;
3650 int most_tests, num_marks, new_marks;
3652 /* Locate all the EQ_ATTR expressions. */
3653 if (! find_and_mark_used_attributes (exp, &list, &ndim) || ndim == 0)
3655 unmark_used_attributes (list, 0, 0);
3659 /* Create an attribute space from the list of used attributes. For each
3660 dimension in the attribute space, record the attribute, list of values
3661 used, and number of values used. Add members to the list of values to
3662 cover the domain of the attribute. This makes the expanded COND form
3663 order independent. */
3665 space = (struct dimension *) alloca (ndim * sizeof (struct dimension));
3668 for (ndim = 0; list; ndim++)
3670 /* Pull the first attribute value from the list and record that
3671 attribute as another dimension in the attribute space. */
3672 const char *name = XSTR (XEXP (list, 0), 0);
3675 if ((space[ndim].attr = find_attr (name, 0)) == 0
3676 || space[ndim].attr->is_numeric)
3678 unmark_used_attributes (list, space, ndim);
3682 /* Add all remaining attribute values that refer to this attribute. */
3683 space[ndim].num_values = 0;
3684 space[ndim].values = 0;
3686 for (link = list; link; link = *prev)
3687 if (! strcmp (XSTR (XEXP (link, 0), 0), name))
3689 space[ndim].num_values++;
3690 *prev = XEXP (link, 1);
3691 XEXP (link, 1) = space[ndim].values;
3692 space[ndim].values = link;
3695 prev = &XEXP (link, 1);
3697 /* Add sufficient members to the list of values to make the list
3698 mutually exclusive and record the total size of the attribute
3700 total *= add_values_to_cover (&space[ndim]);
3703 /* Sort the attribute space so that the attributes go from non-constant
3704 to constant and from most values to least values. */
3705 for (i = 0; i < ndim; i++)
3706 for (j = ndim - 1; j > i; j--)
3707 if ((space[j-1].attr->is_const && !space[j].attr->is_const)
3708 || space[j-1].num_values < space[j].num_values)
3710 struct dimension tmp;
3712 space[j] = space[j - 1];
3716 /* Establish the initial current value. */
3717 for (i = 0; i < ndim; i++)
3718 space[i].current_value = space[i].values;
3720 condtest = (rtx *) alloca (total * sizeof (rtx));
3721 condval = (rtx *) alloca (total * sizeof (rtx));
3723 /* Expand the tests and values by iterating over all values in the
3727 condtest[i] = test_for_current_value (space, ndim);
3728 condval[i] = simplify_with_current_value (exp, space, ndim);
3729 if (! increment_current_value (space, ndim))
3735 /* We are now finished with the original expression. */
3736 unmark_used_attributes (0, space, ndim);
3738 /* Find the most used constant value and make that the default. */
3740 for (i = num_marks = 0; i < total; i++)
3741 if (GET_CODE (condval[i]) == CONST_STRING
3742 && ! MEM_VOLATILE_P (condval[i]))
3744 /* Mark the unmarked constant value and count how many are marked. */
3745 MEM_VOLATILE_P (condval[i]) = 1;
3746 for (j = new_marks = 0; j < total; j++)
3747 if (GET_CODE (condval[j]) == CONST_STRING
3748 && MEM_VOLATILE_P (condval[j]))
3750 if (new_marks - num_marks > most_tests)
3752 most_tests = new_marks - num_marks;
3753 defval = condval[i];
3755 num_marks = new_marks;
3757 /* Clear all the marks. */
3758 for (i = 0; i < total; i++)
3759 MEM_VOLATILE_P (condval[i]) = 0;
3761 /* Give up if nothing is constant. */
3765 /* If all values are the default, use that. */
3766 if (total == most_tests)
3769 /* Make a COND with the most common constant value the default. (A more
3770 complex method where tests with the same value were combined didn't
3771 seem to improve things.) */
3772 condexp = rtx_alloc (COND);
3773 XVEC (condexp, 0) = rtvec_alloc ((total - most_tests) * 2);
3774 XEXP (condexp, 1) = defval;
3775 for (i = j = 0; i < total; i++)
3776 if (condval[i] != defval)
3778 XVECEXP (condexp, 0, 2 * j) = condtest[i];
3779 XVECEXP (condexp, 0, 2 * j + 1) = condval[i];
3786 /* Set the MEM_VOLATILE_P flag for all EQ_ATTR expressions in EXP and
3787 verify that EXP can be simplified to a constant term if all the EQ_ATTR
3788 tests have known value. */
3791 find_and_mark_used_attributes (exp, terms, nterms)
3797 switch (GET_CODE (exp))
3800 if (! MEM_VOLATILE_P (exp))
3802 rtx link = rtx_alloc (EXPR_LIST);
3803 XEXP (link, 0) = exp;
3804 XEXP (link, 1) = *terms;
3807 MEM_VOLATILE_P (exp) = 1;
3816 if (! find_and_mark_used_attributes (XEXP (exp, 2), terms, nterms))
3820 if (! find_and_mark_used_attributes (XEXP (exp, 1), terms, nterms))
3823 if (! find_and_mark_used_attributes (XEXP (exp, 0), terms, nterms))
3828 for (i = 0; i < XVECLEN (exp, 0); i++)
3829 if (! find_and_mark_used_attributes (XVECEXP (exp, 0, i), terms, nterms))
3831 if (! find_and_mark_used_attributes (XEXP (exp, 1), terms, nterms))
3840 /* Clear the MEM_VOLATILE_P flag in all EQ_ATTR expressions on LIST and
3841 in the values of the NDIM-dimensional attribute space SPACE. */
3844 unmark_used_attributes (list, space, ndim)
3846 struct dimension *space;
3852 for (i = 0; i < ndim; i++)
3853 unmark_used_attributes (space[i].values, 0, 0);
3855 for (link = list; link; link = XEXP (link, 1))
3857 exp = XEXP (link, 0);
3858 if (GET_CODE (exp) == EQ_ATTR)
3859 MEM_VOLATILE_P (exp) = 0;
3863 /* Update the attribute dimension DIM so that all values of the attribute
3864 are tested. Return the updated number of values. */
3867 add_values_to_cover (dim)
3868 struct dimension *dim;
3870 struct attr_value *av;
3871 rtx exp, link, *prev;
3874 for (av = dim->attr->first_value; av; av = av->next)
3875 if (GET_CODE (av->value) == CONST_STRING)
3878 if (nalt < dim->num_values)
3880 else if (nalt == dim->num_values)
3883 else if (nalt * 2 < dim->num_values * 3)
3885 /* Most all the values of the attribute are used, so add all the unused
3887 prev = &dim->values;
3888 for (link = dim->values; link; link = *prev)
3889 prev = &XEXP (link, 1);
3891 for (av = dim->attr->first_value; av; av = av->next)
3892 if (GET_CODE (av->value) == CONST_STRING)
3894 exp = attr_eq (dim->attr->name, XSTR (av->value, 0));
3895 if (MEM_VOLATILE_P (exp))
3898 link = rtx_alloc (EXPR_LIST);
3899 XEXP (link, 0) = exp;
3902 prev = &XEXP (link, 1);
3904 dim->num_values = nalt;
3908 rtx orexp = false_rtx;
3910 /* Very few values are used, so compute a mutually exclusive
3911 expression. (We could do this for numeric values if that becomes
3913 prev = &dim->values;
3914 for (link = dim->values; link; link = *prev)
3916 orexp = insert_right_side (IOR, orexp, XEXP (link, 0), -2, -2);
3917 prev = &XEXP (link, 1);
3919 link = rtx_alloc (EXPR_LIST);
3920 XEXP (link, 0) = attr_rtx (NOT, orexp);
3925 return dim->num_values;
3928 /* Increment the current value for the NDIM-dimensional attribute space SPACE
3929 and return FALSE if the increment overflowed. */
3932 increment_current_value (space, ndim)
3933 struct dimension *space;
3938 for (i = ndim - 1; i >= 0; i--)
3940 if ((space[i].current_value = XEXP (space[i].current_value, 1)) == 0)
3941 space[i].current_value = space[i].values;
3948 /* Construct an expression corresponding to the current value for the
3949 NDIM-dimensional attribute space SPACE. */
3952 test_for_current_value (space, ndim)
3953 struct dimension *space;
3959 for (i = 0; i < ndim; i++)
3960 exp = insert_right_side (AND, exp, XEXP (space[i].current_value, 0),
3966 /* Given the current value of the NDIM-dimensional attribute space SPACE,
3967 set the corresponding EQ_ATTR expressions to that value and reduce
3968 the expression EXP as much as possible. On input [and output], all
3969 known EQ_ATTR expressions are set to FALSE. */
3972 simplify_with_current_value (exp, space, ndim)
3974 struct dimension *space;
3980 /* Mark each current value as TRUE. */
3981 for (i = 0; i < ndim; i++)
3983 x = XEXP (space[i].current_value, 0);
3984 if (GET_CODE (x) == EQ_ATTR)
3985 MEM_VOLATILE_P (x) = 0;
3988 exp = simplify_with_current_value_aux (exp);
3990 /* Change each current value back to FALSE. */
3991 for (i = 0; i < ndim; i++)
3993 x = XEXP (space[i].current_value, 0);
3994 if (GET_CODE (x) == EQ_ATTR)
3995 MEM_VOLATILE_P (x) = 1;
4001 /* Reduce the expression EXP based on the MEM_VOLATILE_P settings of
4002 all EQ_ATTR expressions. */
4005 simplify_with_current_value_aux (exp)
4011 switch (GET_CODE (exp))
4014 if (MEM_VOLATILE_P (exp))
4023 cond = simplify_with_current_value_aux (XEXP (exp, 0));
4024 if (cond == true_rtx)
4025 return simplify_with_current_value_aux (XEXP (exp, 1));
4026 else if (cond == false_rtx)
4027 return simplify_with_current_value_aux (XEXP (exp, 2));
4029 return attr_rtx (IF_THEN_ELSE, cond,
4030 simplify_with_current_value_aux (XEXP (exp, 1)),
4031 simplify_with_current_value_aux (XEXP (exp, 2)));
4034 cond = simplify_with_current_value_aux (XEXP (exp, 1));
4035 if (cond == true_rtx)
4037 else if (cond == false_rtx)
4038 return simplify_with_current_value_aux (XEXP (exp, 0));
4040 return attr_rtx (IOR, cond,
4041 simplify_with_current_value_aux (XEXP (exp, 0)));
4044 cond = simplify_with_current_value_aux (XEXP (exp, 1));
4045 if (cond == true_rtx)
4046 return simplify_with_current_value_aux (XEXP (exp, 0));
4047 else if (cond == false_rtx)
4050 return attr_rtx (AND, cond,
4051 simplify_with_current_value_aux (XEXP (exp, 0)));
4054 cond = simplify_with_current_value_aux (XEXP (exp, 0));
4055 if (cond == true_rtx)
4057 else if (cond == false_rtx)
4060 return attr_rtx (NOT, cond);
4063 for (i = 0; i < XVECLEN (exp, 0); i += 2)
4065 cond = simplify_with_current_value_aux (XVECEXP (exp, 0, i));
4066 if (cond == true_rtx)
4067 return simplify_with_current_value_aux (XVECEXP (exp, 0, i + 1));
4068 else if (cond == false_rtx)
4071 abort (); /* With all EQ_ATTR's of known value, a case should
4072 have been selected. */
4074 return simplify_with_current_value_aux (XEXP (exp, 1));
4081 /* Clear the MEM_IN_STRUCT_P flag in EXP and its subexpressions. */
4084 clear_struct_flag (x)
4089 register enum rtx_code code;
4090 register const char *fmt;
4092 MEM_IN_STRUCT_P (x) = 0;
4093 if (RTX_UNCHANGING_P (x))
4096 code = GET_CODE (x);
4116 /* Compare the elements. If any pair of corresponding elements
4117 fail to match, return 0 for the whole things. */
4119 fmt = GET_RTX_FORMAT (code);
4120 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
4126 for (j = 0; j < XVECLEN (x, i); j++)
4127 clear_struct_flag (XVECEXP (x, i, j));
4131 clear_struct_flag (XEXP (x, i));
4137 /* Return the number of RTX objects making up the expression X.
4138 But if we count more than MAX objects, stop counting. */
4141 count_sub_rtxs (x, max)
4147 register enum rtx_code code;
4148 register const char *fmt;
4151 code = GET_CODE (x);
4171 /* Compare the elements. If any pair of corresponding elements
4172 fail to match, return 0 for the whole things. */
4174 fmt = GET_RTX_FORMAT (code);
4175 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
4184 for (j = 0; j < XVECLEN (x, i); j++)
4185 total += count_sub_rtxs (XVECEXP (x, i, j), max);
4189 total += count_sub_rtxs (XEXP (x, i), max);
4197 /* Create table entries for DEFINE_ATTR. */
4200 gen_attr (exp, lineno)
4204 struct attr_desc *attr;
4205 struct attr_value *av;
4206 const char *name_ptr;
4209 /* Make a new attribute structure. Check for duplicate by looking at
4210 attr->default_val, since it is initialized by this routine. */
4211 attr = find_attr (XSTR (exp, 0), 1);
4212 if (attr->default_val)
4214 message_with_line (lineno, "duplicate definition for attribute %s",
4216 message_with_line (attr->lineno, "previous definition");
4220 attr->lineno = lineno;
4222 if (*XSTR (exp, 1) == '\0')
4223 attr->is_numeric = 1;
4226 name_ptr = XSTR (exp, 1);
4227 while ((p = next_comma_elt (&name_ptr)) != NULL)
4229 av = (struct attr_value *) oballoc (sizeof (struct attr_value));
4230 av->value = attr_rtx (CONST_STRING, p);
4231 av->next = attr->first_value;
4232 attr->first_value = av;
4233 av->first_insn = NULL;
4235 av->has_asm_insn = 0;
4239 if (GET_CODE (XEXP (exp, 2)) == CONST)
4242 if (attr->is_numeric)
4244 message_with_line (lineno,
4245 "constant attributes may not take numeric values");
4249 /* Get rid of the CONST node. It is allowed only at top-level. */
4250 XEXP (exp, 2) = XEXP (XEXP (exp, 2), 0);
4253 if (! strcmp (attr->name, "length") && ! attr->is_numeric)
4255 message_with_line (lineno,
4256 "`length' attribute must take numeric values");
4260 /* Set up the default value. */
4261 XEXP (exp, 2) = check_attr_value (XEXP (exp, 2), attr);
4262 attr->default_val = get_attr_value (XEXP (exp, 2), attr, -2);
4265 /* Given a pattern for DEFINE_PEEPHOLE or DEFINE_INSN, return the number of
4266 alternatives in the constraints. Assume all MATCH_OPERANDs have the same
4267 number of alternatives as this should be checked elsewhere. */
4270 count_alternatives (exp)
4276 if (GET_CODE (exp) == MATCH_OPERAND)
4277 return n_comma_elts (XSTR (exp, 2));
4279 for (i = 0, fmt = GET_RTX_FORMAT (GET_CODE (exp));
4280 i < GET_RTX_LENGTH (GET_CODE (exp)); i++)
4285 n = count_alternatives (XEXP (exp, i));
4292 if (XVEC (exp, i) != NULL)
4293 for (j = 0; j < XVECLEN (exp, i); j++)
4295 n = count_alternatives (XVECEXP (exp, i, j));
4304 /* Returns non-zero if the given expression contains an EQ_ATTR with the
4305 `alternative' attribute. */
4308 compares_alternatives_p (exp)
4314 if (GET_CODE (exp) == EQ_ATTR && XSTR (exp, 0) == alternative_name)
4317 for (i = 0, fmt = GET_RTX_FORMAT (GET_CODE (exp));
4318 i < GET_RTX_LENGTH (GET_CODE (exp)); i++)
4323 if (compares_alternatives_p (XEXP (exp, i)))
4328 for (j = 0; j < XVECLEN (exp, i); j++)
4329 if (compares_alternatives_p (XVECEXP (exp, i, j)))
4337 /* Returns non-zero is INNER is contained in EXP. */
4340 contained_in_p (inner, exp)
4347 if (rtx_equal_p (inner, exp))
4350 for (i = 0, fmt = GET_RTX_FORMAT (GET_CODE (exp));
4351 i < GET_RTX_LENGTH (GET_CODE (exp)); i++)
4356 if (contained_in_p (inner, XEXP (exp, i)))
4361 for (j = 0; j < XVECLEN (exp, i); j++)
4362 if (contained_in_p (inner, XVECEXP (exp, i, j)))
4370 /* Process DEFINE_PEEPHOLE, DEFINE_INSN, and DEFINE_ASM_ATTRIBUTES. */
4373 gen_insn (exp, lineno)
4377 struct insn_def *id;
4379 id = (struct insn_def *) oballoc (sizeof (struct insn_def));
4383 id->lineno = lineno;
4385 switch (GET_CODE (exp))
4388 id->insn_code = insn_code_number;
4389 id->insn_index = insn_index_number;
4390 id->num_alternatives = count_alternatives (exp);
4391 if (id->num_alternatives == 0)
4392 id->num_alternatives = 1;
4396 case DEFINE_PEEPHOLE:
4397 id->insn_code = insn_code_number;
4398 id->insn_index = insn_index_number;
4399 id->num_alternatives = count_alternatives (exp);
4400 if (id->num_alternatives == 0)
4401 id->num_alternatives = 1;
4405 case DEFINE_ASM_ATTRIBUTES:
4407 id->insn_index = -1;
4408 id->num_alternatives = 1;
4410 got_define_asm_attributes = 1;
4418 /* Process a DEFINE_DELAY. Validate the vector length, check if annul
4419 true or annul false is specified, and make a `struct delay_desc'. */
4422 gen_delay (def, lineno)
4426 struct delay_desc *delay;
4429 if (XVECLEN (def, 1) % 3 != 0)
4431 message_with_line (lineno,
4432 "number of elements in DEFINE_DELAY must be multiple of three");
4437 for (i = 0; i < XVECLEN (def, 1); i += 3)
4439 if (XVECEXP (def, 1, i + 1))
4440 have_annul_true = 1;
4441 if (XVECEXP (def, 1, i + 2))
4442 have_annul_false = 1;
4445 delay = (struct delay_desc *) oballoc (sizeof (struct delay_desc));
4447 delay->num = ++num_delays;
4448 delay->next = delays;
4449 delay->lineno = lineno;
4453 /* Process a DEFINE_FUNCTION_UNIT.
4455 This gives information about a function unit contained in the CPU.
4456 We fill in a `struct function_unit_op' and a `struct function_unit'
4457 with information used later by `expand_unit'. */
4460 gen_unit (def, lineno)
4464 struct function_unit *unit;
4465 struct function_unit_op *op;
4466 const char *name = XSTR (def, 0);
4467 int multiplicity = XINT (def, 1);
4468 int simultaneity = XINT (def, 2);
4469 rtx condexp = XEXP (def, 3);
4470 int ready_cost = MAX (XINT (def, 4), 1);
4471 int issue_delay = MAX (XINT (def, 5), 1);
4473 /* See if we have already seen this function unit. If so, check that
4474 the multiplicity and simultaneity values are the same. If not, make
4475 a structure for this function unit. */
4476 for (unit = units; unit; unit = unit->next)
4477 if (! strcmp (unit->name, name))
4479 if (unit->multiplicity != multiplicity
4480 || unit->simultaneity != simultaneity)
4482 message_with_line (lineno,
4483 "differing specifications given for function unit %s",
4485 message_with_line (unit->first_lineno, "previous definition");
4494 unit = (struct function_unit *) oballoc (sizeof (struct function_unit));
4496 unit->multiplicity = multiplicity;
4497 unit->simultaneity = simultaneity;
4498 unit->issue_delay.min = unit->issue_delay.max = issue_delay;
4499 unit->num = num_units++;
4500 unit->num_opclasses = 0;
4501 unit->condexp = false_rtx;
4504 unit->first_lineno = lineno;
4508 /* Make a new operation class structure entry and initialize it. */
4509 op = (struct function_unit_op *) oballoc (sizeof (struct function_unit_op));
4510 op->condexp = condexp;
4511 op->num = unit->num_opclasses++;
4512 op->ready = ready_cost;
4513 op->issue_delay = issue_delay;
4514 op->next = unit->ops;
4515 op->lineno = lineno;
4517 num_unit_opclasses++;
4519 /* Set our issue expression based on whether or not an optional conflict
4520 vector was specified. */
4523 /* Compute the IOR of all the specified expressions. */
4524 rtx orexp = false_rtx;
4527 for (i = 0; i < XVECLEN (def, 6); i++)
4528 orexp = insert_right_side (IOR, orexp, XVECEXP (def, 6, i), -2, -2);
4530 op->conflict_exp = orexp;
4531 extend_range (&unit->issue_delay, 1, issue_delay);
4535 op->conflict_exp = true_rtx;
4536 extend_range (&unit->issue_delay, issue_delay, issue_delay);
4539 /* Merge our conditional into that of the function unit so we can determine
4540 which insns are used by the function unit. */
4541 unit->condexp = insert_right_side (IOR, unit->condexp, op->condexp, -2, -2);
4544 /* Given a piece of RTX, print a C expression to test its truth value.
4545 We use AND and IOR both for logical and bit-wise operations, so
4546 interpret them as logical unless they are inside a comparison expression.
4547 The first bit of FLAGS will be non-zero in that case.
4549 Set the second bit of FLAGS to make references to attribute values use
4550 a cached local variable instead of calling a function. */
4553 write_test_expr (exp, flags)
4557 int comparison_operator = 0;
4559 struct attr_desc *attr;
4561 /* In order not to worry about operator precedence, surround our part of
4562 the expression with parentheses. */
4565 code = GET_CODE (exp);
4568 /* Binary operators. */
4570 case GE: case GT: case GEU: case GTU:
4571 case LE: case LT: case LEU: case LTU:
4572 comparison_operator = 1;
4574 case PLUS: case MINUS: case MULT: case DIV: case MOD:
4575 case AND: case IOR: case XOR:
4576 case ASHIFT: case LSHIFTRT: case ASHIFTRT:
4577 write_test_expr (XEXP (exp, 0), flags | comparison_operator);
4593 printf (" >= (unsigned) ");
4596 printf (" > (unsigned) ");
4605 printf (" <= (unsigned) ");
4608 printf (" < (unsigned) ");
4651 write_test_expr (XEXP (exp, 1), flags | comparison_operator);
4655 /* Special-case (not (eq_attrq "alternative" "x")) */
4656 if (! (flags & 1) && GET_CODE (XEXP (exp, 0)) == EQ_ATTR
4657 && XSTR (XEXP (exp, 0), 0) == alternative_name)
4659 printf ("which_alternative != %s", XSTR (XEXP (exp, 0), 1));
4663 /* Otherwise, fall through to normal unary operator. */
4665 /* Unary operators. */
4685 write_test_expr (XEXP (exp, 0), flags);
4688 /* Comparison test of an attribute with a value. Most of these will
4689 have been removed by optimization. Handle "alternative"
4690 specially and give error if EQ_ATTR present inside a comparison. */
4693 fatal ("EQ_ATTR not valid inside comparison");
4695 if (XSTR (exp, 0) == alternative_name)
4697 printf ("which_alternative == %s", XSTR (exp, 1));
4701 attr = find_attr (XSTR (exp, 0), 0);
4705 /* Now is the time to expand the value of a constant attribute. */
4708 write_test_expr (evaluate_eq_attr (exp, attr->default_val->value,
4715 printf ("attr_%s", attr->name);
4717 printf ("get_attr_%s (insn)", attr->name);
4719 write_attr_valueq (attr, XSTR (exp, 1));
4723 /* Comparison test of flags for define_delays. */
4726 fatal ("ATTR_FLAG not valid inside comparison");
4727 printf ("(flags & ATTR_FLAG_%s) != 0", XSTR (exp, 0));
4730 /* See if an operand matches a predicate. */
4732 /* If only a mode is given, just ensure the mode matches the operand.
4733 If neither a mode nor predicate is given, error. */
4734 if (XSTR (exp, 1) == NULL || *XSTR (exp, 1) == '\0')
4736 if (GET_MODE (exp) == VOIDmode)
4737 fatal ("Null MATCH_OPERAND specified as test");
4739 printf ("GET_MODE (operands[%d]) == %smode",
4740 XINT (exp, 0), GET_MODE_NAME (GET_MODE (exp)));
4743 printf ("%s (operands[%d], %smode)",
4744 XSTR (exp, 1), XINT (exp, 0), GET_MODE_NAME (GET_MODE (exp)));
4748 printf ("%s (insn)", XSTR (exp, 0));
4751 /* Constant integer. */
4753 printf (HOST_WIDE_INT_PRINT_DEC, XWINT (exp, 0));
4756 /* A random C expression. */
4758 printf ("%s", XSTR (exp, 0));
4761 /* The address of the branch target. */
4763 printf ("INSN_ADDRESSES_SET_P () ? INSN_ADDRESSES (INSN_UID (GET_CODE (operands[%d]) == LABEL_REF ? XEXP (operands[%d], 0) : operands[%d])) : 0",
4764 XINT (exp, 0), XINT (exp, 0), XINT (exp, 0));
4768 /* The address of the current insn. We implement this actually as the
4769 address of the current insn for backward branches, but the last
4770 address of the next insn for forward branches, and both with
4771 adjustments that account for the worst-case possible stretching of
4772 intervening alignments between this insn and its destination. */
4773 printf ("insn_current_reference_address (insn)");
4777 printf ("%s", XSTR (exp, 0));
4781 write_test_expr (XEXP (exp, 0), flags & 2);
4783 write_test_expr (XEXP (exp, 1), flags | 1);
4785 write_test_expr (XEXP (exp, 2), flags | 1);
4789 fatal ("bad RTX code `%s' in attribute calculation\n",
4790 GET_RTX_NAME (code));
4796 /* Given an attribute value, return the maximum CONST_STRING argument
4797 encountered. Set *UNKNOWNP and return INT_MAX if the value is unknown. */
4800 max_attr_value (exp, unknownp)
4807 switch (GET_CODE (exp))
4810 current_max = atoi (XSTR (exp, 0));
4814 current_max = max_attr_value (XEXP (exp, 1), unknownp);
4815 for (i = 0; i < XVECLEN (exp, 0); i += 2)
4817 n = max_attr_value (XVECEXP (exp, 0, i + 1), unknownp);
4818 if (n > current_max)
4824 current_max = max_attr_value (XEXP (exp, 1), unknownp);
4825 n = max_attr_value (XEXP (exp, 2), unknownp);
4826 if (n > current_max)
4832 current_max = INT_MAX;
4839 /* Given an attribute value, return the result of ORing together all
4840 CONST_STRING arguments encountered. Set *UNKNOWNP and return -1
4841 if the numeric value is not known. */
4844 or_attr_value (exp, unknownp)
4851 switch (GET_CODE (exp))
4854 current_or = atoi (XSTR (exp, 0));
4858 current_or = or_attr_value (XEXP (exp, 1), unknownp);
4859 for (i = 0; i < XVECLEN (exp, 0); i += 2)
4860 current_or |= or_attr_value (XVECEXP (exp, 0, i + 1), unknownp);
4864 current_or = or_attr_value (XEXP (exp, 1), unknownp);
4865 current_or |= or_attr_value (XEXP (exp, 2), unknownp);
4877 /* Scan an attribute value, possibly a conditional, and record what actions
4878 will be required to do any conditional tests in it.
4881 `must_extract' if we need to extract the insn operands
4882 `must_constrain' if we must compute `which_alternative'
4883 `address_used' if an address expression was used
4884 `length_used' if an (eq_attr "length" ...) was used
4888 walk_attr_value (exp)
4892 register const char *fmt;
4898 code = GET_CODE (exp);
4902 if (! RTX_UNCHANGING_P (exp))
4903 /* Since this is an arbitrary expression, it can look at anything.
4904 However, constant expressions do not depend on any particular
4906 must_extract = must_constrain = 1;
4914 if (XSTR (exp, 0) == alternative_name)
4915 must_extract = must_constrain = 1;
4916 else if (strcmp (XSTR (exp, 0), "length") == 0)
4936 for (i = 0, fmt = GET_RTX_FORMAT (code); i < GET_RTX_LENGTH (code); i++)
4941 walk_attr_value (XEXP (exp, i));
4945 if (XVEC (exp, i) != NULL)
4946 for (j = 0; j < XVECLEN (exp, i); j++)
4947 walk_attr_value (XVECEXP (exp, i, j));
4952 /* Write out a function to obtain the attribute for a given INSN. */
4955 write_attr_get (attr)
4956 struct attr_desc *attr;
4958 struct attr_value *av, *common_av;
4960 /* Find the most used attribute value. Handle that as the `default' of the
4961 switch we will generate. */
4962 common_av = find_most_used (attr);
4964 /* Write out prototype of function. */
4965 if (!attr->is_numeric)
4966 printf ("extern enum attr_%s ", attr->name);
4967 else if (attr->unsigned_p)
4968 printf ("extern unsigned int ");
4970 printf ("extern int ");
4971 /* If the attribute name starts with a star, the remainder is the name of
4972 the subroutine to use, instead of `get_attr_...'. */
4973 if (attr->name[0] == '*')
4974 printf ("%s PARAMS ((rtx));\n", &attr->name[1]);
4976 printf ("get_attr_%s PARAMS ((%s));\n", attr->name,
4977 (attr->is_const ? "void" : "rtx"));
4979 /* Write out start of function, then all values with explicit `case' lines,
4980 then a `default', then the value with the most uses. */
4981 if (!attr->is_numeric)
4982 printf ("enum attr_%s\n", attr->name);
4983 else if (attr->unsigned_p)
4984 printf ("unsigned int\n");
4988 /* If the attribute name starts with a star, the remainder is the name of
4989 the subroutine to use, instead of `get_attr_...'. */
4990 if (attr->name[0] == '*')
4991 printf ("%s (insn)\n", &attr->name[1]);
4992 else if (attr->is_const == 0)
4993 printf ("get_attr_%s (insn)\n", attr->name);
4996 printf ("get_attr_%s ()\n", attr->name);
4999 for (av = attr->first_value; av; av = av->next)
5000 if (av->num_insns != 0)
5001 write_attr_set (attr, 2, av->value, "return", ";",
5002 true_rtx, av->first_insn->insn_code,
5003 av->first_insn->insn_index);
5009 printf (" rtx insn;\n");
5012 if (GET_CODE (common_av->value) == FFS)
5014 rtx p = XEXP (common_av->value, 0);
5016 /* No need to emit code to abort if the insn is unrecognized; the
5017 other get_attr_foo functions will do that when we call them. */
5019 write_toplevel_expr (p);
5021 printf ("\n if (accum && accum == (accum & -accum))\n");
5023 printf (" int i;\n");
5024 printf (" for (i = 0; accum >>= 1; ++i) continue;\n");
5025 printf (" accum = i;\n");
5026 printf (" }\n else\n");
5027 printf (" accum = ~accum;\n");
5028 printf (" return accum;\n}\n\n");
5032 printf (" switch (recog_memoized (insn))\n");
5035 for (av = attr->first_value; av; av = av->next)
5036 if (av != common_av)
5037 write_attr_case (attr, av, 1, "return", ";", 4, true_rtx);
5039 write_attr_case (attr, common_av, 0, "return", ";", 4, true_rtx);
5040 printf (" }\n}\n\n");
5044 /* Given an AND tree of known true terms (because we are inside an `if' with
5045 that as the condition or are in an `else' clause) and an expression,
5046 replace any known true terms with TRUE. Use `simplify_and_tree' to do
5047 the bulk of the work. */
5050 eliminate_known_true (known_true, exp, insn_code, insn_index)
5053 int insn_code, insn_index;
5057 known_true = SIMPLIFY_TEST_EXP (known_true, insn_code, insn_index);
5059 if (GET_CODE (known_true) == AND)
5061 exp = eliminate_known_true (XEXP (known_true, 0), exp,
5062 insn_code, insn_index);
5063 exp = eliminate_known_true (XEXP (known_true, 1), exp,
5064 insn_code, insn_index);
5069 exp = simplify_and_tree (exp, &term, insn_code, insn_index);
5075 /* Write out a series of tests and assignment statements to perform tests and
5076 sets of an attribute value. We are passed an indentation amount and prefix
5077 and suffix strings to write around each attribute value (e.g., "return"
5081 write_attr_set (attr, indent, value, prefix, suffix, known_true,
5082 insn_code, insn_index)
5083 struct attr_desc *attr;
5089 int insn_code, insn_index;
5091 if (GET_CODE (value) == COND)
5093 /* Assume the default value will be the default of the COND unless we
5094 find an always true expression. */
5095 rtx default_val = XEXP (value, 1);
5096 rtx our_known_true = known_true;
5101 for (i = 0; i < XVECLEN (value, 0); i += 2)
5106 testexp = eliminate_known_true (our_known_true,
5107 XVECEXP (value, 0, i),
5108 insn_code, insn_index);
5109 newexp = attr_rtx (NOT, testexp);
5110 newexp = insert_right_side (AND, our_known_true, newexp,
5111 insn_code, insn_index);
5113 /* If the test expression is always true or if the next `known_true'
5114 expression is always false, this is the last case, so break
5115 out and let this value be the `else' case. */
5116 if (testexp == true_rtx || newexp == false_rtx)
5118 default_val = XVECEXP (value, 0, i + 1);
5122 /* Compute the expression to pass to our recursive call as being
5124 inner_true = insert_right_side (AND, our_known_true,
5125 testexp, insn_code, insn_index);
5127 /* If this is always false, skip it. */
5128 if (inner_true == false_rtx)
5131 write_indent (indent);
5132 printf ("%sif ", first_if ? "" : "else ");
5134 write_test_expr (testexp, 0);
5136 write_indent (indent + 2);
5139 write_attr_set (attr, indent + 4,
5140 XVECEXP (value, 0, i + 1), prefix, suffix,
5141 inner_true, insn_code, insn_index);
5142 write_indent (indent + 2);
5144 our_known_true = newexp;
5149 write_indent (indent);
5151 write_indent (indent + 2);
5155 write_attr_set (attr, first_if ? indent : indent + 4, default_val,
5156 prefix, suffix, our_known_true, insn_code, insn_index);
5160 write_indent (indent + 2);
5166 write_indent (indent);
5167 printf ("%s ", prefix);
5168 write_attr_value (attr, value);
5169 printf ("%s\n", suffix);
5173 /* Write out the computation for one attribute value. */
5176 write_attr_case (attr, av, write_case_lines, prefix, suffix, indent,
5178 struct attr_desc *attr;
5179 struct attr_value *av;
5180 int write_case_lines;
5181 const char *prefix, *suffix;
5185 struct insn_ent *ie;
5187 if (av->num_insns == 0)
5190 if (av->has_asm_insn)
5192 write_indent (indent);
5193 printf ("case -1:\n");
5194 write_indent (indent + 2);
5195 printf ("if (GET_CODE (PATTERN (insn)) != ASM_INPUT\n");
5196 write_indent (indent + 2);
5197 printf (" && asm_noperands (PATTERN (insn)) < 0)\n");
5198 write_indent (indent + 2);
5199 printf (" fatal_insn_not_found (insn);\n");
5202 if (write_case_lines)
5204 for (ie = av->first_insn; ie; ie = ie->next)
5205 if (ie->insn_code != -1)
5207 write_indent (indent);
5208 printf ("case %d:\n", ie->insn_code);
5213 write_indent (indent);
5214 printf ("default:\n");
5217 /* See what we have to do to output this value. */
5218 must_extract = must_constrain = address_used = 0;
5219 walk_attr_value (av->value);
5223 write_indent (indent + 2);
5224 printf ("extract_constrain_insn_cached (insn);\n");
5226 else if (must_extract)
5228 write_indent (indent + 2);
5229 printf ("extract_insn_cached (insn);\n");
5232 write_attr_set (attr, indent + 2, av->value, prefix, suffix,
5233 known_true, av->first_insn->insn_code,
5234 av->first_insn->insn_index);
5236 if (strncmp (prefix, "return", 6))
5238 write_indent (indent + 2);
5239 printf ("break;\n");
5244 /* Search for uses of non-const attributes and write code to cache them. */
5247 write_expr_attr_cache (p, attr)
5249 struct attr_desc *attr;
5254 if (GET_CODE (p) == EQ_ATTR)
5256 if (XSTR (p, 0) != attr->name)
5259 if (!attr->is_numeric)
5260 printf (" register enum attr_%s ", attr->name);
5261 else if (attr->unsigned_p)
5262 printf (" register unsigned int ");
5264 printf (" register int ");
5266 printf ("attr_%s = get_attr_%s (insn);\n", attr->name, attr->name);
5270 fmt = GET_RTX_FORMAT (GET_CODE (p));
5271 ie = GET_RTX_LENGTH (GET_CODE (p));
5272 for (i = 0; i < ie; i++)
5277 if (write_expr_attr_cache (XEXP (p, i), attr))
5282 je = XVECLEN (p, i);
5283 for (j = 0; j < je; ++j)
5284 if (write_expr_attr_cache (XVECEXP (p, i, j), attr))
5293 /* Evaluate an expression at top level. A front end to write_test_expr,
5294 in which we cache attribute values and break up excessively large
5295 expressions to cater to older compilers. */
5298 write_toplevel_expr (p)
5301 struct attr_desc *attr;
5304 for (i = 0; i < MAX_ATTRS_INDEX; ++i)
5305 for (attr = attrs[i]; attr; attr = attr->next)
5306 if (!attr->is_const)
5307 write_expr_attr_cache (p, attr);
5309 printf (" register unsigned long accum = 0;\n\n");
5311 while (GET_CODE (p) == IOR)
5314 if (GET_CODE (XEXP (p, 0)) == IOR)
5315 e = XEXP (p, 1), p = XEXP (p, 0);
5317 e = XEXP (p, 0), p = XEXP (p, 1);
5319 printf (" accum |= ");
5320 write_test_expr (e, 3);
5323 printf (" accum |= ");
5324 write_test_expr (p, 3);
5328 /* Utilities to write names in various forms. */
5331 write_unit_name (prefix, num, suffix)
5336 struct function_unit *unit;
5338 for (unit = units; unit; unit = unit->next)
5339 if (unit->num == num)
5341 printf ("%s%s%s", prefix, unit->name, suffix);
5345 printf ("%s<unknown>%s", prefix, suffix);
5349 write_attr_valueq (attr, s)
5350 struct attr_desc *attr;
5353 if (attr->is_numeric)
5359 /* Make the blockage range values and function units used values easier
5361 if (attr->func_units_p)
5364 printf (" /* units: none */");
5366 write_unit_name (" /* units: ", num, " */");
5370 const char *sep = " /* units: ";
5371 for (i = 0, num = ~num; num; i++, num >>= 1)
5374 write_unit_name (sep, i, (num == 1) ? " */" : "");
5380 else if (attr->blockage_p)
5381 printf (" /* min %d, max %d */", num >> (HOST_BITS_PER_INT / 2),
5382 num & ((1 << (HOST_BITS_PER_INT / 2)) - 1));
5384 else if (num > 9 || num < 0)
5385 printf (" /* 0x%x */", num);
5389 write_upcase (attr->name);
5396 write_attr_value (attr, value)
5397 struct attr_desc *attr;
5402 switch (GET_CODE (value))
5405 write_attr_valueq (attr, XSTR (value, 0));
5409 printf (HOST_WIDE_INT_PRINT_DEC, INTVAL (value));
5413 fputs (XSTR (value, 0), stdout);
5418 struct attr_desc *attr2 = find_attr (XSTR (value, 0), 0);
5419 printf ("get_attr_%s (%s)", attr2->name,
5420 (attr2->is_const ? "" : "insn"));
5441 write_attr_value (attr, XEXP (value, 0));
5445 write_attr_value (attr, XEXP (value, 1));
5459 /* The argument of TOUPPER should not have side effects. */
5460 putchar (TOUPPER(*str));
5466 write_indent (indent)
5469 for (; indent > 8; indent -= 8)
5472 for (; indent; indent--)
5476 /* Write a subroutine that is given an insn that requires a delay slot, a
5477 delay slot ordinal, and a candidate insn. It returns non-zero if the
5478 candidate can be placed in the specified delay slot of the insn.
5480 We can write as many as three subroutines. `eligible_for_delay'
5481 handles normal delay slots, `eligible_for_annul_true' indicates that
5482 the specified insn can be annulled if the branch is true, and likewise
5483 for `eligible_for_annul_false'.
5485 KIND is a string distinguishing these three cases ("delay", "annul_true",
5486 or "annul_false"). */
5489 write_eligible_delay (kind)
5492 struct delay_desc *delay;
5495 struct attr_desc *attr;
5496 struct attr_value *av, *common_av;
5499 /* Compute the maximum number of delay slots required. We use the delay
5500 ordinal times this number plus one, plus the slot number as an index into
5501 the appropriate predicate to test. */
5503 for (delay = delays, max_slots = 0; delay; delay = delay->next)
5504 if (XVECLEN (delay->def, 1) / 3 > max_slots)
5505 max_slots = XVECLEN (delay->def, 1) / 3;
5507 /* Write function prelude. */
5510 printf ("eligible_for_%s (delay_insn, slot, candidate_insn, flags)\n",
5512 printf (" rtx delay_insn;\n");
5513 printf (" int slot;\n");
5514 printf (" rtx candidate_insn;\n");
5515 printf (" int flags ATTRIBUTE_UNUSED;\n");
5517 printf (" rtx insn;\n");
5519 printf (" if (slot >= %d)\n", max_slots);
5520 printf (" abort ();\n");
5523 /* If more than one delay type, find out which type the delay insn is. */
5527 attr = find_attr ("*delay_type", 0);
5530 common_av = find_most_used (attr);
5532 printf (" insn = delay_insn;\n");
5533 printf (" switch (recog_memoized (insn))\n");
5536 sprintf (str, " * %d;\n break;", max_slots);
5537 for (av = attr->first_value; av; av = av->next)
5538 if (av != common_av)
5539 write_attr_case (attr, av, 1, "slot +=", str, 4, true_rtx);
5541 write_attr_case (attr, common_av, 0, "slot +=", str, 4, true_rtx);
5544 /* Ensure matched. Otherwise, shouldn't have been called. */
5545 printf (" if (slot < %d)\n", max_slots);
5546 printf (" abort ();\n\n");
5549 /* If just one type of delay slot, write simple switch. */
5550 if (num_delays == 1 && max_slots == 1)
5552 printf (" insn = candidate_insn;\n");
5553 printf (" switch (recog_memoized (insn))\n");
5556 attr = find_attr ("*delay_1_0", 0);
5559 common_av = find_most_used (attr);
5561 for (av = attr->first_value; av; av = av->next)
5562 if (av != common_av)
5563 write_attr_case (attr, av, 1, "return", ";", 4, true_rtx);
5565 write_attr_case (attr, common_av, 0, "return", ";", 4, true_rtx);
5571 /* Write a nested CASE. The first indicates which condition we need to
5572 test, and the inner CASE tests the condition. */
5573 printf (" insn = candidate_insn;\n");
5574 printf (" switch (slot)\n");
5577 for (delay = delays; delay; delay = delay->next)
5578 for (i = 0; i < XVECLEN (delay->def, 1); i += 3)
5580 printf (" case %d:\n",
5581 (i / 3) + (num_delays == 1 ? 0 : delay->num * max_slots));
5582 printf (" switch (recog_memoized (insn))\n");
5585 sprintf (str, "*%s_%d_%d", kind, delay->num, i / 3);
5586 attr = find_attr (str, 0);
5589 common_av = find_most_used (attr);
5591 for (av = attr->first_value; av; av = av->next)
5592 if (av != common_av)
5593 write_attr_case (attr, av, 1, "return", ";", 8, true_rtx);
5595 write_attr_case (attr, common_av, 0, "return", ";", 8, true_rtx);
5599 printf (" default:\n");
5600 printf (" abort ();\n");
5607 /* Write routines to compute conflict cost for function units. Then write a
5608 table describing the available function units. */
5611 write_function_unit_info ()
5613 struct function_unit *unit;
5616 /* Write out conflict routines for function units. Don't bother writing
5617 one if there is only one issue delay value. */
5619 for (unit = units; unit; unit = unit->next)
5621 if (unit->needs_blockage_function)
5622 write_complex_function (unit, "blockage", "block");
5624 /* If the minimum and maximum conflict costs are the same, there
5625 is only one value, so we don't need a function. */
5626 if (! unit->needs_conflict_function)
5628 unit->default_cost = make_numeric_value (unit->issue_delay.max);
5632 /* The function first computes the case from the candidate insn. */
5633 unit->default_cost = make_numeric_value (0);
5634 write_complex_function (unit, "conflict_cost", "cost");
5637 /* Now that all functions have been written, write the table describing
5638 the function units. The name is included for documentation purposes
5641 printf ("struct function_unit_desc function_units[] = {\n");
5643 /* Write out the descriptions in numeric order, but don't force that order
5644 on the list. Doing so increases the runtime of genattrtab.c. */
5645 for (i = 0; i < num_units; i++)
5647 for (unit = units; unit; unit = unit->next)
5651 printf (" {\"%s\", %d, %d, %d, %s, %d, %s_unit_ready_cost, ",
5652 unit->name, 1 << unit->num, unit->multiplicity,
5653 unit->simultaneity, XSTR (unit->default_cost, 0),
5654 unit->issue_delay.max, unit->name);
5656 if (unit->needs_conflict_function)
5657 printf ("%s_unit_conflict_cost, ", unit->name);
5661 printf ("%d, ", unit->max_blockage);
5663 if (unit->needs_range_function)
5664 printf ("%s_unit_blockage_range, ", unit->name);
5668 if (unit->needs_blockage_function)
5669 printf ("%s_unit_blockage", unit->name);
5680 write_complex_function (unit, name, connection)
5681 struct function_unit *unit;
5682 const char *name, *connection;
5684 struct attr_desc *case_attr, *attr;
5685 struct attr_value *av, *common_av;
5691 printf ("static int %s_unit_%s PARAMS ((rtx, rtx));\n", unit->name, name);
5692 printf ("static int\n");
5693 printf ("%s_unit_%s (executing_insn, candidate_insn)\n", unit->name, name);
5694 printf (" rtx executing_insn;\n");
5695 printf (" rtx candidate_insn;\n");
5697 printf (" rtx insn;\n");
5698 printf (" int casenum;\n\n");
5699 printf (" insn = executing_insn;\n");
5700 printf (" switch (recog_memoized (insn))\n");
5703 /* Write the `switch' statement to get the case value. */
5704 str = (char *) alloca (strlen (unit->name) + strlen (name) + strlen (connection) + 10);
5705 sprintf (str, "*%s_cases", unit->name);
5706 case_attr = find_attr (str, 0);
5709 common_av = find_most_used (case_attr);
5711 for (av = case_attr->first_value; av; av = av->next)
5712 if (av != common_av)
5713 write_attr_case (case_attr, av, 1,
5714 "casenum =", ";", 4, unit->condexp);
5716 write_attr_case (case_attr, common_av, 0,
5717 "casenum =", ";", 4, unit->condexp);
5720 /* Now write an outer switch statement on each case. Then write
5721 the tests on the executing function within each. */
5722 printf (" insn = candidate_insn;\n");
5723 printf (" switch (casenum)\n");
5726 for (i = 0; i < unit->num_opclasses; i++)
5728 /* Ensure using this case. */
5730 for (av = case_attr->first_value; av; av = av->next)
5732 && contained_in_p (make_numeric_value (i), av->value))
5738 printf (" case %d:\n", i);
5739 sprintf (str, "*%s_%s_%d", unit->name, connection, i);
5740 attr = find_attr (str, 0);
5744 /* If single value, just write it. */
5745 value = find_single_value (attr);
5747 write_attr_set (attr, 6, value, "return", ";\n", true_rtx, -2, -2);
5750 common_av = find_most_used (attr);
5751 printf (" switch (recog_memoized (insn))\n");
5754 for (av = attr->first_value; av; av = av->next)
5755 if (av != common_av)
5756 write_attr_case (attr, av, 1,
5757 "return", ";", 8, unit->condexp);
5759 write_attr_case (attr, common_av, 0,
5760 "return", ";", 8, unit->condexp);
5765 /* This default case should not be needed, but gcc's analysis is not
5766 good enough to realize that the default case is not needed for the
5767 second switch statement. */
5768 printf (" default:\n abort ();\n");
5769 printf (" }\n}\n\n");
5772 /* This page contains miscellaneous utility routines. */
5774 /* Given a string, return the number of comma-separated elements in it.
5775 Return 0 for the null string. */
5786 for (n = 1; *s; s++)
5793 /* Given a pointer to a (char *), return a malloc'ed string containing the
5794 next comma-separated element. Advance the pointer to after the string
5795 scanned, or the end-of-string. Return NULL if at end of string. */
5798 next_comma_elt (pstr)
5807 /* Find end of string to compute length. */
5808 for (p = *pstr; *p != ',' && *p != '\0'; p++)
5811 out_str = attr_string (*pstr, p - *pstr);
5820 /* Return a `struct attr_desc' pointer for a given named attribute. If CREATE
5821 is non-zero, build a new attribute, if one does not exist. */
5823 static struct attr_desc *
5824 find_attr (name, create)
5828 struct attr_desc *attr;
5831 /* Before we resort to using `strcmp', see if the string address matches
5832 anywhere. In most cases, it should have been canonicalized to do so. */
5833 if (name == alternative_name)
5836 index = name[0] & (MAX_ATTRS_INDEX - 1);
5837 for (attr = attrs[index]; attr; attr = attr->next)
5838 if (name == attr->name)
5841 /* Otherwise, do it the slow way. */
5842 for (attr = attrs[index]; attr; attr = attr->next)
5843 if (name[0] == attr->name[0] && ! strcmp (name, attr->name))
5849 attr = (struct attr_desc *) oballoc (sizeof (struct attr_desc));
5850 attr->name = attr_string (name, strlen (name));
5851 attr->first_value = attr->default_val = NULL;
5852 attr->is_numeric = attr->negative_ok = attr->is_const = attr->is_special = 0;
5853 attr->unsigned_p = attr->func_units_p = attr->blockage_p = 0;
5854 attr->next = attrs[index];
5855 attrs[index] = attr;
5860 /* Create internal attribute with the given default value. */
5863 make_internal_attr (name, value, special)
5868 struct attr_desc *attr;
5870 attr = find_attr (name, 1);
5871 if (attr->default_val)
5874 attr->is_numeric = 1;
5876 attr->is_special = (special & 1) != 0;
5877 attr->negative_ok = (special & 2) != 0;
5878 attr->unsigned_p = (special & 4) != 0;
5879 attr->func_units_p = (special & 8) != 0;
5880 attr->blockage_p = (special & 16) != 0;
5881 attr->default_val = get_attr_value (value, attr, -2);
5884 /* Find the most used value of an attribute. */
5886 static struct attr_value *
5887 find_most_used (attr)
5888 struct attr_desc *attr;
5890 struct attr_value *av;
5891 struct attr_value *most_used;
5897 for (av = attr->first_value; av; av = av->next)
5898 if (av->num_insns > nuses)
5899 nuses = av->num_insns, most_used = av;
5904 /* If an attribute only has a single value used, return it. Otherwise
5908 find_single_value (attr)
5909 struct attr_desc *attr;
5911 struct attr_value *av;
5914 unique_value = NULL;
5915 for (av = attr->first_value; av; av = av->next)
5921 unique_value = av->value;
5924 return unique_value;
5927 /* Return (attr_value "n") */
5930 make_numeric_value (n)
5933 static rtx int_values[20];
5940 if (n < 20 && int_values[n])
5941 return int_values[n];
5943 p = attr_printf (MAX_DIGITS, "%d", n);
5944 exp = attr_rtx (CONST_STRING, p);
5947 int_values[n] = exp;
5953 extend_range (range, min, max)
5954 struct range *range;
5958 if (range->min > min)
5960 if (range->max < max)
5965 copy_rtx_unchanging (orig)
5970 register RTX_CODE code;
5973 if (RTX_UNCHANGING_P (orig) || MEM_IN_STRUCT_P (orig))
5976 MEM_IN_STRUCT_P (orig) = 1;
5980 code = GET_CODE (orig);
5993 copy = rtx_alloc (code);
5994 PUT_MODE (copy, GET_MODE (orig));
5995 RTX_UNCHANGING_P (copy) = 1;
5997 bcopy ((char *) &XEXP (orig, 0), (char *) &XEXP (copy, 0),
5998 GET_RTX_LENGTH (GET_CODE (copy)) * sizeof (rtx));
6003 /* Determine if an insn has a constant number of delay slots, i.e., the
6004 number of delay slots is not a function of the length of the insn. */
6007 write_const_num_delay_slots ()
6009 struct attr_desc *attr = find_attr ("*num_delay_slots", 0);
6010 struct attr_value *av;
6011 struct insn_ent *ie;
6015 printf ("int\nconst_num_delay_slots (insn)\n");
6016 printf (" rtx insn;\n");
6018 printf (" switch (recog_memoized (insn))\n");
6021 for (av = attr->first_value; av; av = av->next)
6024 walk_attr_value (av->value);
6027 for (ie = av->first_insn; ie; ie = ie->next)
6028 if (ie->insn_code != -1)
6029 printf (" case %d:\n", ie->insn_code);
6030 printf (" return 0;\n");
6034 printf (" default:\n");
6035 printf (" return 1;\n");
6036 printf (" }\n}\n\n");
6040 extern int main PARAMS ((int, char **));
6048 struct attr_desc *attr;
6049 struct insn_def *id;
6053 progname = "genattrtab";
6056 fatal ("No input file name.");
6058 #if defined (RLIMIT_STACK) && defined (HAVE_GETRLIMIT) && defined (HAVE_SETRLIMIT)
6059 /* Get rid of any avoidable limit on stack size. */
6063 /* Set the stack limit huge so that alloca does not fail. */
6064 getrlimit (RLIMIT_STACK, &rlim);
6065 rlim.rlim_cur = rlim.rlim_max;
6066 setrlimit (RLIMIT_STACK, &rlim);
6070 if (init_md_reader (argv[1]) != SUCCESS_EXIT_CODE)
6071 return (FATAL_EXIT_CODE);
6073 obstack_init (hash_obstack);
6074 obstack_init (temp_obstack);
6076 /* Set up true and false rtx's */
6077 true_rtx = rtx_alloc (CONST_INT);
6078 XWINT (true_rtx, 0) = 1;
6079 false_rtx = rtx_alloc (CONST_INT);
6080 XWINT (false_rtx, 0) = 0;
6081 RTX_UNCHANGING_P (true_rtx) = RTX_UNCHANGING_P (false_rtx) = 1;
6082 RTX_INTEGRATED_P (true_rtx) = RTX_INTEGRATED_P (false_rtx) = 1;
6084 alternative_name = attr_string ("alternative", strlen ("alternative"));
6086 printf ("/* Generated automatically by the program `genattrtab'\n\
6087 from the machine description file `md'. */\n\n");
6089 /* Read the machine description. */
6095 desc = read_md_rtx (&lineno, &insn_code_number);
6099 switch (GET_CODE (desc))
6102 case DEFINE_PEEPHOLE:
6103 case DEFINE_ASM_ATTRIBUTES:
6104 gen_insn (desc, lineno);
6108 gen_attr (desc, lineno);
6112 gen_delay (desc, lineno);
6115 case DEFINE_FUNCTION_UNIT:
6116 gen_unit (desc, lineno);
6122 if (GET_CODE (desc) != DEFINE_ASM_ATTRIBUTES)
6123 insn_index_number++;
6127 return FATAL_EXIT_CODE;
6131 /* If we didn't have a DEFINE_ASM_ATTRIBUTES, make a null one. */
6132 if (! got_define_asm_attributes)
6134 tem = rtx_alloc (DEFINE_ASM_ATTRIBUTES);
6135 XVEC (tem, 0) = rtvec_alloc (0);
6139 /* Expand DEFINE_DELAY information into new attribute. */
6143 /* Expand DEFINE_FUNCTION_UNIT information into new attributes. */
6147 printf ("#include \"config.h\"\n");
6148 printf ("#include \"system.h\"\n");
6149 printf ("#include \"rtl.h\"\n");
6150 printf ("#include \"tm_p.h\"\n");
6151 printf ("#include \"insn-config.h\"\n");
6152 printf ("#include \"recog.h\"\n");
6153 printf ("#include \"regs.h\"\n");
6154 printf ("#include \"real.h\"\n");
6155 printf ("#include \"output.h\"\n");
6156 printf ("#include \"insn-attr.h\"\n");
6157 printf ("#include \"toplev.h\"\n");
6159 printf ("#define operands recog_data.operand\n\n");
6161 /* Make `insn_alternatives'. */
6162 insn_alternatives = (int *) oballoc (insn_code_number * sizeof (int));
6163 for (id = defs; id; id = id->next)
6164 if (id->insn_code >= 0)
6165 insn_alternatives[id->insn_code] = (1 << id->num_alternatives) - 1;
6167 /* Make `insn_n_alternatives'. */
6168 insn_n_alternatives = (int *) oballoc (insn_code_number * sizeof (int));
6169 for (id = defs; id; id = id->next)
6170 if (id->insn_code >= 0)
6171 insn_n_alternatives[id->insn_code] = id->num_alternatives;
6173 /* Prepare to write out attribute subroutines by checking everything stored
6174 away and building the attribute cases. */
6178 for (i = 0; i < MAX_ATTRS_INDEX; i++)
6179 for (attr = attrs[i]; attr; attr = attr->next)
6180 attr->default_val->value
6181 = check_attr_value (attr->default_val->value, attr);
6184 return FATAL_EXIT_CODE;
6186 for (i = 0; i < MAX_ATTRS_INDEX; i++)
6187 for (attr = attrs[i]; attr; attr = attr->next)
6190 /* Construct extra attributes for `length'. */
6191 make_length_attrs ();
6193 /* Perform any possible optimizations to speed up compilation. */
6196 /* Now write out all the `gen_attr_...' routines. Do these before the
6197 special routines (specifically before write_function_unit_info), so
6198 that they get defined before they are used. */
6200 for (i = 0; i < MAX_ATTRS_INDEX; i++)
6201 for (attr = attrs[i]; attr; attr = attr->next)
6203 if (! attr->is_special && ! attr->is_const)
6204 write_attr_get (attr);
6207 /* Write out delay eligibility information, if DEFINE_DELAY present.
6208 (The function to compute the number of delay slots will be written
6212 write_eligible_delay ("delay");
6213 if (have_annul_true)
6214 write_eligible_delay ("annul_true");
6215 if (have_annul_false)
6216 write_eligible_delay ("annul_false");
6219 /* Write out information about function units. */
6221 write_function_unit_info ();
6223 /* Write out constant delay slot info */
6224 write_const_num_delay_slots ();
6226 write_length_unit_log ();
6229 return (ferror (stdout) != 0 ? FATAL_EXIT_CODE : SUCCESS_EXIT_CODE);
6232 /* Define this so we can link with print-rtl.o to get debug_rtx function. */
6234 get_insn_name (code)
6235 int code ATTRIBUTE_UNUSED;