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 GCC.
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 2, or (at your option) any later
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING. If not, write to the Free
20 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
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 rtx simplify_test_exp_in_temp PARAMS ((rtx, int, int));
421 static void optimize_attrs PARAMS ((void));
422 static void gen_attr PARAMS ((rtx, int));
423 static int count_alternatives PARAMS ((rtx));
424 static int compares_alternatives_p PARAMS ((rtx));
425 static int contained_in_p PARAMS ((rtx, rtx));
426 static void gen_insn PARAMS ((rtx, int));
427 static void gen_delay PARAMS ((rtx, int));
428 static void gen_unit PARAMS ((rtx, int));
429 static void write_test_expr PARAMS ((rtx, int));
430 static int max_attr_value PARAMS ((rtx, int*));
431 static int or_attr_value PARAMS ((rtx, int*));
432 static void walk_attr_value PARAMS ((rtx));
433 static void write_attr_get PARAMS ((struct attr_desc *));
434 static rtx eliminate_known_true PARAMS ((rtx, rtx, int, int));
435 static void write_attr_set PARAMS ((struct attr_desc *, int, rtx,
436 const char *, const char *, rtx,
438 static void write_attr_case PARAMS ((struct attr_desc *, struct attr_value *,
439 int, const char *, const char *, int, rtx));
440 static void write_unit_name PARAMS ((const char *, int, const char *));
441 static void write_attr_valueq PARAMS ((struct attr_desc *, const char *));
442 static void write_attr_value PARAMS ((struct attr_desc *, rtx));
443 static void write_upcase PARAMS ((const char *));
444 static void write_indent PARAMS ((int));
445 static void write_eligible_delay PARAMS ((const char *));
446 static void write_function_unit_info PARAMS ((void));
447 static void write_complex_function PARAMS ((struct function_unit *, const char *,
449 static int write_expr_attr_cache PARAMS ((rtx, struct attr_desc *));
450 static void write_toplevel_expr PARAMS ((rtx));
451 static void write_const_num_delay_slots PARAMS ((void));
452 static int n_comma_elts PARAMS ((const char *));
453 static char *next_comma_elt PARAMS ((const char **));
454 static struct attr_desc *find_attr PARAMS ((const char *, int));
455 static void make_internal_attr PARAMS ((const char *, rtx, int));
456 static struct attr_value *find_most_used PARAMS ((struct attr_desc *));
457 static rtx find_single_value PARAMS ((struct attr_desc *));
458 static rtx make_numeric_value PARAMS ((int));
459 static void extend_range PARAMS ((struct range *, int, int));
460 static rtx attr_eq PARAMS ((const char *, const char *));
461 static const char *attr_numeral PARAMS ((int));
462 static int attr_equal_p PARAMS ((rtx, rtx));
463 static rtx attr_copy_rtx PARAMS ((rtx));
464 static int attr_rtx_cost PARAMS ((rtx));
466 #define oballoc(size) obstack_alloc (hash_obstack, size)
468 /* Hash table for sharing RTL and strings. */
470 /* Each hash table slot is a bucket containing a chain of these structures.
471 Strings are given negative hash codes; RTL expressions are given positive
476 struct attr_hash *next; /* Next structure in the bucket. */
477 int hashcode; /* Hash code of this rtx or string. */
480 char *str; /* The string (negative hash codes) */
481 rtx rtl; /* or the RTL recorded here. */
485 /* Now here is the hash table. When recording an RTL, it is added to
486 the slot whose index is the hash code mod the table size. Note
487 that the hash table is used for several kinds of RTL (see attr_rtx)
488 and for strings. While all these live in the same table, they are
489 completely independent, and the hash code is computed differently
492 #define RTL_HASH_SIZE 4093
493 struct attr_hash *attr_hash_table[RTL_HASH_SIZE];
495 /* Here is how primitive or already-shared RTL's hash
497 #define RTL_HASH(RTL) ((long) (RTL) & 0777777)
499 /* Add an entry to the hash table for RTL with hash code HASHCODE. */
502 attr_hash_add_rtx (hashcode, rtl)
506 register struct attr_hash *h;
508 h = (struct attr_hash *) obstack_alloc (hash_obstack,
509 sizeof (struct attr_hash));
510 h->hashcode = hashcode;
512 h->next = attr_hash_table[hashcode % RTL_HASH_SIZE];
513 attr_hash_table[hashcode % RTL_HASH_SIZE] = h;
516 /* Add an entry to the hash table for STRING with hash code HASHCODE. */
519 attr_hash_add_string (hashcode, str)
523 register struct attr_hash *h;
525 h = (struct attr_hash *) obstack_alloc (hash_obstack,
526 sizeof (struct attr_hash));
527 h->hashcode = -hashcode;
529 h->next = attr_hash_table[hashcode % RTL_HASH_SIZE];
530 attr_hash_table[hashcode % RTL_HASH_SIZE] = h;
533 /* Generate an RTL expression, but avoid duplicates.
534 Set the RTX_INTEGRATED_P flag for these permanent objects.
536 In some cases we cannot uniquify; then we return an ordinary
537 impermanent rtx with RTX_INTEGRATED_P clear.
539 Args are like gen_rtx, but without the mode:
541 rtx attr_rtx (code, [element1, ..., elementn]) */
544 attr_rtx VPARAMS ((enum rtx_code code, ...))
546 #ifndef ANSI_PROTOTYPES
550 register int i; /* Array indices... */
551 register const char *fmt; /* Current rtx's format... */
552 register rtx rt_val = NULL_RTX;/* RTX to return to caller... */
554 register struct attr_hash *h;
555 struct obstack *old_obstack = rtl_obstack;
559 #ifndef ANSI_PROTOTYPES
560 code = va_arg (p, enum rtx_code);
563 /* For each of several cases, search the hash table for an existing entry.
564 Use that entry if one is found; otherwise create a new RTL and add it
567 if (GET_RTX_CLASS (code) == '1')
569 rtx arg0 = va_arg (p, rtx);
571 /* A permanent object cannot point to impermanent ones. */
572 if (! RTX_INTEGRATED_P (arg0))
574 rt_val = rtx_alloc (code);
575 XEXP (rt_val, 0) = arg0;
580 hashcode = ((HOST_WIDE_INT) code + RTL_HASH (arg0));
581 for (h = attr_hash_table[hashcode % RTL_HASH_SIZE]; h; h = h->next)
582 if (h->hashcode == hashcode
583 && GET_CODE (h->u.rtl) == code
584 && XEXP (h->u.rtl, 0) == arg0)
589 rtl_obstack = hash_obstack;
590 rt_val = rtx_alloc (code);
591 XEXP (rt_val, 0) = arg0;
594 else if (GET_RTX_CLASS (code) == 'c'
595 || GET_RTX_CLASS (code) == '2'
596 || GET_RTX_CLASS (code) == '<')
598 rtx arg0 = va_arg (p, rtx);
599 rtx arg1 = va_arg (p, rtx);
601 /* A permanent object cannot point to impermanent ones. */
602 if (! RTX_INTEGRATED_P (arg0) || ! RTX_INTEGRATED_P (arg1))
604 rt_val = rtx_alloc (code);
605 XEXP (rt_val, 0) = arg0;
606 XEXP (rt_val, 1) = arg1;
611 hashcode = ((HOST_WIDE_INT) code + RTL_HASH (arg0) + RTL_HASH (arg1));
612 for (h = attr_hash_table[hashcode % RTL_HASH_SIZE]; h; h = h->next)
613 if (h->hashcode == hashcode
614 && GET_CODE (h->u.rtl) == code
615 && XEXP (h->u.rtl, 0) == arg0
616 && XEXP (h->u.rtl, 1) == arg1)
621 rtl_obstack = hash_obstack;
622 rt_val = rtx_alloc (code);
623 XEXP (rt_val, 0) = arg0;
624 XEXP (rt_val, 1) = arg1;
627 else if (GET_RTX_LENGTH (code) == 1
628 && GET_RTX_FORMAT (code)[0] == 's')
630 char *arg0 = va_arg (p, char *);
632 if (code == SYMBOL_REF)
633 arg0 = attr_string (arg0, strlen (arg0));
635 hashcode = ((HOST_WIDE_INT) code + RTL_HASH (arg0));
636 for (h = attr_hash_table[hashcode % RTL_HASH_SIZE]; h; h = h->next)
637 if (h->hashcode == hashcode
638 && GET_CODE (h->u.rtl) == code
639 && XSTR (h->u.rtl, 0) == arg0)
644 rtl_obstack = hash_obstack;
645 rt_val = rtx_alloc (code);
646 XSTR (rt_val, 0) = arg0;
649 else if (GET_RTX_LENGTH (code) == 2
650 && GET_RTX_FORMAT (code)[0] == 's'
651 && GET_RTX_FORMAT (code)[1] == 's')
653 char *arg0 = va_arg (p, char *);
654 char *arg1 = va_arg (p, char *);
656 hashcode = ((HOST_WIDE_INT) code + RTL_HASH (arg0) + RTL_HASH (arg1));
657 for (h = attr_hash_table[hashcode % RTL_HASH_SIZE]; h; h = h->next)
658 if (h->hashcode == hashcode
659 && GET_CODE (h->u.rtl) == code
660 && XSTR (h->u.rtl, 0) == arg0
661 && XSTR (h->u.rtl, 1) == arg1)
666 rtl_obstack = hash_obstack;
667 rt_val = rtx_alloc (code);
668 XSTR (rt_val, 0) = arg0;
669 XSTR (rt_val, 1) = arg1;
672 else if (code == CONST_INT)
674 HOST_WIDE_INT arg0 = va_arg (p, HOST_WIDE_INT);
690 rt_val = rtx_alloc (code); /* Allocate the storage space. */
692 fmt = GET_RTX_FORMAT (code); /* Find the right format... */
693 for (i = 0; i < GET_RTX_LENGTH (code); i++)
697 case '0': /* Unused field. */
700 case 'i': /* An integer? */
701 XINT (rt_val, i) = va_arg (p, int);
704 case 'w': /* A wide integer? */
705 XWINT (rt_val, i) = va_arg (p, HOST_WIDE_INT);
708 case 's': /* A string? */
709 XSTR (rt_val, i) = va_arg (p, char *);
712 case 'e': /* An expression? */
713 case 'u': /* An insn? Same except when printing. */
714 XEXP (rt_val, i) = va_arg (p, rtx);
717 case 'E': /* An RTX vector? */
718 XVEC (rt_val, i) = va_arg (p, rtvec);
729 rtl_obstack = old_obstack;
731 attr_hash_add_rtx (hashcode, rt_val);
732 RTX_INTEGRATED_P (rt_val) = 1;
740 /* Create a new string printed with the printf line arguments into a space
741 of at most LEN bytes:
743 rtx attr_printf (len, format, [arg1, ..., argn]) */
746 attr_printf VPARAMS ((register int len, const char *fmt, ...))
751 VA_FIXEDARG (p, int, len);
752 VA_FIXEDARG (p, const char *, fmt);
754 if (len > (sizeof(str) - 1)) /* leave room for \0 */
757 vsprintf (str, fmt, p);
760 return attr_string (str, strlen (str));
764 attr_eq (name, value)
765 const char *name, *value;
767 return attr_rtx (EQ_ATTR, attr_string (name, strlen (name)),
768 attr_string (value, strlen (value)));
775 return XSTR (make_numeric_value (n), 0);
778 /* Return a permanent (possibly shared) copy of a string STR (not assumed
779 to be null terminated) with LEN bytes. */
782 attr_string (str, len)
786 register struct attr_hash *h;
789 register char *new_str;
791 /* Compute the hash code. */
792 hashcode = (len + 1) * 613 + (unsigned) str[0];
793 for (i = 1; i <= len; i += 2)
794 hashcode = ((hashcode * 613) + (unsigned) str[i]);
796 hashcode = -hashcode;
798 /* Search the table for the string. */
799 for (h = attr_hash_table[hashcode % RTL_HASH_SIZE]; h; h = h->next)
800 if (h->hashcode == -hashcode && h->u.str[0] == str[0]
801 && !strncmp (h->u.str, str, len))
802 return h->u.str; /* <-- return if found. */
804 /* Not found; create a permanent copy and add it to the hash table. */
805 new_str = (char *) obstack_alloc (hash_obstack, len + 1);
806 memcpy (new_str, str, len);
808 attr_hash_add_string (hashcode, new_str);
810 return new_str; /* Return the new string. */
813 /* Check two rtx's for equality of contents,
814 taking advantage of the fact that if both are hashed
815 then they can't be equal unless they are the same object. */
821 return (x == y || (! (RTX_INTEGRATED_P (x) && RTX_INTEGRATED_P (y))
822 && rtx_equal_p (x, y)));
825 /* Copy an attribute value expression,
826 descending to all depths, but not copying any
827 permanent hashed subexpressions. */
835 register RTX_CODE code;
836 register const char *format_ptr;
838 /* No need to copy a permanent object. */
839 if (RTX_INTEGRATED_P (orig))
842 code = GET_CODE (orig);
860 copy = rtx_alloc (code);
861 PUT_MODE (copy, GET_MODE (orig));
862 copy->in_struct = orig->in_struct;
863 copy->volatil = orig->volatil;
864 copy->unchanging = orig->unchanging;
865 copy->integrated = orig->integrated;
867 format_ptr = GET_RTX_FORMAT (GET_CODE (copy));
869 for (i = 0; i < GET_RTX_LENGTH (GET_CODE (copy)); i++)
871 switch (*format_ptr++)
874 XEXP (copy, i) = XEXP (orig, i);
875 if (XEXP (orig, i) != NULL)
876 XEXP (copy, i) = attr_copy_rtx (XEXP (orig, i));
881 XVEC (copy, i) = XVEC (orig, i);
882 if (XVEC (orig, i) != NULL)
884 XVEC (copy, i) = rtvec_alloc (XVECLEN (orig, i));
885 for (j = 0; j < XVECLEN (copy, i); j++)
886 XVECEXP (copy, i, j) = attr_copy_rtx (XVECEXP (orig, i, j));
892 XINT (copy, i) = XINT (orig, i);
896 XWINT (copy, i) = XWINT (orig, i);
901 XSTR (copy, i) = XSTR (orig, i);
911 /* Given a test expression for an attribute, ensure it is validly formed.
912 IS_CONST indicates whether the expression is constant for each compiler
913 run (a constant expression may not test any particular insn).
915 Convert (eq_attr "att" "a1,a2") to (ior (eq_attr ... ) (eq_attrq ..))
916 and (eq_attr "att" "!a1") to (not (eq_attr "att" "a1")). Do the latter
917 test first so that (eq_attr "att" "!a1,a2,a3") works as expected.
919 Update the string address in EQ_ATTR expression to be the same used
920 in the attribute (or `alternative_name') to speed up subsequent
921 `find_attr' calls and eliminate most `strcmp' calls.
923 Return the new expression, if any. */
926 check_attr_test (exp, is_const, lineno)
931 struct attr_desc *attr;
932 struct attr_value *av;
933 const char *name_ptr, *p;
936 switch (GET_CODE (exp))
939 /* Handle negation test. */
940 if (XSTR (exp, 1)[0] == '!')
941 return check_attr_test (attr_rtx (NOT,
942 attr_eq (XSTR (exp, 0),
946 else if (n_comma_elts (XSTR (exp, 1)) == 1)
948 attr = find_attr (XSTR (exp, 0), 0);
951 if (! strcmp (XSTR (exp, 0), "alternative"))
953 XSTR (exp, 0) = alternative_name;
954 /* This can't be simplified any further. */
955 RTX_UNCHANGING_P (exp) = 1;
959 fatal ("Unknown attribute `%s' in EQ_ATTR", XSTR (exp, 0));
962 if (is_const && ! attr->is_const)
963 fatal ("Constant expression uses insn attribute `%s' in EQ_ATTR",
966 /* Copy this just to make it permanent,
967 so expressions using it can be permanent too. */
968 exp = attr_eq (XSTR (exp, 0), XSTR (exp, 1));
970 /* It shouldn't be possible to simplify the value given to a
971 constant attribute, so don't expand this until it's time to
972 write the test expression. */
974 RTX_UNCHANGING_P (exp) = 1;
976 if (attr->is_numeric)
978 for (p = XSTR (exp, 1); *p; p++)
979 if (*p < '0' || *p > '9')
980 fatal ("Attribute `%s' takes only numeric values",
985 for (av = attr->first_value; av; av = av->next)
986 if (GET_CODE (av->value) == CONST_STRING
987 && ! strcmp (XSTR (exp, 1), XSTR (av->value, 0)))
991 fatal ("Unknown value `%s' for `%s' attribute",
992 XSTR (exp, 1), XSTR (exp, 0));
997 /* Make an IOR tree of the possible values. */
999 name_ptr = XSTR (exp, 1);
1000 while ((p = next_comma_elt (&name_ptr)) != NULL)
1002 newexp = attr_eq (XSTR (exp, 0), p);
1003 orexp = insert_right_side (IOR, orexp, newexp, -2, -2);
1006 return check_attr_test (orexp, is_const, lineno);
1014 /* Either TRUE or FALSE. */
1022 XEXP (exp, 0) = check_attr_test (XEXP (exp, 0), is_const, lineno);
1023 XEXP (exp, 1) = check_attr_test (XEXP (exp, 1), is_const, lineno);
1027 XEXP (exp, 0) = check_attr_test (XEXP (exp, 0), is_const, lineno);
1033 fatal ("RTL operator \"%s\" not valid in constant attribute test",
1034 GET_RTX_NAME (GET_CODE (exp)));
1035 /* These cases can't be simplified. */
1036 RTX_UNCHANGING_P (exp) = 1;
1039 case LE: case LT: case GT: case GE:
1040 case LEU: case LTU: case GTU: case GEU:
1042 if (GET_CODE (XEXP (exp, 0)) == SYMBOL_REF
1043 && GET_CODE (XEXP (exp, 1)) == SYMBOL_REF)
1044 exp = attr_rtx (GET_CODE (exp),
1045 attr_rtx (SYMBOL_REF, XSTR (XEXP (exp, 0), 0)),
1046 attr_rtx (SYMBOL_REF, XSTR (XEXP (exp, 1), 0)));
1047 /* These cases can't be simplified. */
1048 RTX_UNCHANGING_P (exp) = 1;
1054 /* These cases are valid for constant attributes, but can't be
1056 exp = attr_rtx (SYMBOL_REF, XSTR (exp, 0));
1057 RTX_UNCHANGING_P (exp) = 1;
1061 fatal ("RTL operator \"%s\" not valid in attribute test",
1062 GET_RTX_NAME (GET_CODE (exp)));
1068 /* Given an expression, ensure that it is validly formed and that all named
1069 attribute values are valid for the given attribute. Issue a fatal error
1070 if not. If no attribute is specified, assume a numeric attribute.
1072 Return a perhaps modified replacement expression for the value. */
1075 check_attr_value (exp, attr)
1077 struct attr_desc *attr;
1079 struct attr_value *av;
1083 switch (GET_CODE (exp))
1086 if (attr && ! attr->is_numeric)
1088 message_with_line (attr->lineno,
1089 "CONST_INT not valid for non-numeric attribute %s",
1095 if (INTVAL (exp) < 0 && ! attr->negative_ok)
1097 message_with_line (attr->lineno,
1098 "negative numeric value specified for attribute %s",
1106 if (! strcmp (XSTR (exp, 0), "*"))
1109 if (attr == 0 || attr->is_numeric)
1112 if (attr && attr->negative_ok && *p == '-')
1115 if (*p > '9' || *p < '0')
1117 message_with_line (attr ? attr->lineno : 0,
1118 "non-numeric value for numeric attribute %s",
1119 attr ? attr->name : "internal");
1126 for (av = attr->first_value; av; av = av->next)
1127 if (GET_CODE (av->value) == CONST_STRING
1128 && ! strcmp (XSTR (av->value, 0), XSTR (exp, 0)))
1133 message_with_line (attr->lineno,
1134 "unknown value `%s' for `%s' attribute",
1135 XSTR (exp, 0), attr ? attr->name : "internal");
1141 XEXP (exp, 0) = check_attr_test (XEXP (exp, 0),
1142 attr ? attr->is_const : 0,
1143 attr ? attr->lineno : 0);
1144 XEXP (exp, 1) = check_attr_value (XEXP (exp, 1), attr);
1145 XEXP (exp, 2) = check_attr_value (XEXP (exp, 2), attr);
1153 if (attr && !attr->is_numeric)
1155 message_with_line (attr->lineno,
1156 "invalid operation `%s' for non-numeric attribute value",
1157 GET_RTX_NAME (GET_CODE (exp)));
1165 XEXP (exp, 0) = check_attr_value (XEXP (exp, 0), attr);
1166 XEXP (exp, 1) = check_attr_value (XEXP (exp, 1), attr);
1170 XEXP (exp, 0) = check_attr_value (XEXP (exp, 0), attr);
1174 if (XVECLEN (exp, 0) % 2 != 0)
1176 message_with_line (attr->lineno,
1177 "first operand of COND must have even length");
1182 for (i = 0; i < XVECLEN (exp, 0); i += 2)
1184 XVECEXP (exp, 0, i) = check_attr_test (XVECEXP (exp, 0, i),
1185 attr ? attr->is_const : 0,
1186 attr ? attr->lineno : 0);
1187 XVECEXP (exp, 0, i + 1)
1188 = check_attr_value (XVECEXP (exp, 0, i + 1), attr);
1191 XEXP (exp, 1) = check_attr_value (XEXP (exp, 1), attr);
1196 struct attr_desc *attr2 = find_attr (XSTR (exp, 0), 0);
1199 message_with_line (attr ? attr->lineno : 0,
1200 "unknown attribute `%s' in ATTR",
1204 else if (attr && attr->is_const && ! attr2->is_const)
1206 message_with_line (attr->lineno,
1207 "non-constant attribute `%s' referenced from `%s'",
1208 XSTR (exp, 0), attr->name);
1212 && (attr->is_numeric != attr2->is_numeric
1213 || (! attr->negative_ok && attr2->negative_ok)))
1215 message_with_line (attr->lineno,
1216 "numeric attribute mismatch calling `%s' from `%s'",
1217 XSTR (exp, 0), attr->name);
1224 /* A constant SYMBOL_REF is valid as a constant attribute test and
1225 is expanded later by make_canonical into a COND. In a non-constant
1226 attribute test, it is left be. */
1227 return attr_rtx (SYMBOL_REF, XSTR (exp, 0));
1230 message_with_line (attr ? attr->lineno : 0,
1231 "invalid operation `%s' for attribute value",
1232 GET_RTX_NAME (GET_CODE (exp)));
1240 /* Given an SET_ATTR_ALTERNATIVE expression, convert to the canonical SET.
1241 It becomes a COND with each test being (eq_attr "alternative "n") */
1244 convert_set_attr_alternative (exp, id)
1246 struct insn_def *id;
1248 int num_alt = id->num_alternatives;
1252 if (XVECLEN (exp, 1) != num_alt)
1254 message_with_line (id->lineno,
1255 "bad number of entries in SET_ATTR_ALTERNATIVE");
1260 /* Make a COND with all tests but the last. Select the last value via the
1262 condexp = rtx_alloc (COND);
1263 XVEC (condexp, 0) = rtvec_alloc ((num_alt - 1) * 2);
1265 for (i = 0; i < num_alt - 1; i++)
1268 p = attr_numeral (i);
1270 XVECEXP (condexp, 0, 2 * i) = attr_eq (alternative_name, p);
1271 XVECEXP (condexp, 0, 2 * i + 1) = XVECEXP (exp, 1, i);
1274 XEXP (condexp, 1) = XVECEXP (exp, 1, i);
1276 return attr_rtx (SET, attr_rtx (ATTR, XSTR (exp, 0)), condexp);
1279 /* Given a SET_ATTR, convert to the appropriate SET. If a comma-separated
1280 list of values is given, convert to SET_ATTR_ALTERNATIVE first. */
1283 convert_set_attr (exp, id)
1285 struct insn_def *id;
1288 const char *name_ptr;
1292 /* See how many alternative specified. */
1293 n = n_comma_elts (XSTR (exp, 1));
1295 return attr_rtx (SET,
1296 attr_rtx (ATTR, XSTR (exp, 0)),
1297 attr_rtx (CONST_STRING, XSTR (exp, 1)));
1299 newexp = rtx_alloc (SET_ATTR_ALTERNATIVE);
1300 XSTR (newexp, 0) = XSTR (exp, 0);
1301 XVEC (newexp, 1) = rtvec_alloc (n);
1303 /* Process each comma-separated name. */
1304 name_ptr = XSTR (exp, 1);
1306 while ((p = next_comma_elt (&name_ptr)) != NULL)
1307 XVECEXP (newexp, 1, n++) = attr_rtx (CONST_STRING, p);
1309 return convert_set_attr_alternative (newexp, id);
1312 /* Scan all definitions, checking for validity. Also, convert any SET_ATTR
1313 and SET_ATTR_ALTERNATIVE expressions to the corresponding SET
1319 struct insn_def *id;
1320 struct attr_desc *attr;
1324 for (id = defs; id; id = id->next)
1326 if (XVEC (id->def, id->vec_idx) == NULL)
1329 for (i = 0; i < XVECLEN (id->def, id->vec_idx); i++)
1331 value = XVECEXP (id->def, id->vec_idx, i);
1332 switch (GET_CODE (value))
1335 if (GET_CODE (XEXP (value, 0)) != ATTR)
1337 message_with_line (id->lineno, "bad attribute set");
1343 case SET_ATTR_ALTERNATIVE:
1344 value = convert_set_attr_alternative (value, id);
1348 value = convert_set_attr (value, id);
1352 message_with_line (id->lineno, "invalid attribute code %s",
1353 GET_RTX_NAME (GET_CODE (value)));
1357 if (value == NULL_RTX)
1360 if ((attr = find_attr (XSTR (XEXP (value, 0), 0), 0)) == NULL)
1362 message_with_line (id->lineno, "unknown attribute %s",
1363 XSTR (XEXP (value, 0), 0));
1368 XVECEXP (id->def, id->vec_idx, i) = value;
1369 XEXP (value, 1) = check_attr_value (XEXP (value, 1), attr);
1375 /* Given a constant SYMBOL_REF expression, convert to a COND that
1376 explicitly tests each enumerated value. */
1379 convert_const_symbol_ref (exp, attr)
1381 struct attr_desc *attr;
1384 struct attr_value *av;
1388 for (av = attr->first_value; av; av = av->next)
1391 /* Make a COND with all tests but the last, and in the original order.
1392 Select the last value via the default. Note that the attr values
1393 are constructed in reverse order. */
1395 condexp = rtx_alloc (COND);
1396 XVEC (condexp, 0) = rtvec_alloc ((num_alt - 1) * 2);
1397 av = attr->first_value;
1398 XEXP (condexp, 1) = av->value;
1400 for (i = num_alt - 2; av = av->next, i >= 0; i--)
1405 string = p = (char *) oballoc (2
1406 + strlen (attr->name)
1407 + strlen (XSTR (av->value, 0)));
1408 strcpy (p, attr->name);
1410 strcat (p, XSTR (av->value, 0));
1411 for (; *p != '\0'; p++)
1414 value = attr_rtx (SYMBOL_REF, string);
1415 RTX_UNCHANGING_P (value) = 1;
1417 XVECEXP (condexp, 0, 2 * i) = attr_rtx (EQ, exp, value);
1419 XVECEXP (condexp, 0, 2 * i + 1) = av->value;
1426 /* Given a valid expression for an attribute value, remove any IF_THEN_ELSE
1427 expressions by converting them into a COND. This removes cases from this
1428 program. Also, replace an attribute value of "*" with the default attribute
1432 make_canonical (attr, exp)
1433 struct attr_desc *attr;
1439 switch (GET_CODE (exp))
1442 exp = make_numeric_value (INTVAL (exp));
1446 if (! strcmp (XSTR (exp, 0), "*"))
1448 if (attr == 0 || attr->default_val == 0)
1449 fatal ("(attr_value \"*\") used in invalid context.");
1450 exp = attr->default_val->value;
1456 if (!attr->is_const || RTX_UNCHANGING_P (exp))
1458 /* The SYMBOL_REF is constant for a given run, so mark it as unchanging.
1459 This makes the COND something that won't be considered an arbitrary
1460 expression by walk_attr_value. */
1461 RTX_UNCHANGING_P (exp) = 1;
1463 /* ??? Why do we do this? With attribute values { A B C D E }, this
1464 tends to generate (!(x==A) && !(x==B) && !(x==C) && !(x==D)) rather
1466 exp = convert_const_symbol_ref (exp, attr);
1467 RTX_UNCHANGING_P (exp) = 1;
1468 exp = check_attr_value (exp, attr);
1469 /* Goto COND case since this is now a COND. Note that while the
1470 new expression is rescanned, all symbol_ref notes are marked as
1474 exp = check_attr_value (exp, attr);
1479 newexp = rtx_alloc (COND);
1480 XVEC (newexp, 0) = rtvec_alloc (2);
1481 XVECEXP (newexp, 0, 0) = XEXP (exp, 0);
1482 XVECEXP (newexp, 0, 1) = XEXP (exp, 1);
1484 XEXP (newexp, 1) = XEXP (exp, 2);
1487 /* Fall through to COND case since this is now a COND. */
1494 /* First, check for degenerate COND. */
1495 if (XVECLEN (exp, 0) == 0)
1496 return make_canonical (attr, XEXP (exp, 1));
1497 defval = XEXP (exp, 1) = make_canonical (attr, XEXP (exp, 1));
1499 for (i = 0; i < XVECLEN (exp, 0); i += 2)
1501 XVECEXP (exp, 0, i) = copy_boolean (XVECEXP (exp, 0, i));
1502 XVECEXP (exp, 0, i + 1)
1503 = make_canonical (attr, XVECEXP (exp, 0, i + 1));
1504 if (! rtx_equal_p (XVECEXP (exp, 0, i + 1), defval))
1523 if (GET_CODE (exp) == AND || GET_CODE (exp) == IOR)
1524 return attr_rtx (GET_CODE (exp), copy_boolean (XEXP (exp, 0)),
1525 copy_boolean (XEXP (exp, 1)));
1529 /* Given a value and an attribute description, return a `struct attr_value *'
1530 that represents that value. This is either an existing structure, if the
1531 value has been previously encountered, or a newly-created structure.
1533 `insn_code' is the code of an insn whose attribute has the specified
1534 value (-2 if not processing an insn). We ensure that all insns for
1535 a given value have the same number of alternatives if the value checks
1538 static struct attr_value *
1539 get_attr_value (value, attr, insn_code)
1541 struct attr_desc *attr;
1544 struct attr_value *av;
1547 value = make_canonical (attr, value);
1548 if (compares_alternatives_p (value))
1550 if (insn_code < 0 || insn_alternatives == NULL)
1551 fatal ("(eq_attr \"alternatives\" ...) used in non-insn context");
1553 num_alt = insn_alternatives[insn_code];
1556 for (av = attr->first_value; av; av = av->next)
1557 if (rtx_equal_p (value, av->value)
1558 && (num_alt == 0 || av->first_insn == NULL
1559 || insn_alternatives[av->first_insn->insn_code]))
1562 av = (struct attr_value *) oballoc (sizeof (struct attr_value));
1564 av->next = attr->first_value;
1565 attr->first_value = av;
1566 av->first_insn = NULL;
1568 av->has_asm_insn = 0;
1573 /* After all DEFINE_DELAYs have been read in, create internal attributes
1574 to generate the required routines.
1576 First, we compute the number of delay slots for each insn (as a COND of
1577 each of the test expressions in DEFINE_DELAYs). Then, if more than one
1578 delay type is specified, we compute a similar function giving the
1579 DEFINE_DELAY ordinal for each insn.
1581 Finally, for each [DEFINE_DELAY, slot #] pair, we compute an attribute that
1582 tells whether a given insn can be in that delay slot.
1584 Normal attribute filling and optimization expands these to contain the
1585 information needed to handle delay slots. */
1590 struct delay_desc *delay;
1596 /* First, generate data for `num_delay_slots' function. */
1598 condexp = rtx_alloc (COND);
1599 XVEC (condexp, 0) = rtvec_alloc (num_delays * 2);
1600 XEXP (condexp, 1) = make_numeric_value (0);
1602 for (i = 0, delay = delays; delay; i += 2, delay = delay->next)
1604 XVECEXP (condexp, 0, i) = XEXP (delay->def, 0);
1605 XVECEXP (condexp, 0, i + 1)
1606 = make_numeric_value (XVECLEN (delay->def, 1) / 3);
1609 make_internal_attr ("*num_delay_slots", condexp, 0);
1611 /* If more than one delay type, do the same for computing the delay type. */
1614 condexp = rtx_alloc (COND);
1615 XVEC (condexp, 0) = rtvec_alloc (num_delays * 2);
1616 XEXP (condexp, 1) = make_numeric_value (0);
1618 for (i = 0, delay = delays; delay; i += 2, delay = delay->next)
1620 XVECEXP (condexp, 0, i) = XEXP (delay->def, 0);
1621 XVECEXP (condexp, 0, i + 1) = make_numeric_value (delay->num);
1624 make_internal_attr ("*delay_type", condexp, 1);
1627 /* For each delay possibility and delay slot, compute an eligibility
1628 attribute for non-annulled insns and for each type of annulled (annul
1629 if true and annul if false). */
1630 for (delay = delays; delay; delay = delay->next)
1632 for (i = 0; i < XVECLEN (delay->def, 1); i += 3)
1634 condexp = XVECEXP (delay->def, 1, i);
1636 condexp = false_rtx;
1637 newexp = attr_rtx (IF_THEN_ELSE, condexp,
1638 make_numeric_value (1), make_numeric_value (0));
1640 p = attr_printf (sizeof ("*delay__") + MAX_DIGITS * 2,
1643 make_internal_attr (p, newexp, 1);
1645 if (have_annul_true)
1647 condexp = XVECEXP (delay->def, 1, i + 1);
1648 if (condexp == 0) condexp = false_rtx;
1649 newexp = attr_rtx (IF_THEN_ELSE, condexp,
1650 make_numeric_value (1),
1651 make_numeric_value (0));
1652 p = attr_printf (sizeof ("*annul_true__") + MAX_DIGITS * 2,
1653 "*annul_true_%d_%d", delay->num, i / 3);
1654 make_internal_attr (p, newexp, 1);
1657 if (have_annul_false)
1659 condexp = XVECEXP (delay->def, 1, i + 2);
1660 if (condexp == 0) condexp = false_rtx;
1661 newexp = attr_rtx (IF_THEN_ELSE, condexp,
1662 make_numeric_value (1),
1663 make_numeric_value (0));
1664 p = attr_printf (sizeof ("*annul_false__") + MAX_DIGITS * 2,
1665 "*annul_false_%d_%d", delay->num, i / 3);
1666 make_internal_attr (p, newexp, 1);
1672 /* This function is given a left and right side expression and an operator.
1673 Each side is a conditional expression, each alternative of which has a
1674 numerical value. The function returns another conditional expression
1675 which, for every possible set of condition values, returns a value that is
1676 the operator applied to the values of the two sides.
1678 Since this is called early, it must also support IF_THEN_ELSE. */
1681 operate_exp (op, left, right)
1685 int left_value, right_value;
1689 /* If left is a string, apply operator to it and the right side. */
1690 if (GET_CODE (left) == CONST_STRING)
1692 /* If right is also a string, just perform the operation. */
1693 if (GET_CODE (right) == CONST_STRING)
1695 left_value = atoi (XSTR (left, 0));
1696 right_value = atoi (XSTR (right, 0));
1700 i = left_value + right_value;
1704 i = left_value - right_value;
1707 case POS_MINUS_OP: /* The positive part of LEFT - RIGHT. */
1708 if (left_value > right_value)
1709 i = left_value - right_value;
1716 i = left_value | right_value;
1720 i = left_value == right_value;
1724 i = (left_value << (HOST_BITS_PER_INT / 2)) | right_value;
1728 if (left_value > right_value)
1735 if (left_value < right_value)
1745 if (i == left_value)
1747 if (i == right_value)
1749 return make_numeric_value (i);
1751 else if (GET_CODE (right) == IF_THEN_ELSE)
1753 /* Apply recursively to all values within. */
1754 rtx newleft = operate_exp (op, left, XEXP (right, 1));
1755 rtx newright = operate_exp (op, left, XEXP (right, 2));
1756 if (rtx_equal_p (newleft, newright))
1758 return attr_rtx (IF_THEN_ELSE, XEXP (right, 0), newleft, newright);
1760 else if (GET_CODE (right) == COND)
1765 newexp = rtx_alloc (COND);
1766 XVEC (newexp, 0) = rtvec_alloc (XVECLEN (right, 0));
1767 defval = XEXP (newexp, 1) = operate_exp (op, left, XEXP (right, 1));
1769 for (i = 0; i < XVECLEN (right, 0); i += 2)
1771 XVECEXP (newexp, 0, i) = XVECEXP (right, 0, i);
1772 XVECEXP (newexp, 0, i + 1)
1773 = operate_exp (op, left, XVECEXP (right, 0, i + 1));
1774 if (! rtx_equal_p (XVECEXP (newexp, 0, i + 1),
1779 /* If the resulting cond is trivial (all alternatives
1780 give the same value), optimize it away. */
1782 return operate_exp (op, left, XEXP (right, 1));
1787 fatal ("Badly formed attribute value");
1790 /* A hack to prevent expand_units from completely blowing up: ORX_OP does
1791 not associate through IF_THEN_ELSE. */
1792 else if (op == ORX_OP && GET_CODE (right) == IF_THEN_ELSE)
1794 return attr_rtx (IOR, left, right);
1797 /* Otherwise, do recursion the other way. */
1798 else if (GET_CODE (left) == IF_THEN_ELSE)
1800 rtx newleft = operate_exp (op, XEXP (left, 1), right);
1801 rtx newright = operate_exp (op, XEXP (left, 2), right);
1802 if (rtx_equal_p (newleft, newright))
1804 return attr_rtx (IF_THEN_ELSE, XEXP (left, 0), newleft, newright);
1806 else if (GET_CODE (left) == COND)
1811 newexp = rtx_alloc (COND);
1812 XVEC (newexp, 0) = rtvec_alloc (XVECLEN (left, 0));
1813 defval = XEXP (newexp, 1) = operate_exp (op, XEXP (left, 1), right);
1815 for (i = 0; i < XVECLEN (left, 0); i += 2)
1817 XVECEXP (newexp, 0, i) = XVECEXP (left, 0, i);
1818 XVECEXP (newexp, 0, i + 1)
1819 = operate_exp (op, XVECEXP (left, 0, i + 1), right);
1820 if (! rtx_equal_p (XVECEXP (newexp, 0, i + 1),
1825 /* If the cond is trivial (all alternatives give the same value),
1826 optimize it away. */
1828 return operate_exp (op, XEXP (left, 1), right);
1830 /* If the result is the same as the LEFT operand,
1832 if (rtx_equal_p (newexp, left))
1839 fatal ("Badly formed attribute value.");
1844 /* Once all attributes and DEFINE_FUNCTION_UNITs have been read, we
1845 construct a number of attributes.
1847 The first produces a function `function_units_used' which is given an
1848 insn and produces an encoding showing which function units are required
1849 for the execution of that insn. If the value is non-negative, the insn
1850 uses that unit; otherwise, the value is a one's compliment mask of units
1853 The second produces a function `result_ready_cost' which is used to
1854 determine the time that the result of an insn will be ready and hence
1855 a worst-case schedule.
1857 Both of these produce quite complex expressions which are then set as the
1858 default value of internal attributes. Normal attribute simplification
1859 should produce reasonable expressions.
1861 For each unit, a `<name>_unit_ready_cost' function will take an
1862 insn and give the delay until that unit will be ready with the result
1863 and a `<name>_unit_conflict_cost' function is given an insn already
1864 executing on the unit and a candidate to execute and will give the
1865 cost from the time the executing insn started until the candidate
1866 can start (ignore limitations on the number of simultaneous insns).
1868 For each unit, a `<name>_unit_blockage' function is given an insn
1869 already executing on the unit and a candidate to execute and will
1870 give the delay incurred due to function unit conflicts. The range of
1871 blockage cost values for a given executing insn is given by the
1872 `<name>_unit_blockage_range' function. These values are encoded in
1873 an int where the upper half gives the minimum value and the lower
1874 half gives the maximum value. */
1879 struct function_unit *unit, **unit_num;
1880 struct function_unit_op *op, **op_array, ***unit_ops;
1885 int i, j, u, num, nvalues;
1887 /* Rebuild the condition for the unit to share the RTL expressions.
1888 Sharing is required by simplify_by_exploding. Build the issue delay
1889 expressions. Validate the expressions we were given for the conditions
1890 and conflict vector. Then make attributes for use in the conflict
1893 for (unit = units; unit; unit = unit->next)
1895 unit->condexp = check_attr_test (unit->condexp, 0, unit->first_lineno);
1897 for (op = unit->ops; op; op = op->next)
1899 rtx issue_delay = make_numeric_value (op->issue_delay);
1900 rtx issue_exp = issue_delay;
1902 /* Build, validate, and simplify the issue delay expression. */
1903 if (op->conflict_exp != true_rtx)
1904 issue_exp = attr_rtx (IF_THEN_ELSE, op->conflict_exp,
1905 issue_exp, make_numeric_value (0));
1906 issue_exp = check_attr_value (make_canonical (NULL_ATTR,
1909 issue_exp = simplify_knowing (issue_exp, unit->condexp);
1910 op->issue_exp = issue_exp;
1912 /* Make an attribute for use in the conflict function if needed. */
1913 unit->needs_conflict_function = (unit->issue_delay.min
1914 != unit->issue_delay.max);
1915 if (unit->needs_conflict_function)
1917 str = attr_printf (strlen (unit->name) + sizeof ("*_cost_") + MAX_DIGITS,
1918 "*%s_cost_%d", unit->name, op->num);
1919 make_internal_attr (str, issue_exp, 1);
1922 /* Validate the condition. */
1923 op->condexp = check_attr_test (op->condexp, 0, op->lineno);
1927 /* Compute the mask of function units used. Initially, the unitsmask is
1928 zero. Set up a conditional to compute each unit's contribution. */
1929 unitsmask = make_numeric_value (0);
1930 newexp = rtx_alloc (IF_THEN_ELSE);
1931 XEXP (newexp, 2) = make_numeric_value (0);
1933 /* If we have just a few units, we may be all right expanding the whole
1934 thing. But the expansion is 2**N in space on the number of opclasses,
1935 so we can't do this for very long -- Alpha and MIPS in particular have
1936 problems with this. So in that situation, we fall back on an alternate
1937 implementation method. */
1938 #define NUM_UNITOP_CUTOFF 20
1940 if (num_unit_opclasses < NUM_UNITOP_CUTOFF)
1942 /* Merge each function unit into the unit mask attributes. */
1943 for (unit = units; unit; unit = unit->next)
1945 XEXP (newexp, 0) = unit->condexp;
1946 XEXP (newexp, 1) = make_numeric_value (1 << unit->num);
1947 unitsmask = operate_exp (OR_OP, unitsmask, newexp);
1952 /* Merge each function unit into the unit mask attributes. */
1953 for (unit = units; unit; unit = unit->next)
1955 XEXP (newexp, 0) = unit->condexp;
1956 XEXP (newexp, 1) = make_numeric_value (1 << unit->num);
1957 unitsmask = operate_exp (ORX_OP, unitsmask, attr_copy_rtx (newexp));
1961 /* Simplify the unit mask expression, encode it, and make an attribute
1962 for the function_units_used function. */
1963 unitsmask = simplify_by_exploding (unitsmask);
1965 if (num_unit_opclasses < NUM_UNITOP_CUTOFF)
1966 unitsmask = encode_units_mask (unitsmask);
1969 /* We can no longer encode unitsmask at compile time, so emit code to
1970 calculate it at runtime. Rather, put a marker for where we'd do
1971 the code, and actually output it in write_attr_get(). */
1972 unitsmask = attr_rtx (FFS, unitsmask);
1975 make_internal_attr ("*function_units_used", unitsmask, 10);
1977 /* Create an array of ops for each unit. Add an extra unit for the
1978 result_ready_cost function that has the ops of all other units. */
1979 unit_ops = (struct function_unit_op ***)
1980 xmalloc ((num_units + 1) * sizeof (struct function_unit_op **));
1981 unit_num = (struct function_unit **)
1982 xmalloc ((num_units + 1) * sizeof (struct function_unit *));
1984 unit_num[num_units] = unit = (struct function_unit *)
1985 xmalloc (sizeof (struct function_unit));
1986 unit->num = num_units;
1987 unit->num_opclasses = 0;
1989 for (unit = units; unit; unit = unit->next)
1991 unit_num[num_units]->num_opclasses += unit->num_opclasses;
1992 unit_num[unit->num] = unit;
1993 unit_ops[unit->num] = op_array = (struct function_unit_op **)
1994 xmalloc (unit->num_opclasses * sizeof (struct function_unit_op *));
1996 for (op = unit->ops; op; op = op->next)
1997 op_array[op->num] = op;
2000 /* Compose the array of ops for the extra unit. */
2001 unit_ops[num_units] = op_array = (struct function_unit_op **)
2002 xmalloc (unit_num[num_units]->num_opclasses
2003 * sizeof (struct function_unit_op *));
2005 for (unit = units, i = 0; unit; i += unit->num_opclasses, unit = unit->next)
2006 memcpy (&op_array[i], unit_ops[unit->num],
2007 unit->num_opclasses * sizeof (struct function_unit_op *));
2009 /* Compute the ready cost function for each unit by computing the
2010 condition for each non-default value. */
2011 for (u = 0; u <= num_units; u++)
2017 op_array = unit_ops[unit->num];
2018 num = unit->num_opclasses;
2020 /* Sort the array of ops into increasing ready cost order. */
2021 for (i = 0; i < num; i++)
2022 for (j = num - 1; j > i; j--)
2023 if (op_array[j - 1]->ready < op_array[j]->ready)
2026 op_array[j] = op_array[j - 1];
2027 op_array[j - 1] = op;
2030 /* Determine how many distinct non-default ready cost values there
2031 are. We use a default ready cost value of 1. */
2032 nvalues = 0; value = 1;
2033 for (i = num - 1; i >= 0; i--)
2034 if (op_array[i]->ready > value)
2036 value = op_array[i]->ready;
2041 readycost = make_numeric_value (1);
2044 /* Construct the ready cost expression as a COND of each value from
2045 the largest to the smallest. */
2046 readycost = rtx_alloc (COND);
2047 XVEC (readycost, 0) = rtvec_alloc (nvalues * 2);
2048 XEXP (readycost, 1) = make_numeric_value (1);
2052 value = op_array[0]->ready;
2053 for (i = 0; i < num; i++)
2058 else if (op->ready == value)
2059 orexp = insert_right_side (IOR, orexp, op->condexp, -2, -2);
2062 XVECEXP (readycost, 0, nvalues * 2) = orexp;
2063 XVECEXP (readycost, 0, nvalues * 2 + 1)
2064 = make_numeric_value (value);
2067 orexp = op->condexp;
2070 XVECEXP (readycost, 0, nvalues * 2) = orexp;
2071 XVECEXP (readycost, 0, nvalues * 2 + 1) = make_numeric_value (value);
2076 rtx max_blockage = 0, min_blockage = 0;
2078 /* Simplify the readycost expression by only considering insns
2079 that use the unit. */
2080 readycost = simplify_knowing (readycost, unit->condexp);
2082 /* Determine the blockage cost the executing insn (E) given
2083 the candidate insn (C). This is the maximum of the issue
2084 delay, the pipeline delay, and the simultaneity constraint.
2085 Each function_unit_op represents the characteristics of the
2086 candidate insn, so in the expressions below, C is a known
2087 term and E is an unknown term.
2089 We compute the blockage cost for each E for every possible C.
2090 Thus OP represents E, and READYCOST is a list of values for
2093 The issue delay function for C is op->issue_exp and is used to
2094 write the `<name>_unit_conflict_cost' function. Symbolicly
2095 this is "ISSUE-DELAY (E,C)".
2097 The pipeline delay results form the FIFO constraint on the
2098 function unit and is "READY-COST (E) + 1 - READY-COST (C)".
2100 The simultaneity constraint is based on how long it takes to
2101 fill the unit given the minimum issue delay. FILL-TIME is the
2102 constant "MIN (ISSUE-DELAY (*,*)) * (SIMULTANEITY - 1)", and
2103 the simultaneity constraint is "READY-COST (E) - FILL-TIME"
2104 if SIMULTANEITY is non-zero and zero otherwise.
2106 Thus, BLOCKAGE (E,C) when SIMULTANEITY is zero is
2108 MAX (ISSUE-DELAY (E,C),
2109 READY-COST (E) - (READY-COST (C) - 1))
2113 MAX (ISSUE-DELAY (E,C),
2114 READY-COST (E) - (READY-COST (C) - 1),
2115 READY-COST (E) - FILL-TIME)
2117 The `<name>_unit_blockage' function is computed by determining
2118 this value for each candidate insn. As these values are
2119 computed, we also compute the upper and lower bounds for
2120 BLOCKAGE (E,*). These are combined to form the function
2121 `<name>_unit_blockage_range'. Finally, the maximum blockage
2122 cost, MAX (BLOCKAGE (*,*)), is computed. */
2124 for (op = unit->ops; op; op = op->next)
2126 rtx blockage = op->issue_exp;
2127 blockage = simplify_knowing (blockage, unit->condexp);
2129 /* Add this op's contribution to MAX (BLOCKAGE (E,*)) and
2130 MIN (BLOCKAGE (E,*)). */
2131 if (max_blockage == 0)
2132 max_blockage = min_blockage = blockage;
2136 = simplify_knowing (operate_exp (MAX_OP, max_blockage,
2140 = simplify_knowing (operate_exp (MIN_OP, min_blockage,
2145 /* Make an attribute for use in the blockage function. */
2146 str = attr_printf (strlen (unit->name) + sizeof ("*_block_") + MAX_DIGITS,
2147 "*%s_block_%d", unit->name, op->num);
2148 make_internal_attr (str, blockage, 1);
2151 /* Record MAX (BLOCKAGE (*,*)). */
2154 unit->max_blockage = max_attr_value (max_blockage, &unknown);
2157 /* See if the upper and lower bounds of BLOCKAGE (E,*) are the
2158 same. If so, the blockage function carries no additional
2159 information and is not written. */
2160 newexp = operate_exp (EQ_OP, max_blockage, min_blockage);
2161 newexp = simplify_knowing (newexp, unit->condexp);
2162 unit->needs_blockage_function
2163 = (GET_CODE (newexp) != CONST_STRING
2164 || atoi (XSTR (newexp, 0)) != 1);
2166 /* If the all values of BLOCKAGE (E,C) have the same value,
2167 neither blockage function is written. */
2168 unit->needs_range_function
2169 = (unit->needs_blockage_function
2170 || GET_CODE (max_blockage) != CONST_STRING);
2172 if (unit->needs_range_function)
2174 /* Compute the blockage range function and make an attribute
2175 for writing its value. */
2176 newexp = operate_exp (RANGE_OP, min_blockage, max_blockage);
2177 newexp = simplify_knowing (newexp, unit->condexp);
2179 str = attr_printf (strlen (unit->name) + sizeof ("*_unit_blockage_range"),
2180 "*%s_unit_blockage_range", unit->name);
2181 make_internal_attr (str, newexp, 20);
2184 str = attr_printf (strlen (unit->name) + sizeof ("*_unit_ready_cost"),
2185 "*%s_unit_ready_cost", unit->name);
2188 str = "*result_ready_cost";
2190 /* Make an attribute for the ready_cost function. Simplifying
2191 further with simplify_by_exploding doesn't win. */
2192 make_internal_attr (str, readycost, 0);
2195 /* For each unit that requires a conflict cost function, make an attribute
2196 that maps insns to the operation number. */
2197 for (unit = units; unit; unit = unit->next)
2201 if (! unit->needs_conflict_function
2202 && ! unit->needs_blockage_function)
2205 caseexp = rtx_alloc (COND);
2206 XVEC (caseexp, 0) = rtvec_alloc ((unit->num_opclasses - 1) * 2);
2208 for (op = unit->ops; op; op = op->next)
2210 /* Make our adjustment to the COND being computed. If we are the
2211 last operation class, place our values into the default of the
2213 if (op->num == unit->num_opclasses - 1)
2215 XEXP (caseexp, 1) = make_numeric_value (op->num);
2219 XVECEXP (caseexp, 0, op->num * 2) = op->condexp;
2220 XVECEXP (caseexp, 0, op->num * 2 + 1)
2221 = make_numeric_value (op->num);
2225 /* Simplifying caseexp with simplify_by_exploding doesn't win. */
2226 str = attr_printf (strlen (unit->name) + sizeof ("*_cases"),
2227 "*%s_cases", unit->name);
2228 make_internal_attr (str, caseexp, 1);
2232 /* Simplify EXP given KNOWN_TRUE. */
2235 simplify_knowing (exp, known_true)
2236 rtx exp, known_true;
2238 if (GET_CODE (exp) != CONST_STRING)
2240 int unknown = 0, max;
2241 max = max_attr_value (exp, &unknown);
2244 exp = attr_rtx (IF_THEN_ELSE, known_true, exp,
2245 make_numeric_value (max));
2246 exp = simplify_by_exploding (exp);
2252 /* Translate the CONST_STRING expressions in X to change the encoding of
2253 value. On input, the value is a bitmask with a one bit for each unit
2254 used; on output, the value is the unit number (zero based) if one
2255 and only one unit is used or the one's compliment of the bitmask. */
2258 encode_units_mask (x)
2263 register enum rtx_code code;
2264 register const char *fmt;
2266 code = GET_CODE (x);
2271 i = atoi (XSTR (x, 0));
2273 /* The sign bit encodes a one's compliment mask. */
2275 else if (i != 0 && i == (i & -i))
2276 /* Only one bit is set, so yield that unit number. */
2277 for (j = 0; (i >>= 1) != 0; j++)
2281 return attr_rtx (CONST_STRING, attr_printf (MAX_DIGITS, "%d", j));
2298 /* Compare the elements. If any pair of corresponding elements
2299 fail to match, return 0 for the whole things. */
2301 fmt = GET_RTX_FORMAT (code);
2302 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
2308 for (j = 0; j < XVECLEN (x, i); j++)
2309 XVECEXP (x, i, j) = encode_units_mask (XVECEXP (x, i, j));
2313 XEXP (x, i) = encode_units_mask (XEXP (x, i));
2320 /* Once all attributes and insns have been read and checked, we construct for
2321 each attribute value a list of all the insns that have that value for
2326 struct attr_desc *attr;
2328 struct attr_value *av;
2329 struct insn_ent *ie;
2330 struct insn_def *id;
2334 /* Don't fill constant attributes. The value is independent of
2335 any particular insn. */
2339 for (id = defs; id; id = id->next)
2341 /* If no value is specified for this insn for this attribute, use the
2344 if (XVEC (id->def, id->vec_idx))
2345 for (i = 0; i < XVECLEN (id->def, id->vec_idx); i++)
2346 if (! strcmp (XSTR (XEXP (XVECEXP (id->def, id->vec_idx, i), 0), 0),
2348 value = XEXP (XVECEXP (id->def, id->vec_idx, i), 1);
2351 av = attr->default_val;
2353 av = get_attr_value (value, attr, id->insn_code);
2355 ie = (struct insn_ent *) oballoc (sizeof (struct insn_ent));
2356 ie->insn_code = id->insn_code;
2357 ie->insn_index = id->insn_code;
2358 insert_insn_ent (av, ie);
2362 /* Given an expression EXP, see if it is a COND or IF_THEN_ELSE that has a
2363 test that checks relative positions of insns (uses MATCH_DUP or PC).
2364 If so, replace it with what is obtained by passing the expression to
2365 ADDRESS_FN. If not but it is a COND or IF_THEN_ELSE, call this routine
2366 recursively on each value (including the default value). Otherwise,
2367 return the value returned by NO_ADDRESS_FN applied to EXP. */
2370 substitute_address (exp, no_address_fn, address_fn)
2372 rtx (*no_address_fn) PARAMS ((rtx));
2373 rtx (*address_fn) PARAMS ((rtx));
2378 if (GET_CODE (exp) == COND)
2380 /* See if any tests use addresses. */
2382 for (i = 0; i < XVECLEN (exp, 0); i += 2)
2383 walk_attr_value (XVECEXP (exp, 0, i));
2386 return (*address_fn) (exp);
2388 /* Make a new copy of this COND, replacing each element. */
2389 newexp = rtx_alloc (COND);
2390 XVEC (newexp, 0) = rtvec_alloc (XVECLEN (exp, 0));
2391 for (i = 0; i < XVECLEN (exp, 0); i += 2)
2393 XVECEXP (newexp, 0, i) = XVECEXP (exp, 0, i);
2394 XVECEXP (newexp, 0, i + 1)
2395 = substitute_address (XVECEXP (exp, 0, i + 1),
2396 no_address_fn, address_fn);
2399 XEXP (newexp, 1) = substitute_address (XEXP (exp, 1),
2400 no_address_fn, address_fn);
2405 else if (GET_CODE (exp) == IF_THEN_ELSE)
2408 walk_attr_value (XEXP (exp, 0));
2410 return (*address_fn) (exp);
2412 return attr_rtx (IF_THEN_ELSE,
2413 substitute_address (XEXP (exp, 0),
2414 no_address_fn, address_fn),
2415 substitute_address (XEXP (exp, 1),
2416 no_address_fn, address_fn),
2417 substitute_address (XEXP (exp, 2),
2418 no_address_fn, address_fn));
2421 return (*no_address_fn) (exp);
2424 /* Make new attributes from the `length' attribute. The following are made,
2425 each corresponding to a function called from `shorten_branches' or
2428 *insn_default_length This is the length of the insn to be returned
2429 by `get_attr_length' before `shorten_branches'
2430 has been called. In each case where the length
2431 depends on relative addresses, the largest
2432 possible is used. This routine is also used
2433 to compute the initial size of the insn.
2435 *insn_variable_length_p This returns 1 if the insn's length depends
2436 on relative addresses, zero otherwise.
2438 *insn_current_length This is only called when it is known that the
2439 insn has a variable length and returns the
2440 current length, based on relative addresses.
2444 make_length_attrs ()
2446 static const char *new_names[] = {"*insn_default_length",
2447 "*insn_variable_length_p",
2448 "*insn_current_length"};
2449 static rtx (*no_address_fn[]) PARAMS ((rtx)) = {identity_fn, zero_fn, zero_fn};
2450 static rtx (*address_fn[]) PARAMS ((rtx)) = {max_fn, one_fn, identity_fn};
2452 struct attr_desc *length_attr, *new_attr;
2453 struct attr_value *av, *new_av;
2454 struct insn_ent *ie, *new_ie;
2456 /* See if length attribute is defined. If so, it must be numeric. Make
2457 it special so we don't output anything for it. */
2458 length_attr = find_attr ("length", 0);
2459 if (length_attr == 0)
2462 if (! length_attr->is_numeric)
2463 fatal ("length attribute must be numeric.");
2465 length_attr->is_const = 0;
2466 length_attr->is_special = 1;
2468 /* Make each new attribute, in turn. */
2469 for (i = 0; i < ARRAY_SIZE (new_names); i++)
2471 make_internal_attr (new_names[i],
2472 substitute_address (length_attr->default_val->value,
2473 no_address_fn[i], address_fn[i]),
2475 new_attr = find_attr (new_names[i], 0);
2476 for (av = length_attr->first_value; av; av = av->next)
2477 for (ie = av->first_insn; ie; ie = ie->next)
2479 new_av = get_attr_value (substitute_address (av->value,
2482 new_attr, ie->insn_code);
2483 new_ie = (struct insn_ent *) oballoc (sizeof (struct insn_ent));
2484 new_ie->insn_code = ie->insn_code;
2485 new_ie->insn_index = ie->insn_index;
2486 insert_insn_ent (new_av, new_ie);
2491 /* Utility functions called from above routine. */
2502 rtx exp ATTRIBUTE_UNUSED;
2504 return make_numeric_value (0);
2509 rtx exp ATTRIBUTE_UNUSED;
2511 return make_numeric_value (1);
2519 return make_numeric_value (max_attr_value (exp, &unknown));
2523 write_length_unit_log ()
2525 struct attr_desc *length_attr = find_attr ("length", 0);
2526 struct attr_value *av;
2527 struct insn_ent *ie;
2528 unsigned int length_unit_log, length_or;
2531 if (length_attr == 0)
2533 length_or = or_attr_value (length_attr->default_val->value, &unknown);
2534 for (av = length_attr->first_value; av; av = av->next)
2535 for (ie = av->first_insn; ie; ie = ie->next)
2536 length_or |= or_attr_value (av->value, &unknown);
2539 length_unit_log = 0;
2542 length_or = ~length_or;
2543 for (length_unit_log = 0; length_or & 1; length_or >>= 1)
2546 printf ("int length_unit_log = %u;\n", length_unit_log);
2549 /* Take a COND expression and see if any of the conditions in it can be
2550 simplified. If any are known true or known false for the particular insn
2551 code, the COND can be further simplified.
2553 Also call ourselves on any COND operations that are values of this COND.
2555 We do not modify EXP; rather, we make and return a new rtx. */
2558 simplify_cond (exp, insn_code, insn_index)
2560 int insn_code, insn_index;
2563 /* We store the desired contents here,
2564 then build a new expression if they don't match EXP. */
2565 rtx defval = XEXP (exp, 1);
2566 rtx new_defval = XEXP (exp, 1);
2567 int len = XVECLEN (exp, 0);
2568 rtx *tests = (rtx *) xmalloc (len * sizeof (rtx));
2573 /* This lets us free all storage allocated below, if appropriate. */
2574 first_spacer = (char *) obstack_finish (rtl_obstack);
2576 memcpy (tests, XVEC (exp, 0)->elem, len * sizeof (rtx));
2578 /* See if default value needs simplification. */
2579 if (GET_CODE (defval) == COND)
2580 new_defval = simplify_cond (defval, insn_code, insn_index);
2582 /* Simplify the subexpressions, and see what tests we can get rid of. */
2584 for (i = 0; i < len; i += 2)
2586 rtx newtest, newval;
2588 /* Simplify this test. */
2589 newtest = simplify_test_exp_in_temp (tests[i], insn_code, insn_index);
2592 newval = tests[i + 1];
2593 /* See if this value may need simplification. */
2594 if (GET_CODE (newval) == COND)
2595 newval = simplify_cond (newval, insn_code, insn_index);
2597 /* Look for ways to delete or combine this test. */
2598 if (newtest == true_rtx)
2600 /* If test is true, make this value the default
2601 and discard this + any following tests. */
2603 defval = tests[i + 1];
2604 new_defval = newval;
2607 else if (newtest == false_rtx)
2609 /* If test is false, discard it and its value. */
2610 for (j = i; j < len - 2; j++)
2611 tests[j] = tests[j + 2];
2615 else if (i > 0 && attr_equal_p (newval, tests[i - 1]))
2617 /* If this value and the value for the prev test are the same,
2621 = insert_right_side (IOR, tests[i - 2], newtest,
2622 insn_code, insn_index);
2624 /* Delete this test/value. */
2625 for (j = i; j < len - 2; j++)
2626 tests[j] = tests[j + 2];
2631 tests[i + 1] = newval;
2634 /* If the last test in a COND has the same value
2635 as the default value, that test isn't needed. */
2637 while (len > 0 && attr_equal_p (tests[len - 1], new_defval))
2640 /* See if we changed anything. */
2641 if (len != XVECLEN (exp, 0) || new_defval != XEXP (exp, 1))
2644 for (i = 0; i < len; i++)
2645 if (! attr_equal_p (tests[i], XVECEXP (exp, 0, i)))
2653 if (GET_CODE (defval) == COND)
2654 ret = simplify_cond (defval, insn_code, insn_index);
2662 rtx newexp = rtx_alloc (COND);
2664 XVEC (newexp, 0) = rtvec_alloc (len);
2665 memcpy (XVEC (newexp, 0)->elem, tests, len * sizeof (rtx));
2666 XEXP (newexp, 1) = new_defval;
2673 /* Remove an insn entry from an attribute value. */
2676 remove_insn_ent (av, ie)
2677 struct attr_value *av;
2678 struct insn_ent *ie;
2680 struct insn_ent *previe;
2682 if (av->first_insn == ie)
2683 av->first_insn = ie->next;
2686 for (previe = av->first_insn; previe->next != ie; previe = previe->next)
2688 previe->next = ie->next;
2692 if (ie->insn_code == -1)
2693 av->has_asm_insn = 0;
2698 /* Insert an insn entry in an attribute value list. */
2701 insert_insn_ent (av, ie)
2702 struct attr_value *av;
2703 struct insn_ent *ie;
2705 ie->next = av->first_insn;
2706 av->first_insn = ie;
2708 if (ie->insn_code == -1)
2709 av->has_asm_insn = 1;
2714 /* This is a utility routine to take an expression that is a tree of either
2715 AND or IOR expressions and insert a new term. The new term will be
2716 inserted at the right side of the first node whose code does not match
2717 the root. A new node will be created with the root's code. Its left
2718 side will be the old right side and its right side will be the new
2721 If the `term' is itself a tree, all its leaves will be inserted. */
2724 insert_right_side (code, exp, term, insn_code, insn_index)
2728 int insn_code, insn_index;
2732 /* Avoid consing in some special cases. */
2733 if (code == AND && term == true_rtx)
2735 if (code == AND && term == false_rtx)
2737 if (code == AND && exp == true_rtx)
2739 if (code == AND && exp == false_rtx)
2741 if (code == IOR && term == true_rtx)
2743 if (code == IOR && term == false_rtx)
2745 if (code == IOR && exp == true_rtx)
2747 if (code == IOR && exp == false_rtx)
2749 if (attr_equal_p (exp, term))
2752 if (GET_CODE (term) == code)
2754 exp = insert_right_side (code, exp, XEXP (term, 0),
2755 insn_code, insn_index);
2756 exp = insert_right_side (code, exp, XEXP (term, 1),
2757 insn_code, insn_index);
2762 if (GET_CODE (exp) == code)
2764 rtx new = insert_right_side (code, XEXP (exp, 1),
2765 term, insn_code, insn_index);
2766 if (new != XEXP (exp, 1))
2767 /* Make a copy of this expression and call recursively. */
2768 newexp = attr_rtx (code, XEXP (exp, 0), new);
2774 /* Insert the new term. */
2775 newexp = attr_rtx (code, exp, term);
2778 return simplify_test_exp_in_temp (newexp, insn_code, insn_index);
2781 /* If we have an expression which AND's a bunch of
2782 (not (eq_attrq "alternative" "n"))
2783 terms, we may have covered all or all but one of the possible alternatives.
2784 If so, we can optimize. Similarly for IOR's of EQ_ATTR.
2786 This routine is passed an expression and either AND or IOR. It returns a
2787 bitmask indicating which alternatives are mentioned within EXP. */
2790 compute_alternative_mask (exp, code)
2795 if (GET_CODE (exp) == code)
2796 return compute_alternative_mask (XEXP (exp, 0), code)
2797 | compute_alternative_mask (XEXP (exp, 1), code);
2799 else if (code == AND && GET_CODE (exp) == NOT
2800 && GET_CODE (XEXP (exp, 0)) == EQ_ATTR
2801 && XSTR (XEXP (exp, 0), 0) == alternative_name)
2802 string = XSTR (XEXP (exp, 0), 1);
2804 else if (code == IOR && GET_CODE (exp) == EQ_ATTR
2805 && XSTR (exp, 0) == alternative_name)
2806 string = XSTR (exp, 1);
2812 return 1 << (string[0] - '0');
2813 return 1 << atoi (string);
2816 /* Given I, a single-bit mask, return RTX to compare the `alternative'
2817 attribute with the value represented by that bit. */
2820 make_alternative_compare (mask)
2827 for (i = 0; (mask & (1 << i)) == 0; i++)
2830 newexp = attr_rtx (EQ_ATTR, alternative_name, attr_numeral (i));
2831 RTX_UNCHANGING_P (newexp) = 1;
2836 /* If we are processing an (eq_attr "attr" "value") test, we find the value
2837 of "attr" for this insn code. From that value, we can compute a test
2838 showing when the EQ_ATTR will be true. This routine performs that
2839 computation. If a test condition involves an address, we leave the EQ_ATTR
2840 intact because addresses are only valid for the `length' attribute.
2842 EXP is the EQ_ATTR expression and VALUE is the value of that attribute
2843 for the insn corresponding to INSN_CODE and INSN_INDEX. */
2846 evaluate_eq_attr (exp, value, insn_code, insn_index)
2849 int insn_code, insn_index;
2856 if (GET_CODE (value) == CONST_STRING)
2858 if (! strcmp (XSTR (value, 0), XSTR (exp, 1)))
2863 else if (GET_CODE (value) == SYMBOL_REF)
2868 if (GET_CODE (exp) != EQ_ATTR)
2871 if (strlen (XSTR (exp, 0)) + strlen (XSTR (exp, 1)) + 2 > 256)
2874 strcpy (string, XSTR (exp, 0));
2875 strcat (string, "_");
2876 strcat (string, XSTR (exp, 1));
2877 for (p = string; *p; p++)
2880 newexp = attr_rtx (EQ, value,
2881 attr_rtx (SYMBOL_REF,
2882 attr_string (string, strlen (string))));
2884 else if (GET_CODE (value) == COND)
2886 /* We construct an IOR of all the cases for which the requested attribute
2887 value is present. Since we start with FALSE, if it is not present,
2888 FALSE will be returned.
2890 Each case is the AND of the NOT's of the previous conditions with the
2891 current condition; in the default case the current condition is TRUE.
2893 For each possible COND value, call ourselves recursively.
2895 The extra TRUE and FALSE expressions will be eliminated by another
2896 call to the simplification routine. */
2901 if (current_alternative_string)
2902 clear_struct_flag (value);
2904 for (i = 0; i < XVECLEN (value, 0); i += 2)
2906 rtx this = simplify_test_exp_in_temp (XVECEXP (value, 0, i),
2907 insn_code, insn_index);
2909 SIMPLIFY_ALTERNATIVE (this);
2911 right = insert_right_side (AND, andexp, this,
2912 insn_code, insn_index);
2913 right = insert_right_side (AND, right,
2914 evaluate_eq_attr (exp,
2917 insn_code, insn_index),
2918 insn_code, insn_index);
2919 orexp = insert_right_side (IOR, orexp, right,
2920 insn_code, insn_index);
2922 /* Add this condition into the AND expression. */
2923 newexp = attr_rtx (NOT, this);
2924 andexp = insert_right_side (AND, andexp, newexp,
2925 insn_code, insn_index);
2928 /* Handle the default case. */
2929 right = insert_right_side (AND, andexp,
2930 evaluate_eq_attr (exp, XEXP (value, 1),
2931 insn_code, insn_index),
2932 insn_code, insn_index);
2933 newexp = insert_right_side (IOR, orexp, right, insn_code, insn_index);
2938 /* If uses an address, must return original expression. But set the
2939 RTX_UNCHANGING_P bit so we don't try to simplify it again. */
2942 walk_attr_value (newexp);
2946 /* This had `&& current_alternative_string', which seems to be wrong. */
2947 if (! RTX_UNCHANGING_P (exp))
2948 return copy_rtx_unchanging (exp);
2955 /* This routine is called when an AND of a term with a tree of AND's is
2956 encountered. If the term or its complement is present in the tree, it
2957 can be replaced with TRUE or FALSE, respectively.
2959 Note that (eq_attr "att" "v1") and (eq_attr "att" "v2") cannot both
2960 be true and hence are complementary.
2962 There is one special case: If we see
2963 (and (not (eq_attr "att" "v1"))
2964 (eq_attr "att" "v2"))
2965 this can be replaced by (eq_attr "att" "v2"). To do this we need to
2966 replace the term, not anything in the AND tree. So we pass a pointer to
2970 simplify_and_tree (exp, pterm, insn_code, insn_index)
2973 int insn_code, insn_index;
2978 int left_eliminates_term, right_eliminates_term;
2980 if (GET_CODE (exp) == AND)
2982 left = simplify_and_tree (XEXP (exp, 0), pterm, insn_code, insn_index);
2983 right = simplify_and_tree (XEXP (exp, 1), pterm, insn_code, insn_index);
2984 if (left != XEXP (exp, 0) || right != XEXP (exp, 1))
2986 newexp = attr_rtx (GET_CODE (exp), left, right);
2988 exp = simplify_test_exp_in_temp (newexp, insn_code, insn_index);
2992 else if (GET_CODE (exp) == IOR)
2994 /* For the IOR case, we do the same as above, except that we can
2995 only eliminate `term' if both sides of the IOR would do so. */
2997 left = simplify_and_tree (XEXP (exp, 0), &temp, insn_code, insn_index);
2998 left_eliminates_term = (temp == true_rtx);
3001 right = simplify_and_tree (XEXP (exp, 1), &temp, insn_code, insn_index);
3002 right_eliminates_term = (temp == true_rtx);
3004 if (left_eliminates_term && right_eliminates_term)
3007 if (left != XEXP (exp, 0) || right != XEXP (exp, 1))
3009 newexp = attr_rtx (GET_CODE (exp), left, right);
3011 exp = simplify_test_exp_in_temp (newexp, insn_code, insn_index);
3015 /* Check for simplifications. Do some extra checking here since this
3016 routine is called so many times. */
3021 else if (GET_CODE (exp) == NOT && XEXP (exp, 0) == *pterm)
3024 else if (GET_CODE (*pterm) == NOT && exp == XEXP (*pterm, 0))
3027 else if (GET_CODE (exp) == EQ_ATTR && GET_CODE (*pterm) == EQ_ATTR)
3029 if (XSTR (exp, 0) != XSTR (*pterm, 0))
3032 if (! strcmp (XSTR (exp, 1), XSTR (*pterm, 1)))
3038 else if (GET_CODE (*pterm) == EQ_ATTR && GET_CODE (exp) == NOT
3039 && GET_CODE (XEXP (exp, 0)) == EQ_ATTR)
3041 if (XSTR (*pterm, 0) != XSTR (XEXP (exp, 0), 0))
3044 if (! strcmp (XSTR (*pterm, 1), XSTR (XEXP (exp, 0), 1)))
3050 else if (GET_CODE (exp) == EQ_ATTR && GET_CODE (*pterm) == NOT
3051 && GET_CODE (XEXP (*pterm, 0)) == EQ_ATTR)
3053 if (XSTR (exp, 0) != XSTR (XEXP (*pterm, 0), 0))
3056 if (! strcmp (XSTR (exp, 1), XSTR (XEXP (*pterm, 0), 1)))
3062 else if (GET_CODE (exp) == NOT && GET_CODE (*pterm) == NOT)
3064 if (attr_equal_p (XEXP (exp, 0), XEXP (*pterm, 0)))
3068 else if (GET_CODE (exp) == NOT)
3070 if (attr_equal_p (XEXP (exp, 0), *pterm))
3074 else if (GET_CODE (*pterm) == NOT)
3076 if (attr_equal_p (XEXP (*pterm, 0), exp))
3080 else if (attr_equal_p (exp, *pterm))
3086 /* Similar to `simplify_and_tree', but for IOR trees. */
3089 simplify_or_tree (exp, pterm, insn_code, insn_index)
3092 int insn_code, insn_index;
3097 int left_eliminates_term, right_eliminates_term;
3099 if (GET_CODE (exp) == IOR)
3101 left = simplify_or_tree (XEXP (exp, 0), pterm, insn_code, insn_index);
3102 right = simplify_or_tree (XEXP (exp, 1), pterm, insn_code, insn_index);
3103 if (left != XEXP (exp, 0) || right != XEXP (exp, 1))
3105 newexp = attr_rtx (GET_CODE (exp), left, right);
3107 exp = simplify_test_exp_in_temp (newexp, insn_code, insn_index);
3111 else if (GET_CODE (exp) == AND)
3113 /* For the AND case, we do the same as above, except that we can
3114 only eliminate `term' if both sides of the AND would do so. */
3116 left = simplify_or_tree (XEXP (exp, 0), &temp, insn_code, insn_index);
3117 left_eliminates_term = (temp == false_rtx);
3120 right = simplify_or_tree (XEXP (exp, 1), &temp, insn_code, insn_index);
3121 right_eliminates_term = (temp == false_rtx);
3123 if (left_eliminates_term && right_eliminates_term)
3126 if (left != XEXP (exp, 0) || right != XEXP (exp, 1))
3128 newexp = attr_rtx (GET_CODE (exp), left, right);
3130 exp = simplify_test_exp_in_temp (newexp, insn_code, insn_index);
3134 if (attr_equal_p (exp, *pterm))
3137 else if (GET_CODE (exp) == NOT && attr_equal_p (XEXP (exp, 0), *pterm))
3140 else if (GET_CODE (*pterm) == NOT && attr_equal_p (XEXP (*pterm, 0), exp))
3143 else if (GET_CODE (*pterm) == EQ_ATTR && GET_CODE (exp) == NOT
3144 && GET_CODE (XEXP (exp, 0)) == EQ_ATTR
3145 && XSTR (*pterm, 0) == XSTR (XEXP (exp, 0), 0))
3148 else if (GET_CODE (exp) == EQ_ATTR && GET_CODE (*pterm) == NOT
3149 && GET_CODE (XEXP (*pterm, 0)) == EQ_ATTR
3150 && XSTR (exp, 0) == XSTR (XEXP (*pterm, 0), 0))
3155 /* Compute approximate cost of the expression. Used to decide whether
3156 expression is cheap enought for inline. */
3165 code = GET_CODE (x);
3174 /* Alternatives don't result into function call. */
3175 if (!strcmp (XSTR (x, 0), "alternative"))
3182 const char *fmt = GET_RTX_FORMAT (code);
3183 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
3189 for (j = 0; j < XVECLEN (x, i); j++)
3190 cost += attr_rtx_cost (XVECEXP (x, i, j));
3193 cost += attr_rtx_cost (XEXP (x, i));
3204 /* Simplify test expression and use temporary obstack in order to avoid
3205 memory bloat. Use RTX_UNCHANGING_P to avoid unnecesary simplifications
3206 and avoid unnecesary copying if possible. */
3209 simplify_test_exp_in_temp (exp, insn_code, insn_index)
3211 int insn_code, insn_index;
3214 struct obstack *old;
3215 if (RTX_UNCHANGING_P (exp))
3218 rtl_obstack = temp_obstack;
3219 x = simplify_test_exp (exp, insn_code, insn_index);
3221 if (x == exp || rtl_obstack == temp_obstack)
3223 return attr_copy_rtx (x);
3226 /* Given an expression, see if it can be simplified for a particular insn
3227 code based on the values of other attributes being tested. This can
3228 eliminate nested get_attr_... calls.
3230 Note that if an endless recursion is specified in the patterns, the
3231 optimization will loop. However, it will do so in precisely the cases where
3232 an infinite recursion loop could occur during compilation. It's better that
3236 simplify_test_exp (exp, insn_code, insn_index)
3238 int insn_code, insn_index;
3241 struct attr_desc *attr;
3242 struct attr_value *av;
3243 struct insn_ent *ie;
3247 /* Don't re-simplify something we already simplified. */
3248 if (RTX_UNCHANGING_P (exp) || MEM_IN_STRUCT_P (exp))
3251 switch (GET_CODE (exp))
3254 left = SIMPLIFY_TEST_EXP (XEXP (exp, 0), insn_code, insn_index);
3255 SIMPLIFY_ALTERNATIVE (left);
3256 if (left == false_rtx)
3258 right = SIMPLIFY_TEST_EXP (XEXP (exp, 1), insn_code, insn_index);
3259 SIMPLIFY_ALTERNATIVE (right);
3260 if (left == false_rtx)
3263 /* If either side is an IOR and we have (eq_attr "alternative" ..")
3264 present on both sides, apply the distributive law since this will
3265 yield simplifications. */
3266 if ((GET_CODE (left) == IOR || GET_CODE (right) == IOR)
3267 && compute_alternative_mask (left, IOR)
3268 && compute_alternative_mask (right, IOR))
3270 if (GET_CODE (left) == IOR)
3277 newexp = attr_rtx (IOR,
3278 attr_rtx (AND, left, XEXP (right, 0)),
3279 attr_rtx (AND, left, XEXP (right, 1)));
3281 return SIMPLIFY_TEST_EXP (newexp, insn_code, insn_index);
3284 /* Try with the term on both sides. */
3285 right = simplify_and_tree (right, &left, insn_code, insn_index);
3286 if (left == XEXP (exp, 0) && right == XEXP (exp, 1))
3287 left = simplify_and_tree (left, &right, insn_code, insn_index);
3289 if (left == false_rtx || right == false_rtx)
3291 else if (left == true_rtx)
3295 else if (right == true_rtx)
3299 /* See if all or all but one of the insn's alternatives are specified
3300 in this tree. Optimize if so. */
3302 else if (insn_code >= 0
3303 && (GET_CODE (left) == AND
3304 || (GET_CODE (left) == NOT
3305 && GET_CODE (XEXP (left, 0)) == EQ_ATTR
3306 && XSTR (XEXP (left, 0), 0) == alternative_name)
3307 || GET_CODE (right) == AND
3308 || (GET_CODE (right) == NOT
3309 && GET_CODE (XEXP (right, 0)) == EQ_ATTR
3310 && XSTR (XEXP (right, 0), 0) == alternative_name)))
3312 i = compute_alternative_mask (exp, AND);
3313 if (i & ~insn_alternatives[insn_code])
3314 fatal ("Invalid alternative specified for pattern number %d",
3317 /* If all alternatives are excluded, this is false. */
3318 i ^= insn_alternatives[insn_code];
3321 else if ((i & (i - 1)) == 0 && insn_alternatives[insn_code] > 1)
3323 /* If just one excluded, AND a comparison with that one to the
3324 front of the tree. The others will be eliminated by
3325 optimization. We do not want to do this if the insn has one
3326 alternative and we have tested none of them! */
3327 left = make_alternative_compare (i);
3328 right = simplify_and_tree (exp, &left, insn_code, insn_index);
3329 newexp = attr_rtx (AND, left, right);
3331 return SIMPLIFY_TEST_EXP (newexp, insn_code, insn_index);
3335 if (left != XEXP (exp, 0) || right != XEXP (exp, 1))
3337 newexp = attr_rtx (AND, left, right);
3338 return SIMPLIFY_TEST_EXP (newexp, insn_code, insn_index);
3343 left = SIMPLIFY_TEST_EXP (XEXP (exp, 0), insn_code, insn_index);
3344 SIMPLIFY_ALTERNATIVE (left);
3345 if (left == true_rtx)
3347 right = SIMPLIFY_TEST_EXP (XEXP (exp, 1), insn_code, insn_index);
3348 SIMPLIFY_ALTERNATIVE (right);
3349 if (right == true_rtx)
3352 right = simplify_or_tree (right, &left, insn_code, insn_index);
3353 if (left == XEXP (exp, 0) && right == XEXP (exp, 1))
3354 left = simplify_or_tree (left, &right, insn_code, insn_index);
3356 if (right == true_rtx || left == true_rtx)
3358 else if (left == false_rtx)
3362 else if (right == false_rtx)
3367 /* Test for simple cases where the distributive law is useful. I.e.,
3368 convert (ior (and (x) (y))
3374 else if (GET_CODE (left) == AND && GET_CODE (right) == AND
3375 && attr_equal_p (XEXP (left, 0), XEXP (right, 0)))
3377 newexp = attr_rtx (IOR, XEXP (left, 1), XEXP (right, 1));
3379 left = XEXP (left, 0);
3381 newexp = attr_rtx (AND, left, right);
3382 return SIMPLIFY_TEST_EXP (newexp, insn_code, insn_index);
3385 /* See if all or all but one of the insn's alternatives are specified
3386 in this tree. Optimize if so. */
3388 else if (insn_code >= 0
3389 && (GET_CODE (left) == IOR
3390 || (GET_CODE (left) == EQ_ATTR
3391 && XSTR (left, 0) == alternative_name)
3392 || GET_CODE (right) == IOR
3393 || (GET_CODE (right) == EQ_ATTR
3394 && XSTR (right, 0) == alternative_name)))
3396 i = compute_alternative_mask (exp, IOR);
3397 if (i & ~insn_alternatives[insn_code])
3398 fatal ("Invalid alternative specified for pattern number %d",
3401 /* If all alternatives are included, this is true. */
3402 i ^= insn_alternatives[insn_code];
3405 else if ((i & (i - 1)) == 0 && insn_alternatives[insn_code] > 1)
3407 /* If just one excluded, IOR a comparison with that one to the
3408 front of the tree. The others will be eliminated by
3409 optimization. We do not want to do this if the insn has one
3410 alternative and we have tested none of them! */
3411 left = make_alternative_compare (i);
3412 right = simplify_and_tree (exp, &left, insn_code, insn_index);
3413 newexp = attr_rtx (IOR, attr_rtx (NOT, left), right);
3415 return SIMPLIFY_TEST_EXP (newexp, insn_code, insn_index);
3419 if (left != XEXP (exp, 0) || right != XEXP (exp, 1))
3421 newexp = attr_rtx (IOR, left, right);
3422 return SIMPLIFY_TEST_EXP (newexp, insn_code, insn_index);
3427 if (GET_CODE (XEXP (exp, 0)) == NOT)
3429 left = SIMPLIFY_TEST_EXP (XEXP (XEXP (exp, 0), 0),
3430 insn_code, insn_index);
3431 SIMPLIFY_ALTERNATIVE (left);
3435 left = SIMPLIFY_TEST_EXP (XEXP (exp, 0), insn_code, insn_index);
3436 SIMPLIFY_ALTERNATIVE (left);
3437 if (GET_CODE (left) == NOT)
3438 return XEXP (left, 0);
3440 if (left == false_rtx)
3442 else if (left == true_rtx)
3445 /* Try to apply De`Morgan's laws. */
3446 else if (GET_CODE (left) == IOR)
3448 newexp = attr_rtx (AND,
3449 attr_rtx (NOT, XEXP (left, 0)),
3450 attr_rtx (NOT, XEXP (left, 1)));
3452 newexp = SIMPLIFY_TEST_EXP (newexp, insn_code, insn_index);
3454 else if (GET_CODE (left) == AND)
3456 newexp = attr_rtx (IOR,
3457 attr_rtx (NOT, XEXP (left, 0)),
3458 attr_rtx (NOT, XEXP (left, 1)));
3460 newexp = SIMPLIFY_TEST_EXP (newexp, insn_code, insn_index);
3462 else if (left != XEXP (exp, 0))
3464 newexp = attr_rtx (NOT, left);
3469 if (current_alternative_string && XSTR (exp, 0) == alternative_name)
3470 return (XSTR (exp, 1) == current_alternative_string
3471 ? true_rtx : false_rtx);
3473 /* Look at the value for this insn code in the specified attribute.
3474 We normally can replace this comparison with the condition that
3475 would give this insn the values being tested for. */
3476 if (XSTR (exp, 0) != alternative_name
3477 && (attr = find_attr (XSTR (exp, 0), 0)) != NULL)
3478 for (av = attr->first_value; av; av = av->next)
3479 for (ie = av->first_insn; ie; ie = ie->next)
3480 if (ie->insn_code == insn_code)
3483 x = evaluate_eq_attr (exp, av->value, insn_code, insn_index);
3484 x = SIMPLIFY_TEST_EXP (x, insn_code, insn_index);
3485 if (attr_rtx_cost(x) < 20)
3494 /* We have already simplified this expression. Simplifying it again
3495 won't buy anything unless we weren't given a valid insn code
3496 to process (i.e., we are canonicalizing something.). */
3497 if (insn_code != -2 /* Seems wrong: && current_alternative_string. */
3498 && ! RTX_UNCHANGING_P (newexp))
3499 return copy_rtx_unchanging (newexp);
3504 /* Optimize the attribute lists by seeing if we can determine conditional
3505 values from the known values of other attributes. This will save subroutine
3506 calls during the compilation. */
3511 struct attr_desc *attr;
3512 struct attr_value *av;
3513 struct insn_ent *ie;
3516 struct attr_value_list
3518 struct attr_value *av;
3519 struct insn_ent *ie;
3520 struct attr_desc *attr;
3521 struct attr_value_list *next;
3523 struct attr_value_list **insn_code_values;
3524 struct attr_value_list *ivbuf;
3525 struct attr_value_list *iv;
3527 /* For each insn code, make a list of all the insn_ent's for it,
3528 for all values for all attributes. */
3530 if (num_insn_ents == 0)
3533 /* Make 2 extra elements, for "code" values -2 and -1. */
3535 = (struct attr_value_list **) xmalloc ((insn_code_number + 2)
3536 * sizeof (struct attr_value_list *));
3537 memset ((char *) insn_code_values, 0,
3538 (insn_code_number + 2) * sizeof (struct attr_value_list *));
3540 /* Offset the table address so we can index by -2 or -1. */
3541 insn_code_values += 2;
3543 iv = ivbuf = ((struct attr_value_list *)
3544 xmalloc (num_insn_ents * sizeof (struct attr_value_list)));
3546 for (i = 0; i < MAX_ATTRS_INDEX; i++)
3547 for (attr = attrs[i]; attr; attr = attr->next)
3548 for (av = attr->first_value; av; av = av->next)
3549 for (ie = av->first_insn; ie; ie = ie->next)
3554 iv->next = insn_code_values[ie->insn_code];
3555 insn_code_values[ie->insn_code] = iv;
3559 /* Sanity check on num_insn_ents. */
3560 if (iv != ivbuf + num_insn_ents)
3563 /* Process one insn code at a time. */
3564 for (i = -2; i < insn_code_number; i++)
3566 /* Clear the MEM_IN_STRUCT_P flag everywhere relevant.
3567 We use it to mean "already simplified for this insn". */
3568 for (iv = insn_code_values[i]; iv; iv = iv->next)
3569 clear_struct_flag (iv->av->value);
3571 for (iv = insn_code_values[i]; iv; iv = iv->next)
3573 struct obstack *old = rtl_obstack;
3578 if (GET_CODE (av->value) != COND)
3581 rtl_obstack = temp_obstack;
3582 #if 0 /* This was intended as a speed up, but it was slower. */
3583 if (insn_n_alternatives[ie->insn_code] > 6
3584 && count_sub_rtxs (av->value, 200) >= 200)
3585 newexp = simplify_by_alternatives (av->value, ie->insn_code,
3590 while (GET_CODE (newexp) == COND)
3592 rtx newexp2 = simplify_cond (newexp, ie->insn_code,
3594 if (newexp2 == newexp)
3600 if (newexp != av->value)
3602 newexp = attr_copy_rtx (newexp);
3603 remove_insn_ent (av, ie);
3604 av = get_attr_value (newexp, attr, ie->insn_code);
3606 insert_insn_ent (av, ie);
3612 free (insn_code_values - 2);
3617 simplify_by_alternatives (exp, insn_code, insn_index)
3619 int insn_code, insn_index;
3622 int len = insn_n_alternatives[insn_code];
3623 rtx newexp = rtx_alloc (COND);
3626 XVEC (newexp, 0) = rtvec_alloc (len * 2);
3628 /* It will not matter what value we use as the default value
3629 of the new COND, since that default will never be used.
3630 Choose something of the right type. */
3631 for (ultimate = exp; GET_CODE (ultimate) == COND;)
3632 ultimate = XEXP (ultimate, 1);
3633 XEXP (newexp, 1) = ultimate;
3635 for (i = 0; i < insn_n_alternatives[insn_code]; i++)
3637 current_alternative_string = attr_numeral (i);
3638 XVECEXP (newexp, 0, i * 2) = make_alternative_compare (1 << i);
3639 XVECEXP (newexp, 0, i * 2 + 1)
3640 = simplify_cond (exp, insn_code, insn_index);
3643 current_alternative_string = 0;
3644 return simplify_cond (newexp, insn_code, insn_index);
3648 /* If EXP is a suitable expression, reorganize it by constructing an
3649 equivalent expression that is a COND with the tests being all combinations
3650 of attribute values and the values being simple constants. */
3653 simplify_by_exploding (exp)
3656 rtx list = 0, link, condexp, defval = NULL_RTX;
3657 struct dimension *space;
3658 rtx *condtest, *condval;
3659 int i, j, total, ndim = 0;
3660 int most_tests, num_marks, new_marks;
3663 /* Locate all the EQ_ATTR expressions. */
3664 if (! find_and_mark_used_attributes (exp, &list, &ndim) || ndim == 0)
3666 unmark_used_attributes (list, 0, 0);
3670 /* Create an attribute space from the list of used attributes. For each
3671 dimension in the attribute space, record the attribute, list of values
3672 used, and number of values used. Add members to the list of values to
3673 cover the domain of the attribute. This makes the expanded COND form
3674 order independent. */
3676 space = (struct dimension *) xmalloc (ndim * sizeof (struct dimension));
3679 for (ndim = 0; list; ndim++)
3681 /* Pull the first attribute value from the list and record that
3682 attribute as another dimension in the attribute space. */
3683 const char *name = XSTR (XEXP (list, 0), 0);
3686 if ((space[ndim].attr = find_attr (name, 0)) == 0
3687 || space[ndim].attr->is_numeric)
3689 unmark_used_attributes (list, space, ndim);
3693 /* Add all remaining attribute values that refer to this attribute. */
3694 space[ndim].num_values = 0;
3695 space[ndim].values = 0;
3697 for (link = list; link; link = *prev)
3698 if (! strcmp (XSTR (XEXP (link, 0), 0), name))
3700 space[ndim].num_values++;
3701 *prev = XEXP (link, 1);
3702 XEXP (link, 1) = space[ndim].values;
3703 space[ndim].values = link;
3706 prev = &XEXP (link, 1);
3708 /* Add sufficient members to the list of values to make the list
3709 mutually exclusive and record the total size of the attribute
3711 total *= add_values_to_cover (&space[ndim]);
3714 /* Sort the attribute space so that the attributes go from non-constant
3715 to constant and from most values to least values. */
3716 for (i = 0; i < ndim; i++)
3717 for (j = ndim - 1; j > i; j--)
3718 if ((space[j-1].attr->is_const && !space[j].attr->is_const)
3719 || space[j-1].num_values < space[j].num_values)
3721 struct dimension tmp;
3723 space[j] = space[j - 1];
3727 /* Establish the initial current value. */
3728 for (i = 0; i < ndim; i++)
3729 space[i].current_value = space[i].values;
3731 condtest = (rtx *) xmalloc (total * sizeof (rtx));
3732 condval = (rtx *) xmalloc (total * sizeof (rtx));
3734 /* Expand the tests and values by iterating over all values in the
3738 condtest[i] = test_for_current_value (space, ndim);
3739 condval[i] = simplify_with_current_value (exp, space, ndim);
3740 if (! increment_current_value (space, ndim))
3746 /* We are now finished with the original expression. */
3747 unmark_used_attributes (0, space, ndim);
3750 /* Find the most used constant value and make that the default. */
3752 for (i = num_marks = 0; i < total; i++)
3753 if (GET_CODE (condval[i]) == CONST_STRING
3754 && ! MEM_VOLATILE_P (condval[i]))
3756 /* Mark the unmarked constant value and count how many are marked. */
3757 MEM_VOLATILE_P (condval[i]) = 1;
3758 for (j = new_marks = 0; j < total; j++)
3759 if (GET_CODE (condval[j]) == CONST_STRING
3760 && MEM_VOLATILE_P (condval[j]))
3762 if (new_marks - num_marks > most_tests)
3764 most_tests = new_marks - num_marks;
3765 defval = condval[i];
3767 num_marks = new_marks;
3769 /* Clear all the marks. */
3770 for (i = 0; i < total; i++)
3771 MEM_VOLATILE_P (condval[i]) = 0;
3773 /* Give up if nothing is constant. */
3777 /* If all values are the default, use that. */
3778 else if (total == most_tests)
3781 /* Make a COND with the most common constant value the default. (A more
3782 complex method where tests with the same value were combined didn't
3783 seem to improve things.) */
3786 condexp = rtx_alloc (COND);
3787 XVEC (condexp, 0) = rtvec_alloc ((total - most_tests) * 2);
3788 XEXP (condexp, 1) = defval;
3789 for (i = j = 0; i < total; i++)
3790 if (condval[i] != defval)
3792 XVECEXP (condexp, 0, 2 * j) = condtest[i];
3793 XVECEXP (condexp, 0, 2 * j + 1) = condval[i];
3803 /* Set the MEM_VOLATILE_P flag for all EQ_ATTR expressions in EXP and
3804 verify that EXP can be simplified to a constant term if all the EQ_ATTR
3805 tests have known value. */
3808 find_and_mark_used_attributes (exp, terms, nterms)
3814 switch (GET_CODE (exp))
3817 if (! MEM_VOLATILE_P (exp))
3819 rtx link = rtx_alloc (EXPR_LIST);
3820 XEXP (link, 0) = exp;
3821 XEXP (link, 1) = *terms;
3824 MEM_VOLATILE_P (exp) = 1;
3833 if (! find_and_mark_used_attributes (XEXP (exp, 2), terms, nterms))
3837 if (! find_and_mark_used_attributes (XEXP (exp, 1), terms, nterms))
3840 if (! find_and_mark_used_attributes (XEXP (exp, 0), terms, nterms))
3845 for (i = 0; i < XVECLEN (exp, 0); i++)
3846 if (! find_and_mark_used_attributes (XVECEXP (exp, 0, i), terms, nterms))
3848 if (! find_and_mark_used_attributes (XEXP (exp, 1), terms, nterms))
3857 /* Clear the MEM_VOLATILE_P flag in all EQ_ATTR expressions on LIST and
3858 in the values of the NDIM-dimensional attribute space SPACE. */
3861 unmark_used_attributes (list, space, ndim)
3863 struct dimension *space;
3869 for (i = 0; i < ndim; i++)
3870 unmark_used_attributes (space[i].values, 0, 0);
3872 for (link = list; link; link = XEXP (link, 1))
3874 exp = XEXP (link, 0);
3875 if (GET_CODE (exp) == EQ_ATTR)
3876 MEM_VOLATILE_P (exp) = 0;
3880 /* Update the attribute dimension DIM so that all values of the attribute
3881 are tested. Return the updated number of values. */
3884 add_values_to_cover (dim)
3885 struct dimension *dim;
3887 struct attr_value *av;
3888 rtx exp, link, *prev;
3891 for (av = dim->attr->first_value; av; av = av->next)
3892 if (GET_CODE (av->value) == CONST_STRING)
3895 if (nalt < dim->num_values)
3897 else if (nalt == dim->num_values)
3900 else if (nalt * 2 < dim->num_values * 3)
3902 /* Most all the values of the attribute are used, so add all the unused
3904 prev = &dim->values;
3905 for (link = dim->values; link; link = *prev)
3906 prev = &XEXP (link, 1);
3908 for (av = dim->attr->first_value; av; av = av->next)
3909 if (GET_CODE (av->value) == CONST_STRING)
3911 exp = attr_eq (dim->attr->name, XSTR (av->value, 0));
3912 if (MEM_VOLATILE_P (exp))
3915 link = rtx_alloc (EXPR_LIST);
3916 XEXP (link, 0) = exp;
3919 prev = &XEXP (link, 1);
3921 dim->num_values = nalt;
3925 rtx orexp = false_rtx;
3927 /* Very few values are used, so compute a mutually exclusive
3928 expression. (We could do this for numeric values if that becomes
3930 prev = &dim->values;
3931 for (link = dim->values; link; link = *prev)
3933 orexp = insert_right_side (IOR, orexp, XEXP (link, 0), -2, -2);
3934 prev = &XEXP (link, 1);
3936 link = rtx_alloc (EXPR_LIST);
3937 XEXP (link, 0) = attr_rtx (NOT, orexp);
3942 return dim->num_values;
3945 /* Increment the current value for the NDIM-dimensional attribute space SPACE
3946 and return FALSE if the increment overflowed. */
3949 increment_current_value (space, ndim)
3950 struct dimension *space;
3955 for (i = ndim - 1; i >= 0; i--)
3957 if ((space[i].current_value = XEXP (space[i].current_value, 1)) == 0)
3958 space[i].current_value = space[i].values;
3965 /* Construct an expression corresponding to the current value for the
3966 NDIM-dimensional attribute space SPACE. */
3969 test_for_current_value (space, ndim)
3970 struct dimension *space;
3976 for (i = 0; i < ndim; i++)
3977 exp = insert_right_side (AND, exp, XEXP (space[i].current_value, 0),
3983 /* Given the current value of the NDIM-dimensional attribute space SPACE,
3984 set the corresponding EQ_ATTR expressions to that value and reduce
3985 the expression EXP as much as possible. On input [and output], all
3986 known EQ_ATTR expressions are set to FALSE. */
3989 simplify_with_current_value (exp, space, ndim)
3991 struct dimension *space;
3997 /* Mark each current value as TRUE. */
3998 for (i = 0; i < ndim; i++)
4000 x = XEXP (space[i].current_value, 0);
4001 if (GET_CODE (x) == EQ_ATTR)
4002 MEM_VOLATILE_P (x) = 0;
4005 exp = simplify_with_current_value_aux (exp);
4007 /* Change each current value back to FALSE. */
4008 for (i = 0; i < ndim; i++)
4010 x = XEXP (space[i].current_value, 0);
4011 if (GET_CODE (x) == EQ_ATTR)
4012 MEM_VOLATILE_P (x) = 1;
4018 /* Reduce the expression EXP based on the MEM_VOLATILE_P settings of
4019 all EQ_ATTR expressions. */
4022 simplify_with_current_value_aux (exp)
4028 switch (GET_CODE (exp))
4031 if (MEM_VOLATILE_P (exp))
4040 cond = simplify_with_current_value_aux (XEXP (exp, 0));
4041 if (cond == true_rtx)
4042 return simplify_with_current_value_aux (XEXP (exp, 1));
4043 else if (cond == false_rtx)
4044 return simplify_with_current_value_aux (XEXP (exp, 2));
4046 return attr_rtx (IF_THEN_ELSE, cond,
4047 simplify_with_current_value_aux (XEXP (exp, 1)),
4048 simplify_with_current_value_aux (XEXP (exp, 2)));
4051 cond = simplify_with_current_value_aux (XEXP (exp, 1));
4052 if (cond == true_rtx)
4054 else if (cond == false_rtx)
4055 return simplify_with_current_value_aux (XEXP (exp, 0));
4057 return attr_rtx (IOR, cond,
4058 simplify_with_current_value_aux (XEXP (exp, 0)));
4061 cond = simplify_with_current_value_aux (XEXP (exp, 1));
4062 if (cond == true_rtx)
4063 return simplify_with_current_value_aux (XEXP (exp, 0));
4064 else if (cond == false_rtx)
4067 return attr_rtx (AND, cond,
4068 simplify_with_current_value_aux (XEXP (exp, 0)));
4071 cond = simplify_with_current_value_aux (XEXP (exp, 0));
4072 if (cond == true_rtx)
4074 else if (cond == false_rtx)
4077 return attr_rtx (NOT, cond);
4080 for (i = 0; i < XVECLEN (exp, 0); i += 2)
4082 cond = simplify_with_current_value_aux (XVECEXP (exp, 0, i));
4083 if (cond == true_rtx)
4084 return simplify_with_current_value_aux (XVECEXP (exp, 0, i + 1));
4085 else if (cond == false_rtx)
4088 abort (); /* With all EQ_ATTR's of known value, a case should
4089 have been selected. */
4091 return simplify_with_current_value_aux (XEXP (exp, 1));
4098 /* Clear the MEM_IN_STRUCT_P flag in EXP and its subexpressions. */
4101 clear_struct_flag (x)
4106 register enum rtx_code code;
4107 register const char *fmt;
4109 MEM_IN_STRUCT_P (x) = 0;
4110 if (RTX_UNCHANGING_P (x))
4113 code = GET_CODE (x);
4133 /* Compare the elements. If any pair of corresponding elements
4134 fail to match, return 0 for the whole things. */
4136 fmt = GET_RTX_FORMAT (code);
4137 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
4143 for (j = 0; j < XVECLEN (x, i); j++)
4144 clear_struct_flag (XVECEXP (x, i, j));
4148 clear_struct_flag (XEXP (x, i));
4154 /* Return the number of RTX objects making up the expression X.
4155 But if we count more than MAX objects, stop counting. */
4158 count_sub_rtxs (x, max)
4164 register enum rtx_code code;
4165 register const char *fmt;
4168 code = GET_CODE (x);
4188 /* Compare the elements. If any pair of corresponding elements
4189 fail to match, return 0 for the whole things. */
4191 fmt = GET_RTX_FORMAT (code);
4192 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
4201 for (j = 0; j < XVECLEN (x, i); j++)
4202 total += count_sub_rtxs (XVECEXP (x, i, j), max);
4206 total += count_sub_rtxs (XEXP (x, i), max);
4214 /* Create table entries for DEFINE_ATTR. */
4217 gen_attr (exp, lineno)
4221 struct attr_desc *attr;
4222 struct attr_value *av;
4223 const char *name_ptr;
4226 /* Make a new attribute structure. Check for duplicate by looking at
4227 attr->default_val, since it is initialized by this routine. */
4228 attr = find_attr (XSTR (exp, 0), 1);
4229 if (attr->default_val)
4231 message_with_line (lineno, "duplicate definition for attribute %s",
4233 message_with_line (attr->lineno, "previous definition");
4237 attr->lineno = lineno;
4239 if (*XSTR (exp, 1) == '\0')
4240 attr->is_numeric = 1;
4243 name_ptr = XSTR (exp, 1);
4244 while ((p = next_comma_elt (&name_ptr)) != NULL)
4246 av = (struct attr_value *) oballoc (sizeof (struct attr_value));
4247 av->value = attr_rtx (CONST_STRING, p);
4248 av->next = attr->first_value;
4249 attr->first_value = av;
4250 av->first_insn = NULL;
4252 av->has_asm_insn = 0;
4256 if (GET_CODE (XEXP (exp, 2)) == CONST)
4259 if (attr->is_numeric)
4261 message_with_line (lineno,
4262 "constant attributes may not take numeric values");
4266 /* Get rid of the CONST node. It is allowed only at top-level. */
4267 XEXP (exp, 2) = XEXP (XEXP (exp, 2), 0);
4270 if (! strcmp (attr->name, "length") && ! attr->is_numeric)
4272 message_with_line (lineno,
4273 "`length' attribute must take numeric values");
4277 /* Set up the default value. */
4278 XEXP (exp, 2) = check_attr_value (XEXP (exp, 2), attr);
4279 attr->default_val = get_attr_value (XEXP (exp, 2), attr, -2);
4282 /* Given a pattern for DEFINE_PEEPHOLE or DEFINE_INSN, return the number of
4283 alternatives in the constraints. Assume all MATCH_OPERANDs have the same
4284 number of alternatives as this should be checked elsewhere. */
4287 count_alternatives (exp)
4293 if (GET_CODE (exp) == MATCH_OPERAND)
4294 return n_comma_elts (XSTR (exp, 2));
4296 for (i = 0, fmt = GET_RTX_FORMAT (GET_CODE (exp));
4297 i < GET_RTX_LENGTH (GET_CODE (exp)); i++)
4302 n = count_alternatives (XEXP (exp, i));
4309 if (XVEC (exp, i) != NULL)
4310 for (j = 0; j < XVECLEN (exp, i); j++)
4312 n = count_alternatives (XVECEXP (exp, i, j));
4321 /* Returns non-zero if the given expression contains an EQ_ATTR with the
4322 `alternative' attribute. */
4325 compares_alternatives_p (exp)
4331 if (GET_CODE (exp) == EQ_ATTR && XSTR (exp, 0) == alternative_name)
4334 for (i = 0, fmt = GET_RTX_FORMAT (GET_CODE (exp));
4335 i < GET_RTX_LENGTH (GET_CODE (exp)); i++)
4340 if (compares_alternatives_p (XEXP (exp, i)))
4345 for (j = 0; j < XVECLEN (exp, i); j++)
4346 if (compares_alternatives_p (XVECEXP (exp, i, j)))
4354 /* Returns non-zero is INNER is contained in EXP. */
4357 contained_in_p (inner, exp)
4364 if (rtx_equal_p (inner, exp))
4367 for (i = 0, fmt = GET_RTX_FORMAT (GET_CODE (exp));
4368 i < GET_RTX_LENGTH (GET_CODE (exp)); i++)
4373 if (contained_in_p (inner, XEXP (exp, i)))
4378 for (j = 0; j < XVECLEN (exp, i); j++)
4379 if (contained_in_p (inner, XVECEXP (exp, i, j)))
4387 /* Process DEFINE_PEEPHOLE, DEFINE_INSN, and DEFINE_ASM_ATTRIBUTES. */
4390 gen_insn (exp, lineno)
4394 struct insn_def *id;
4396 id = (struct insn_def *) oballoc (sizeof (struct insn_def));
4400 id->lineno = lineno;
4402 switch (GET_CODE (exp))
4405 id->insn_code = insn_code_number;
4406 id->insn_index = insn_index_number;
4407 id->num_alternatives = count_alternatives (exp);
4408 if (id->num_alternatives == 0)
4409 id->num_alternatives = 1;
4413 case DEFINE_PEEPHOLE:
4414 id->insn_code = insn_code_number;
4415 id->insn_index = insn_index_number;
4416 id->num_alternatives = count_alternatives (exp);
4417 if (id->num_alternatives == 0)
4418 id->num_alternatives = 1;
4422 case DEFINE_ASM_ATTRIBUTES:
4424 id->insn_index = -1;
4425 id->num_alternatives = 1;
4427 got_define_asm_attributes = 1;
4435 /* Process a DEFINE_DELAY. Validate the vector length, check if annul
4436 true or annul false is specified, and make a `struct delay_desc'. */
4439 gen_delay (def, lineno)
4443 struct delay_desc *delay;
4446 if (XVECLEN (def, 1) % 3 != 0)
4448 message_with_line (lineno,
4449 "number of elements in DEFINE_DELAY must be multiple of three");
4454 for (i = 0; i < XVECLEN (def, 1); i += 3)
4456 if (XVECEXP (def, 1, i + 1))
4457 have_annul_true = 1;
4458 if (XVECEXP (def, 1, i + 2))
4459 have_annul_false = 1;
4462 delay = (struct delay_desc *) oballoc (sizeof (struct delay_desc));
4464 delay->num = ++num_delays;
4465 delay->next = delays;
4466 delay->lineno = lineno;
4470 /* Process a DEFINE_FUNCTION_UNIT.
4472 This gives information about a function unit contained in the CPU.
4473 We fill in a `struct function_unit_op' and a `struct function_unit'
4474 with information used later by `expand_unit'. */
4477 gen_unit (def, lineno)
4481 struct function_unit *unit;
4482 struct function_unit_op *op;
4483 const char *name = XSTR (def, 0);
4484 int multiplicity = XINT (def, 1);
4485 int simultaneity = XINT (def, 2);
4486 rtx condexp = XEXP (def, 3);
4487 int ready_cost = MAX (XINT (def, 4), 1);
4488 int issue_delay = MAX (XINT (def, 5), 1);
4490 /* See if we have already seen this function unit. If so, check that
4491 the multiplicity and simultaneity values are the same. If not, make
4492 a structure for this function unit. */
4493 for (unit = units; unit; unit = unit->next)
4494 if (! strcmp (unit->name, name))
4496 if (unit->multiplicity != multiplicity
4497 || unit->simultaneity != simultaneity)
4499 message_with_line (lineno,
4500 "differing specifications given for function unit %s",
4502 message_with_line (unit->first_lineno, "previous definition");
4511 unit = (struct function_unit *) oballoc (sizeof (struct function_unit));
4513 unit->multiplicity = multiplicity;
4514 unit->simultaneity = simultaneity;
4515 unit->issue_delay.min = unit->issue_delay.max = issue_delay;
4516 unit->num = num_units++;
4517 unit->num_opclasses = 0;
4518 unit->condexp = false_rtx;
4521 unit->first_lineno = lineno;
4525 /* Make a new operation class structure entry and initialize it. */
4526 op = (struct function_unit_op *) oballoc (sizeof (struct function_unit_op));
4527 op->condexp = condexp;
4528 op->num = unit->num_opclasses++;
4529 op->ready = ready_cost;
4530 op->issue_delay = issue_delay;
4531 op->next = unit->ops;
4532 op->lineno = lineno;
4534 num_unit_opclasses++;
4536 /* Set our issue expression based on whether or not an optional conflict
4537 vector was specified. */
4540 /* Compute the IOR of all the specified expressions. */
4541 rtx orexp = false_rtx;
4544 for (i = 0; i < XVECLEN (def, 6); i++)
4545 orexp = insert_right_side (IOR, orexp, XVECEXP (def, 6, i), -2, -2);
4547 op->conflict_exp = orexp;
4548 extend_range (&unit->issue_delay, 1, issue_delay);
4552 op->conflict_exp = true_rtx;
4553 extend_range (&unit->issue_delay, issue_delay, issue_delay);
4556 /* Merge our conditional into that of the function unit so we can determine
4557 which insns are used by the function unit. */
4558 unit->condexp = insert_right_side (IOR, unit->condexp, op->condexp, -2, -2);
4561 /* Given a piece of RTX, print a C expression to test its truth value.
4562 We use AND and IOR both for logical and bit-wise operations, so
4563 interpret them as logical unless they are inside a comparison expression.
4564 The first bit of FLAGS will be non-zero in that case.
4566 Set the second bit of FLAGS to make references to attribute values use
4567 a cached local variable instead of calling a function. */
4570 write_test_expr (exp, flags)
4574 int comparison_operator = 0;
4576 struct attr_desc *attr;
4578 /* In order not to worry about operator precedence, surround our part of
4579 the expression with parentheses. */
4582 code = GET_CODE (exp);
4585 /* Binary operators. */
4587 case GE: case GT: case GEU: case GTU:
4588 case LE: case LT: case LEU: case LTU:
4589 comparison_operator = 1;
4591 case PLUS: case MINUS: case MULT: case DIV: case MOD:
4592 case AND: case IOR: case XOR:
4593 case ASHIFT: case LSHIFTRT: case ASHIFTRT:
4594 write_test_expr (XEXP (exp, 0), flags | comparison_operator);
4610 printf (" >= (unsigned) ");
4613 printf (" > (unsigned) ");
4622 printf (" <= (unsigned) ");
4625 printf (" < (unsigned) ");
4668 write_test_expr (XEXP (exp, 1), flags | comparison_operator);
4672 /* Special-case (not (eq_attrq "alternative" "x")) */
4673 if (! (flags & 1) && GET_CODE (XEXP (exp, 0)) == EQ_ATTR
4674 && XSTR (XEXP (exp, 0), 0) == alternative_name)
4676 printf ("which_alternative != %s", XSTR (XEXP (exp, 0), 1));
4680 /* Otherwise, fall through to normal unary operator. */
4682 /* Unary operators. */
4702 write_test_expr (XEXP (exp, 0), flags);
4705 /* Comparison test of an attribute with a value. Most of these will
4706 have been removed by optimization. Handle "alternative"
4707 specially and give error if EQ_ATTR present inside a comparison. */
4710 fatal ("EQ_ATTR not valid inside comparison");
4712 if (XSTR (exp, 0) == alternative_name)
4714 printf ("which_alternative == %s", XSTR (exp, 1));
4718 attr = find_attr (XSTR (exp, 0), 0);
4722 /* Now is the time to expand the value of a constant attribute. */
4725 write_test_expr (evaluate_eq_attr (exp, attr->default_val->value,
4732 printf ("attr_%s", attr->name);
4734 printf ("get_attr_%s (insn)", attr->name);
4736 write_attr_valueq (attr, XSTR (exp, 1));
4740 /* Comparison test of flags for define_delays. */
4743 fatal ("ATTR_FLAG not valid inside comparison");
4744 printf ("(flags & ATTR_FLAG_%s) != 0", XSTR (exp, 0));
4747 /* See if an operand matches a predicate. */
4749 /* If only a mode is given, just ensure the mode matches the operand.
4750 If neither a mode nor predicate is given, error. */
4751 if (XSTR (exp, 1) == NULL || *XSTR (exp, 1) == '\0')
4753 if (GET_MODE (exp) == VOIDmode)
4754 fatal ("Null MATCH_OPERAND specified as test");
4756 printf ("GET_MODE (operands[%d]) == %smode",
4757 XINT (exp, 0), GET_MODE_NAME (GET_MODE (exp)));
4760 printf ("%s (operands[%d], %smode)",
4761 XSTR (exp, 1), XINT (exp, 0), GET_MODE_NAME (GET_MODE (exp)));
4765 printf ("%s (insn)", XSTR (exp, 0));
4768 /* Constant integer. */
4770 printf (HOST_WIDE_INT_PRINT_DEC, XWINT (exp, 0));
4773 /* A random C expression. */
4775 printf ("%s", XSTR (exp, 0));
4778 /* The address of the branch target. */
4780 printf ("INSN_ADDRESSES_SET_P () ? INSN_ADDRESSES (INSN_UID (GET_CODE (operands[%d]) == LABEL_REF ? XEXP (operands[%d], 0) : operands[%d])) : 0",
4781 XINT (exp, 0), XINT (exp, 0), XINT (exp, 0));
4785 /* The address of the current insn. We implement this actually as the
4786 address of the current insn for backward branches, but the last
4787 address of the next insn for forward branches, and both with
4788 adjustments that account for the worst-case possible stretching of
4789 intervening alignments between this insn and its destination. */
4790 printf ("insn_current_reference_address (insn)");
4794 printf ("%s", XSTR (exp, 0));
4798 write_test_expr (XEXP (exp, 0), flags & 2);
4800 write_test_expr (XEXP (exp, 1), flags | 1);
4802 write_test_expr (XEXP (exp, 2), flags | 1);
4806 fatal ("bad RTX code `%s' in attribute calculation\n",
4807 GET_RTX_NAME (code));
4813 /* Given an attribute value, return the maximum CONST_STRING argument
4814 encountered. Set *UNKNOWNP and return INT_MAX if the value is unknown. */
4817 max_attr_value (exp, unknownp)
4824 switch (GET_CODE (exp))
4827 current_max = atoi (XSTR (exp, 0));
4831 current_max = max_attr_value (XEXP (exp, 1), unknownp);
4832 for (i = 0; i < XVECLEN (exp, 0); i += 2)
4834 n = max_attr_value (XVECEXP (exp, 0, i + 1), unknownp);
4835 if (n > current_max)
4841 current_max = max_attr_value (XEXP (exp, 1), unknownp);
4842 n = max_attr_value (XEXP (exp, 2), unknownp);
4843 if (n > current_max)
4849 current_max = INT_MAX;
4856 /* Given an attribute value, return the result of ORing together all
4857 CONST_STRING arguments encountered. Set *UNKNOWNP and return -1
4858 if the numeric value is not known. */
4861 or_attr_value (exp, unknownp)
4868 switch (GET_CODE (exp))
4871 current_or = atoi (XSTR (exp, 0));
4875 current_or = or_attr_value (XEXP (exp, 1), unknownp);
4876 for (i = 0; i < XVECLEN (exp, 0); i += 2)
4877 current_or |= or_attr_value (XVECEXP (exp, 0, i + 1), unknownp);
4881 current_or = or_attr_value (XEXP (exp, 1), unknownp);
4882 current_or |= or_attr_value (XEXP (exp, 2), unknownp);
4894 /* Scan an attribute value, possibly a conditional, and record what actions
4895 will be required to do any conditional tests in it.
4898 `must_extract' if we need to extract the insn operands
4899 `must_constrain' if we must compute `which_alternative'
4900 `address_used' if an address expression was used
4901 `length_used' if an (eq_attr "length" ...) was used
4905 walk_attr_value (exp)
4909 register const char *fmt;
4915 code = GET_CODE (exp);
4919 if (! RTX_UNCHANGING_P (exp))
4920 /* Since this is an arbitrary expression, it can look at anything.
4921 However, constant expressions do not depend on any particular
4923 must_extract = must_constrain = 1;
4931 if (XSTR (exp, 0) == alternative_name)
4932 must_extract = must_constrain = 1;
4933 else if (strcmp (XSTR (exp, 0), "length") == 0)
4953 for (i = 0, fmt = GET_RTX_FORMAT (code); i < GET_RTX_LENGTH (code); i++)
4958 walk_attr_value (XEXP (exp, i));
4962 if (XVEC (exp, i) != NULL)
4963 for (j = 0; j < XVECLEN (exp, i); j++)
4964 walk_attr_value (XVECEXP (exp, i, j));
4969 /* Write out a function to obtain the attribute for a given INSN. */
4972 write_attr_get (attr)
4973 struct attr_desc *attr;
4975 struct attr_value *av, *common_av;
4977 /* Find the most used attribute value. Handle that as the `default' of the
4978 switch we will generate. */
4979 common_av = find_most_used (attr);
4981 /* Write out prototype of function. */
4982 if (!attr->is_numeric)
4983 printf ("extern enum attr_%s ", attr->name);
4984 else if (attr->unsigned_p)
4985 printf ("extern unsigned int ");
4987 printf ("extern int ");
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 PARAMS ((rtx));\n", &attr->name[1]);
4993 printf ("get_attr_%s PARAMS ((%s));\n", attr->name,
4994 (attr->is_const ? "void" : "rtx"));
4996 /* Write out start of function, then all values with explicit `case' lines,
4997 then a `default', then the value with the most uses. */
4998 if (!attr->is_numeric)
4999 printf ("enum attr_%s\n", attr->name);
5000 else if (attr->unsigned_p)
5001 printf ("unsigned int\n");
5005 /* If the attribute name starts with a star, the remainder is the name of
5006 the subroutine to use, instead of `get_attr_...'. */
5007 if (attr->name[0] == '*')
5008 printf ("%s (insn)\n", &attr->name[1]);
5009 else if (attr->is_const == 0)
5010 printf ("get_attr_%s (insn)\n", attr->name);
5013 printf ("get_attr_%s ()\n", attr->name);
5016 for (av = attr->first_value; av; av = av->next)
5017 if (av->num_insns != 0)
5018 write_attr_set (attr, 2, av->value, "return", ";",
5019 true_rtx, av->first_insn->insn_code,
5020 av->first_insn->insn_index);
5026 printf (" rtx insn;\n");
5029 if (GET_CODE (common_av->value) == FFS)
5031 rtx p = XEXP (common_av->value, 0);
5033 /* No need to emit code to abort if the insn is unrecognized; the
5034 other get_attr_foo functions will do that when we call them. */
5036 write_toplevel_expr (p);
5038 printf ("\n if (accum && accum == (accum & -accum))\n");
5040 printf (" int i;\n");
5041 printf (" for (i = 0; accum >>= 1; ++i) continue;\n");
5042 printf (" accum = i;\n");
5043 printf (" }\n else\n");
5044 printf (" accum = ~accum;\n");
5045 printf (" return accum;\n}\n\n");
5049 printf (" switch (recog_memoized (insn))\n");
5052 for (av = attr->first_value; av; av = av->next)
5053 if (av != common_av)
5054 write_attr_case (attr, av, 1, "return", ";", 4, true_rtx);
5056 write_attr_case (attr, common_av, 0, "return", ";", 4, true_rtx);
5057 printf (" }\n}\n\n");
5061 /* Given an AND tree of known true terms (because we are inside an `if' with
5062 that as the condition or are in an `else' clause) and an expression,
5063 replace any known true terms with TRUE. Use `simplify_and_tree' to do
5064 the bulk of the work. */
5067 eliminate_known_true (known_true, exp, insn_code, insn_index)
5070 int insn_code, insn_index;
5074 known_true = SIMPLIFY_TEST_EXP (known_true, insn_code, insn_index);
5076 if (GET_CODE (known_true) == AND)
5078 exp = eliminate_known_true (XEXP (known_true, 0), exp,
5079 insn_code, insn_index);
5080 exp = eliminate_known_true (XEXP (known_true, 1), exp,
5081 insn_code, insn_index);
5086 exp = simplify_and_tree (exp, &term, insn_code, insn_index);
5092 /* Write out a series of tests and assignment statements to perform tests and
5093 sets of an attribute value. We are passed an indentation amount and prefix
5094 and suffix strings to write around each attribute value (e.g., "return"
5098 write_attr_set (attr, indent, value, prefix, suffix, known_true,
5099 insn_code, insn_index)
5100 struct attr_desc *attr;
5106 int insn_code, insn_index;
5108 if (GET_CODE (value) == COND)
5110 /* Assume the default value will be the default of the COND unless we
5111 find an always true expression. */
5112 rtx default_val = XEXP (value, 1);
5113 rtx our_known_true = known_true;
5118 for (i = 0; i < XVECLEN (value, 0); i += 2)
5123 testexp = eliminate_known_true (our_known_true,
5124 XVECEXP (value, 0, i),
5125 insn_code, insn_index);
5126 newexp = attr_rtx (NOT, testexp);
5127 newexp = insert_right_side (AND, our_known_true, newexp,
5128 insn_code, insn_index);
5130 /* If the test expression is always true or if the next `known_true'
5131 expression is always false, this is the last case, so break
5132 out and let this value be the `else' case. */
5133 if (testexp == true_rtx || newexp == false_rtx)
5135 default_val = XVECEXP (value, 0, i + 1);
5139 /* Compute the expression to pass to our recursive call as being
5141 inner_true = insert_right_side (AND, our_known_true,
5142 testexp, insn_code, insn_index);
5144 /* If this is always false, skip it. */
5145 if (inner_true == false_rtx)
5148 write_indent (indent);
5149 printf ("%sif ", first_if ? "" : "else ");
5151 write_test_expr (testexp, 0);
5153 write_indent (indent + 2);
5156 write_attr_set (attr, indent + 4,
5157 XVECEXP (value, 0, i + 1), prefix, suffix,
5158 inner_true, insn_code, insn_index);
5159 write_indent (indent + 2);
5161 our_known_true = newexp;
5166 write_indent (indent);
5168 write_indent (indent + 2);
5172 write_attr_set (attr, first_if ? indent : indent + 4, default_val,
5173 prefix, suffix, our_known_true, insn_code, insn_index);
5177 write_indent (indent + 2);
5183 write_indent (indent);
5184 printf ("%s ", prefix);
5185 write_attr_value (attr, value);
5186 printf ("%s\n", suffix);
5190 /* Write out the computation for one attribute value. */
5193 write_attr_case (attr, av, write_case_lines, prefix, suffix, indent,
5195 struct attr_desc *attr;
5196 struct attr_value *av;
5197 int write_case_lines;
5198 const char *prefix, *suffix;
5202 struct insn_ent *ie;
5204 if (av->num_insns == 0)
5207 if (av->has_asm_insn)
5209 write_indent (indent);
5210 printf ("case -1:\n");
5211 write_indent (indent + 2);
5212 printf ("if (GET_CODE (PATTERN (insn)) != ASM_INPUT\n");
5213 write_indent (indent + 2);
5214 printf (" && asm_noperands (PATTERN (insn)) < 0)\n");
5215 write_indent (indent + 2);
5216 printf (" fatal_insn_not_found (insn);\n");
5219 if (write_case_lines)
5221 for (ie = av->first_insn; ie; ie = ie->next)
5222 if (ie->insn_code != -1)
5224 write_indent (indent);
5225 printf ("case %d:\n", ie->insn_code);
5230 write_indent (indent);
5231 printf ("default:\n");
5234 /* See what we have to do to output this value. */
5235 must_extract = must_constrain = address_used = 0;
5236 walk_attr_value (av->value);
5240 write_indent (indent + 2);
5241 printf ("extract_constrain_insn_cached (insn);\n");
5243 else if (must_extract)
5245 write_indent (indent + 2);
5246 printf ("extract_insn_cached (insn);\n");
5249 write_attr_set (attr, indent + 2, av->value, prefix, suffix,
5250 known_true, av->first_insn->insn_code,
5251 av->first_insn->insn_index);
5253 if (strncmp (prefix, "return", 6))
5255 write_indent (indent + 2);
5256 printf ("break;\n");
5261 /* Search for uses of non-const attributes and write code to cache them. */
5264 write_expr_attr_cache (p, attr)
5266 struct attr_desc *attr;
5271 if (GET_CODE (p) == EQ_ATTR)
5273 if (XSTR (p, 0) != attr->name)
5276 if (!attr->is_numeric)
5277 printf (" register enum attr_%s ", attr->name);
5278 else if (attr->unsigned_p)
5279 printf (" register unsigned int ");
5281 printf (" register int ");
5283 printf ("attr_%s = get_attr_%s (insn);\n", attr->name, attr->name);
5287 fmt = GET_RTX_FORMAT (GET_CODE (p));
5288 ie = GET_RTX_LENGTH (GET_CODE (p));
5289 for (i = 0; i < ie; i++)
5294 if (write_expr_attr_cache (XEXP (p, i), attr))
5299 je = XVECLEN (p, i);
5300 for (j = 0; j < je; ++j)
5301 if (write_expr_attr_cache (XVECEXP (p, i, j), attr))
5310 /* Evaluate an expression at top level. A front end to write_test_expr,
5311 in which we cache attribute values and break up excessively large
5312 expressions to cater to older compilers. */
5315 write_toplevel_expr (p)
5318 struct attr_desc *attr;
5321 for (i = 0; i < MAX_ATTRS_INDEX; ++i)
5322 for (attr = attrs[i]; attr; attr = attr->next)
5323 if (!attr->is_const)
5324 write_expr_attr_cache (p, attr);
5326 printf (" register unsigned long accum = 0;\n\n");
5328 while (GET_CODE (p) == IOR)
5331 if (GET_CODE (XEXP (p, 0)) == IOR)
5332 e = XEXP (p, 1), p = XEXP (p, 0);
5334 e = XEXP (p, 0), p = XEXP (p, 1);
5336 printf (" accum |= ");
5337 write_test_expr (e, 3);
5340 printf (" accum |= ");
5341 write_test_expr (p, 3);
5345 /* Utilities to write names in various forms. */
5348 write_unit_name (prefix, num, suffix)
5353 struct function_unit *unit;
5355 for (unit = units; unit; unit = unit->next)
5356 if (unit->num == num)
5358 printf ("%s%s%s", prefix, unit->name, suffix);
5362 printf ("%s<unknown>%s", prefix, suffix);
5366 write_attr_valueq (attr, s)
5367 struct attr_desc *attr;
5370 if (attr->is_numeric)
5376 /* Make the blockage range values and function units used values easier
5378 if (attr->func_units_p)
5381 printf (" /* units: none */");
5383 write_unit_name (" /* units: ", num, " */");
5387 const char *sep = " /* units: ";
5388 for (i = 0, num = ~num; num; i++, num >>= 1)
5391 write_unit_name (sep, i, (num == 1) ? " */" : "");
5397 else if (attr->blockage_p)
5398 printf (" /* min %d, max %d */", num >> (HOST_BITS_PER_INT / 2),
5399 num & ((1 << (HOST_BITS_PER_INT / 2)) - 1));
5401 else if (num > 9 || num < 0)
5402 printf (" /* 0x%x */", num);
5406 write_upcase (attr->name);
5413 write_attr_value (attr, value)
5414 struct attr_desc *attr;
5419 switch (GET_CODE (value))
5422 write_attr_valueq (attr, XSTR (value, 0));
5426 printf (HOST_WIDE_INT_PRINT_DEC, INTVAL (value));
5430 fputs (XSTR (value, 0), stdout);
5435 struct attr_desc *attr2 = find_attr (XSTR (value, 0), 0);
5436 printf ("get_attr_%s (%s)", attr2->name,
5437 (attr2->is_const ? "" : "insn"));
5458 write_attr_value (attr, XEXP (value, 0));
5462 write_attr_value (attr, XEXP (value, 1));
5476 /* The argument of TOUPPER should not have side effects. */
5477 putchar (TOUPPER(*str));
5483 write_indent (indent)
5486 for (; indent > 8; indent -= 8)
5489 for (; indent; indent--)
5493 /* Write a subroutine that is given an insn that requires a delay slot, a
5494 delay slot ordinal, and a candidate insn. It returns non-zero if the
5495 candidate can be placed in the specified delay slot of the insn.
5497 We can write as many as three subroutines. `eligible_for_delay'
5498 handles normal delay slots, `eligible_for_annul_true' indicates that
5499 the specified insn can be annulled if the branch is true, and likewise
5500 for `eligible_for_annul_false'.
5502 KIND is a string distinguishing these three cases ("delay", "annul_true",
5503 or "annul_false"). */
5506 write_eligible_delay (kind)
5509 struct delay_desc *delay;
5512 struct attr_desc *attr;
5513 struct attr_value *av, *common_av;
5516 /* Compute the maximum number of delay slots required. We use the delay
5517 ordinal times this number plus one, plus the slot number as an index into
5518 the appropriate predicate to test. */
5520 for (delay = delays, max_slots = 0; delay; delay = delay->next)
5521 if (XVECLEN (delay->def, 1) / 3 > max_slots)
5522 max_slots = XVECLEN (delay->def, 1) / 3;
5524 /* Write function prelude. */
5527 printf ("eligible_for_%s (delay_insn, slot, candidate_insn, flags)\n",
5529 printf (" rtx delay_insn;\n");
5530 printf (" int slot;\n");
5531 printf (" rtx candidate_insn;\n");
5532 printf (" int flags ATTRIBUTE_UNUSED;\n");
5534 printf (" rtx insn;\n");
5536 printf (" if (slot >= %d)\n", max_slots);
5537 printf (" abort ();\n");
5540 /* If more than one delay type, find out which type the delay insn is. */
5544 attr = find_attr ("*delay_type", 0);
5547 common_av = find_most_used (attr);
5549 printf (" insn = delay_insn;\n");
5550 printf (" switch (recog_memoized (insn))\n");
5553 sprintf (str, " * %d;\n break;", max_slots);
5554 for (av = attr->first_value; av; av = av->next)
5555 if (av != common_av)
5556 write_attr_case (attr, av, 1, "slot +=", str, 4, true_rtx);
5558 write_attr_case (attr, common_av, 0, "slot +=", str, 4, true_rtx);
5561 /* Ensure matched. Otherwise, shouldn't have been called. */
5562 printf (" if (slot < %d)\n", max_slots);
5563 printf (" abort ();\n\n");
5566 /* If just one type of delay slot, write simple switch. */
5567 if (num_delays == 1 && max_slots == 1)
5569 printf (" insn = candidate_insn;\n");
5570 printf (" switch (recog_memoized (insn))\n");
5573 attr = find_attr ("*delay_1_0", 0);
5576 common_av = find_most_used (attr);
5578 for (av = attr->first_value; av; av = av->next)
5579 if (av != common_av)
5580 write_attr_case (attr, av, 1, "return", ";", 4, true_rtx);
5582 write_attr_case (attr, common_av, 0, "return", ";", 4, true_rtx);
5588 /* Write a nested CASE. The first indicates which condition we need to
5589 test, and the inner CASE tests the condition. */
5590 printf (" insn = candidate_insn;\n");
5591 printf (" switch (slot)\n");
5594 for (delay = delays; delay; delay = delay->next)
5595 for (i = 0; i < XVECLEN (delay->def, 1); i += 3)
5597 printf (" case %d:\n",
5598 (i / 3) + (num_delays == 1 ? 0 : delay->num * max_slots));
5599 printf (" switch (recog_memoized (insn))\n");
5602 sprintf (str, "*%s_%d_%d", kind, delay->num, i / 3);
5603 attr = find_attr (str, 0);
5606 common_av = find_most_used (attr);
5608 for (av = attr->first_value; av; av = av->next)
5609 if (av != common_av)
5610 write_attr_case (attr, av, 1, "return", ";", 8, true_rtx);
5612 write_attr_case (attr, common_av, 0, "return", ";", 8, true_rtx);
5616 printf (" default:\n");
5617 printf (" abort ();\n");
5624 /* Write routines to compute conflict cost for function units. Then write a
5625 table describing the available function units. */
5628 write_function_unit_info ()
5630 struct function_unit *unit;
5633 /* Write out conflict routines for function units. Don't bother writing
5634 one if there is only one issue delay value. */
5636 for (unit = units; unit; unit = unit->next)
5638 if (unit->needs_blockage_function)
5639 write_complex_function (unit, "blockage", "block");
5641 /* If the minimum and maximum conflict costs are the same, there
5642 is only one value, so we don't need a function. */
5643 if (! unit->needs_conflict_function)
5645 unit->default_cost = make_numeric_value (unit->issue_delay.max);
5649 /* The function first computes the case from the candidate insn. */
5650 unit->default_cost = make_numeric_value (0);
5651 write_complex_function (unit, "conflict_cost", "cost");
5654 /* Now that all functions have been written, write the table describing
5655 the function units. The name is included for documentation purposes
5658 printf ("struct function_unit_desc function_units[] = {\n");
5660 /* Write out the descriptions in numeric order, but don't force that order
5661 on the list. Doing so increases the runtime of genattrtab.c. */
5662 for (i = 0; i < num_units; i++)
5664 for (unit = units; unit; unit = unit->next)
5668 printf (" {\"%s\", %d, %d, %d, %s, %d, %s_unit_ready_cost, ",
5669 unit->name, 1 << unit->num, unit->multiplicity,
5670 unit->simultaneity, XSTR (unit->default_cost, 0),
5671 unit->issue_delay.max, unit->name);
5673 if (unit->needs_conflict_function)
5674 printf ("%s_unit_conflict_cost, ", unit->name);
5678 printf ("%d, ", unit->max_blockage);
5680 if (unit->needs_range_function)
5681 printf ("%s_unit_blockage_range, ", unit->name);
5685 if (unit->needs_blockage_function)
5686 printf ("%s_unit_blockage", unit->name);
5697 write_complex_function (unit, name, connection)
5698 struct function_unit *unit;
5699 const char *name, *connection;
5701 struct attr_desc *case_attr, *attr;
5702 struct attr_value *av, *common_av;
5708 printf ("static int %s_unit_%s PARAMS ((rtx, rtx));\n", unit->name, name);
5709 printf ("static int\n");
5710 printf ("%s_unit_%s (executing_insn, candidate_insn)\n", unit->name, name);
5711 printf (" rtx executing_insn;\n");
5712 printf (" rtx candidate_insn;\n");
5714 printf (" rtx insn;\n");
5715 printf (" int casenum;\n\n");
5716 printf (" insn = executing_insn;\n");
5717 printf (" switch (recog_memoized (insn))\n");
5720 /* Write the `switch' statement to get the case value. */
5721 if (strlen (unit->name) + sizeof "*_cases" > 256)
5723 sprintf (str, "*%s_cases", unit->name);
5724 case_attr = find_attr (str, 0);
5727 common_av = find_most_used (case_attr);
5729 for (av = case_attr->first_value; av; av = av->next)
5730 if (av != common_av)
5731 write_attr_case (case_attr, av, 1,
5732 "casenum =", ";", 4, unit->condexp);
5734 write_attr_case (case_attr, common_av, 0,
5735 "casenum =", ";", 4, unit->condexp);
5738 /* Now write an outer switch statement on each case. Then write
5739 the tests on the executing function within each. */
5740 printf (" insn = candidate_insn;\n");
5741 printf (" switch (casenum)\n");
5744 for (i = 0; i < unit->num_opclasses; i++)
5746 /* Ensure using this case. */
5748 for (av = case_attr->first_value; av; av = av->next)
5750 && contained_in_p (make_numeric_value (i), av->value))
5756 printf (" case %d:\n", i);
5757 sprintf (str, "*%s_%s_%d", unit->name, connection, i);
5758 attr = find_attr (str, 0);
5762 /* If single value, just write it. */
5763 value = find_single_value (attr);
5765 write_attr_set (attr, 6, value, "return", ";\n", true_rtx, -2, -2);
5768 common_av = find_most_used (attr);
5769 printf (" switch (recog_memoized (insn))\n");
5772 for (av = attr->first_value; av; av = av->next)
5773 if (av != common_av)
5774 write_attr_case (attr, av, 1,
5775 "return", ";", 8, unit->condexp);
5777 write_attr_case (attr, common_av, 0,
5778 "return", ";", 8, unit->condexp);
5783 /* This default case should not be needed, but gcc's analysis is not
5784 good enough to realize that the default case is not needed for the
5785 second switch statement. */
5786 printf (" default:\n abort ();\n");
5787 printf (" }\n}\n\n");
5790 /* This page contains miscellaneous utility routines. */
5792 /* Given a string, return the number of comma-separated elements in it.
5793 Return 0 for the null string. */
5804 for (n = 1; *s; s++)
5811 /* Given a pointer to a (char *), return a malloc'ed string containing the
5812 next comma-separated element. Advance the pointer to after the string
5813 scanned, or the end-of-string. Return NULL if at end of string. */
5816 next_comma_elt (pstr)
5825 /* Find end of string to compute length. */
5826 for (p = *pstr; *p != ',' && *p != '\0'; p++)
5829 out_str = attr_string (*pstr, p - *pstr);
5838 /* Return a `struct attr_desc' pointer for a given named attribute. If CREATE
5839 is non-zero, build a new attribute, if one does not exist. */
5841 static struct attr_desc *
5842 find_attr (name, create)
5846 struct attr_desc *attr;
5849 /* Before we resort to using `strcmp', see if the string address matches
5850 anywhere. In most cases, it should have been canonicalized to do so. */
5851 if (name == alternative_name)
5854 index = name[0] & (MAX_ATTRS_INDEX - 1);
5855 for (attr = attrs[index]; attr; attr = attr->next)
5856 if (name == attr->name)
5859 /* Otherwise, do it the slow way. */
5860 for (attr = attrs[index]; attr; attr = attr->next)
5861 if (name[0] == attr->name[0] && ! strcmp (name, attr->name))
5867 attr = (struct attr_desc *) oballoc (sizeof (struct attr_desc));
5868 attr->name = attr_string (name, strlen (name));
5869 attr->first_value = attr->default_val = NULL;
5870 attr->is_numeric = attr->negative_ok = attr->is_const = attr->is_special = 0;
5871 attr->unsigned_p = attr->func_units_p = attr->blockage_p = 0;
5872 attr->next = attrs[index];
5873 attrs[index] = attr;
5878 /* Create internal attribute with the given default value. */
5881 make_internal_attr (name, value, special)
5886 struct attr_desc *attr;
5888 attr = find_attr (name, 1);
5889 if (attr->default_val)
5892 attr->is_numeric = 1;
5894 attr->is_special = (special & 1) != 0;
5895 attr->negative_ok = (special & 2) != 0;
5896 attr->unsigned_p = (special & 4) != 0;
5897 attr->func_units_p = (special & 8) != 0;
5898 attr->blockage_p = (special & 16) != 0;
5899 attr->default_val = get_attr_value (value, attr, -2);
5902 /* Find the most used value of an attribute. */
5904 static struct attr_value *
5905 find_most_used (attr)
5906 struct attr_desc *attr;
5908 struct attr_value *av;
5909 struct attr_value *most_used;
5915 for (av = attr->first_value; av; av = av->next)
5916 if (av->num_insns > nuses)
5917 nuses = av->num_insns, most_used = av;
5922 /* If an attribute only has a single value used, return it. Otherwise
5926 find_single_value (attr)
5927 struct attr_desc *attr;
5929 struct attr_value *av;
5932 unique_value = NULL;
5933 for (av = attr->first_value; av; av = av->next)
5939 unique_value = av->value;
5942 return unique_value;
5945 /* Return (attr_value "n") */
5948 make_numeric_value (n)
5951 static rtx int_values[20];
5958 if (n < 20 && int_values[n])
5959 return int_values[n];
5961 p = attr_printf (MAX_DIGITS, "%d", n);
5962 exp = attr_rtx (CONST_STRING, p);
5965 int_values[n] = exp;
5971 extend_range (range, min, max)
5972 struct range *range;
5976 if (range->min > min)
5978 if (range->max < max)
5983 copy_rtx_unchanging (orig)
5988 register RTX_CODE code;
5991 if (RTX_UNCHANGING_P (orig) || MEM_IN_STRUCT_P (orig))
5994 MEM_IN_STRUCT_P (orig) = 1;
5998 code = GET_CODE (orig);
6011 copy = rtx_alloc (code);
6012 PUT_MODE (copy, GET_MODE (orig));
6013 RTX_UNCHANGING_P (copy) = 1;
6015 memcpy (&XEXP (copy, 0), &XEXP (orig, 0),
6016 GET_RTX_LENGTH (GET_CODE (copy)) * sizeof (rtx));
6021 /* Determine if an insn has a constant number of delay slots, i.e., the
6022 number of delay slots is not a function of the length of the insn. */
6025 write_const_num_delay_slots ()
6027 struct attr_desc *attr = find_attr ("*num_delay_slots", 0);
6028 struct attr_value *av;
6029 struct insn_ent *ie;
6033 printf ("int\nconst_num_delay_slots (insn)\n");
6034 printf (" rtx insn;\n");
6036 printf (" switch (recog_memoized (insn))\n");
6039 for (av = attr->first_value; av; av = av->next)
6042 walk_attr_value (av->value);
6045 for (ie = av->first_insn; ie; ie = ie->next)
6046 if (ie->insn_code != -1)
6047 printf (" case %d:\n", ie->insn_code);
6048 printf (" return 0;\n");
6052 printf (" default:\n");
6053 printf (" return 1;\n");
6054 printf (" }\n}\n\n");
6058 extern int main PARAMS ((int, char **));
6066 struct attr_desc *attr;
6067 struct insn_def *id;
6071 progname = "genattrtab";
6074 fatal ("No input file name.");
6076 if (init_md_reader (argv[1]) != SUCCESS_EXIT_CODE)
6077 return (FATAL_EXIT_CODE);
6079 obstack_init (hash_obstack);
6080 obstack_init (temp_obstack);
6082 /* Set up true and false rtx's */
6083 true_rtx = rtx_alloc (CONST_INT);
6084 XWINT (true_rtx, 0) = 1;
6085 false_rtx = rtx_alloc (CONST_INT);
6086 XWINT (false_rtx, 0) = 0;
6087 RTX_UNCHANGING_P (true_rtx) = RTX_UNCHANGING_P (false_rtx) = 1;
6088 RTX_INTEGRATED_P (true_rtx) = RTX_INTEGRATED_P (false_rtx) = 1;
6090 alternative_name = attr_string ("alternative", strlen ("alternative"));
6092 printf ("/* Generated automatically by the program `genattrtab'\n\
6093 from the machine description file `md'. */\n\n");
6095 /* Read the machine description. */
6101 desc = read_md_rtx (&lineno, &insn_code_number);
6105 switch (GET_CODE (desc))
6108 case DEFINE_PEEPHOLE:
6109 case DEFINE_ASM_ATTRIBUTES:
6110 gen_insn (desc, lineno);
6114 gen_attr (desc, lineno);
6118 gen_delay (desc, lineno);
6121 case DEFINE_FUNCTION_UNIT:
6122 gen_unit (desc, lineno);
6128 if (GET_CODE (desc) != DEFINE_ASM_ATTRIBUTES)
6129 insn_index_number++;
6133 return FATAL_EXIT_CODE;
6137 /* If we didn't have a DEFINE_ASM_ATTRIBUTES, make a null one. */
6138 if (! got_define_asm_attributes)
6140 tem = rtx_alloc (DEFINE_ASM_ATTRIBUTES);
6141 XVEC (tem, 0) = rtvec_alloc (0);
6145 /* Expand DEFINE_DELAY information into new attribute. */
6149 /* Expand DEFINE_FUNCTION_UNIT information into new attributes. */
6153 printf ("#include \"config.h\"\n");
6154 printf ("#include \"system.h\"\n");
6155 printf ("#include \"rtl.h\"\n");
6156 printf ("#include \"tm_p.h\"\n");
6157 printf ("#include \"insn-config.h\"\n");
6158 printf ("#include \"recog.h\"\n");
6159 printf ("#include \"regs.h\"\n");
6160 printf ("#include \"real.h\"\n");
6161 printf ("#include \"output.h\"\n");
6162 printf ("#include \"insn-attr.h\"\n");
6163 printf ("#include \"toplev.h\"\n");
6164 printf ("#include \"flags.h\"\n");
6166 printf ("#define operands recog_data.operand\n\n");
6168 /* Make `insn_alternatives'. */
6169 insn_alternatives = (int *) oballoc (insn_code_number * sizeof (int));
6170 for (id = defs; id; id = id->next)
6171 if (id->insn_code >= 0)
6172 insn_alternatives[id->insn_code] = (1 << id->num_alternatives) - 1;
6174 /* Make `insn_n_alternatives'. */
6175 insn_n_alternatives = (int *) oballoc (insn_code_number * sizeof (int));
6176 for (id = defs; id; id = id->next)
6177 if (id->insn_code >= 0)
6178 insn_n_alternatives[id->insn_code] = id->num_alternatives;
6180 /* Prepare to write out attribute subroutines by checking everything stored
6181 away and building the attribute cases. */
6185 for (i = 0; i < MAX_ATTRS_INDEX; i++)
6186 for (attr = attrs[i]; attr; attr = attr->next)
6187 attr->default_val->value
6188 = check_attr_value (attr->default_val->value, attr);
6191 return FATAL_EXIT_CODE;
6193 for (i = 0; i < MAX_ATTRS_INDEX; i++)
6194 for (attr = attrs[i]; attr; attr = attr->next)
6197 /* Construct extra attributes for `length'. */
6198 make_length_attrs ();
6200 /* Perform any possible optimizations to speed up compilation. */
6203 /* Now write out all the `gen_attr_...' routines. Do these before the
6204 special routines (specifically before write_function_unit_info), so
6205 that they get defined before they are used. */
6207 for (i = 0; i < MAX_ATTRS_INDEX; i++)
6208 for (attr = attrs[i]; attr; attr = attr->next)
6210 if (! attr->is_special && ! attr->is_const)
6211 write_attr_get (attr);
6214 /* Write out delay eligibility information, if DEFINE_DELAY present.
6215 (The function to compute the number of delay slots will be written
6219 write_eligible_delay ("delay");
6220 if (have_annul_true)
6221 write_eligible_delay ("annul_true");
6222 if (have_annul_false)
6223 write_eligible_delay ("annul_false");
6226 /* Write out information about function units. */
6228 write_function_unit_info ();
6230 /* Write out constant delay slot info */
6231 write_const_num_delay_slots ();
6233 write_length_unit_log ();
6236 return (ferror (stdout) != 0 ? FATAL_EXIT_CODE : SUCCESS_EXIT_CODE);
6239 /* Define this so we can link with print-rtl.o to get debug_rtx function. */
6241 get_insn_name (code)
6242 int code ATTRIBUTE_UNUSED;