1 /* Generate code from machine description to compute values of attributes.
2 Copyright (C) 1991, 93, 94, 95, 96, 1997 Free Software Foundation, Inc.
3 Contributed by Richard Kenner (kenner@vlsi1.ultra.nyu.edu)
5 This file is part of GNU CC.
7 GNU CC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GNU CC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU CC; see the file COPYING. If not, write to
19 the Free Software Foundation, 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
22 /* This program handles insn attributes and the DEFINE_DELAY and
23 DEFINE_FUNCTION_UNIT definitions.
25 It produces a series of functions named `get_attr_...', one for each insn
26 attribute. Each of these is given the rtx for an insn and returns a member
27 of the enum for the attribute.
29 These subroutines have the form of a `switch' on the INSN_CODE (via
30 `recog_memoized'). Each case either returns a constant attribute value
31 or a value that depends on tests on other attributes, the form of
32 operands, or some random C expression (encoded with a SYMBOL_REF
35 If the attribute `alternative', or a random C expression is present,
36 `constrain_operands' is called. If either of these cases of a reference to
37 an operand is found, `insn_extract' is called.
39 The special attribute `length' is also recognized. For this operand,
40 expressions involving the address of an operand or the current insn,
41 (address (pc)), are valid. In this case, an initial pass is made to
42 set all lengths that do not depend on address. Those that do are set to
43 the maximum length. Then each insn that depends on an address is checked
44 and possibly has its length changed. The process repeats until no further
45 changed are made. The resulting lengths are saved for use by
48 A special form of DEFINE_ATTR, where the expression for default value is a
49 CONST expression, indicates an attribute that is constant for a given run
50 of the compiler. The subroutine generated for these attributes has no
51 parameters as it does not depend on any particular insn. Constant
52 attributes are typically used to specify which variety of processor is
55 Internal attributes are defined to handle DEFINE_DELAY and
56 DEFINE_FUNCTION_UNIT. Special routines are output for these cases.
58 This program works by keeping a list of possible values for each attribute.
59 These include the basic attribute choices, default values for attribute, and
60 all derived quantities.
62 As the description file is read, the definition for each insn is saved in a
63 `struct insn_def'. When the file reading is complete, a `struct insn_ent'
64 is created for each insn and chained to the corresponding attribute value,
65 either that specified, or the default.
67 An optimization phase is then run. This simplifies expressions for each
68 insn. EQ_ATTR tests are resolved, whenever possible, to a test that
69 indicates when the attribute has the specified value for the insn. This
70 avoids recursive calls during compilation.
72 The strategy used when processing DEFINE_DELAY and DEFINE_FUNCTION_UNIT
73 definitions is to create arbitrarily complex expressions and have the
74 optimization simplify them.
76 Once optimization is complete, any required routines and definitions
79 An optimization that is not yet implemented is to hoist the constant
80 expressions entirely out of the routines and definitions that are written.
81 A way to do this is to iterate over all possible combinations of values
82 for constant attributes and generate a set of functions for that given
83 combination. An initialization function would be written that evaluates
84 the attributes and installs the corresponding set of routines and
85 definitions (each would be accessed through a pointer).
87 We use the flags in an RTX as follows:
88 `unchanging' (RTX_UNCHANGING_P): This rtx is fully simplified
89 independent of the insn code.
90 `in_struct' (MEM_IN_STRUCT_P): This rtx is fully simplified
91 for the insn code currently being processed (see optimize_attrs).
92 `integrated' (RTX_INTEGRATED_P): This rtx is permanent and unique
94 `volatil' (MEM_VOLATILE_P): During simplify_by_exploding the value of an
95 EQ_ATTR rtx is true if !volatil and false if volatil. */
99 /* varargs must always be included after *config.h. */
107 #include "insn-config.h" /* For REGISTER_CONSTRAINTS */
109 #ifdef TIME_WITH_SYS_TIME
110 # include <sys/time.h>
114 # include <sys/time.h>
120 #ifdef HAVE_SYS_RESOURCE_H
121 # include <sys/resource.h>
124 /* We must include obstack.h after <sys/time.h>, to avoid lossage with
125 /usr/include/sys/stdtypes.h on Sun OS 4.x. */
128 static struct obstack obstack
, obstack1
, obstack2
;
129 struct obstack
*rtl_obstack
= &obstack
;
130 struct obstack
*hash_obstack
= &obstack1
;
131 struct obstack
*temp_obstack
= &obstack2
;
133 #define obstack_chunk_alloc xmalloc
134 #define obstack_chunk_free free
136 /* Define this so we can link with print-rtl.o to get debug_rtx function. */
137 char **insn_name_ptr
= 0;
140 extern rtx
read_rtx ();
142 static void fatal ();
145 /* enough space to reserve for printing out ints */
146 #define MAX_DIGITS (HOST_BITS_PER_INT * 3 / 10 + 3)
148 /* Define structures used to record attributes and values. */
150 /* As each DEFINE_INSN, DEFINE_PEEPHOLE, or DEFINE_ASM_ATTRIBUTES is
151 encountered, we store all the relevant information into a
152 `struct insn_def'. This is done to allow attribute definitions to occur
153 anywhere in the file. */
157 int insn_code
; /* Instruction number. */
158 int insn_index
; /* Expression numer in file, for errors. */
159 struct insn_def
*next
; /* Next insn in chain. */
160 rtx def
; /* The DEFINE_... */
161 int num_alternatives
; /* Number of alternatives. */
162 int vec_idx
; /* Index of attribute vector in `def'. */
165 /* Once everything has been read in, we store in each attribute value a list
166 of insn codes that have that value. Here is the structure used for the
171 int insn_code
; /* Instruction number. */
172 int insn_index
; /* Index of definition in file */
173 struct insn_ent
*next
; /* Next in chain. */
176 /* Each value of an attribute (either constant or computed) is assigned a
177 structure which is used as the listhead of the insns that have that
182 rtx value
; /* Value of attribute. */
183 struct attr_value
*next
; /* Next attribute value in chain. */
184 struct insn_ent
*first_insn
; /* First insn with this value. */
185 int num_insns
; /* Number of insns with this value. */
186 int has_asm_insn
; /* True if this value used for `asm' insns */
189 /* Structure for each attribute. */
193 char *name
; /* Name of attribute. */
194 struct attr_desc
*next
; /* Next attribute. */
195 int is_numeric
; /* Values of this attribute are numeric. */
196 int negative_ok
; /* Allow negative numeric values. */
197 int unsigned_p
; /* Make the output function unsigned int. */
198 int is_const
; /* Attribute value constant for each run. */
199 int is_special
; /* Don't call `write_attr_set'. */
200 struct attr_value
*first_value
; /* First value of this attribute. */
201 struct attr_value
*default_val
; /* Default value for this attribute. */
204 #define NULL_ATTR (struct attr_desc *) NULL
206 /* A range of values. */
214 /* Structure for each DEFINE_DELAY. */
218 rtx def
; /* DEFINE_DELAY expression. */
219 struct delay_desc
*next
; /* Next DEFINE_DELAY. */
220 int num
; /* Number of DEFINE_DELAY, starting at 1. */
223 /* Record information about each DEFINE_FUNCTION_UNIT. */
225 struct function_unit_op
227 rtx condexp
; /* Expression TRUE for applicable insn. */
228 struct function_unit_op
*next
; /* Next operation for this function unit. */
229 int num
; /* Ordinal for this operation type in unit. */
230 int ready
; /* Cost until data is ready. */
231 int issue_delay
; /* Cost until unit can accept another insn. */
232 rtx conflict_exp
; /* Expression TRUE for insns incurring issue delay. */
233 rtx issue_exp
; /* Expression computing issue delay. */
236 /* Record information about each function unit mentioned in a
237 DEFINE_FUNCTION_UNIT. */
241 char *name
; /* Function unit name. */
242 struct function_unit
*next
; /* Next function unit. */
243 int num
; /* Ordinal of this unit type. */
244 int multiplicity
; /* Number of units of this type. */
245 int simultaneity
; /* Maximum number of simultaneous insns
246 on this function unit or 0 if unlimited. */
247 rtx condexp
; /* Expression TRUE for insn needing unit. */
248 int num_opclasses
; /* Number of different operation types. */
249 struct function_unit_op
*ops
; /* Pointer to first operation type. */
250 int needs_conflict_function
; /* Nonzero if a conflict function required. */
251 int needs_blockage_function
; /* Nonzero if a blockage function required. */
252 int needs_range_function
; /* Nonzero if blockage range function needed.*/
253 rtx default_cost
; /* Conflict cost, if constant. */
254 struct range issue_delay
; /* Range of issue delay values. */
255 int max_blockage
; /* Maximum time an insn blocks the unit. */
258 /* Listheads of above structures. */
260 /* This one is indexed by the first character of the attribute name. */
261 #define MAX_ATTRS_INDEX 256
262 static struct attr_desc
*attrs
[MAX_ATTRS_INDEX
];
263 static struct insn_def
*defs
;
264 static struct delay_desc
*delays
;
265 static struct function_unit
*units
;
267 /* An expression where all the unknown terms are EQ_ATTR tests can be
268 rearranged into a COND provided we can enumerate all possible
269 combinations of the unknown values. The set of combinations become the
270 tests of the COND; the value of the expression given that combination is
271 computed and becomes the corresponding value. To do this, we must be
272 able to enumerate all values for each attribute used in the expression
273 (currently, we give up if we find a numeric attribute).
275 If the set of EQ_ATTR tests used in an expression tests the value of N
276 different attributes, the list of all possible combinations can be made
277 by walking the N-dimensional attribute space defined by those
278 attributes. We record each of these as a struct dimension.
280 The algorithm relies on sharing EQ_ATTR nodes: if two nodes in an
281 expression are the same, the will also have the same address. We find
282 all the EQ_ATTR nodes by marking them MEM_VOLATILE_P. This bit later
283 represents the value of an EQ_ATTR node, so once all nodes are marked,
284 they are also given an initial value of FALSE.
286 We then separate the set of EQ_ATTR nodes into dimensions for each
287 attribute and put them on the VALUES list. Terms are added as needed by
288 `add_values_to_cover' so that all possible values of the attribute are
291 Each dimension also has a current value. This is the node that is
292 currently considered to be TRUE. If this is one of the nodes added by
293 `add_values_to_cover', all the EQ_ATTR tests in the original expression
294 will be FALSE. Otherwise, only the CURRENT_VALUE will be true.
296 NUM_VALUES is simply the length of the VALUES list and is there for
299 Once the dimensions are created, the algorithm enumerates all possible
300 values and computes the current value of the given expression. */
304 struct attr_desc
*attr
; /* Attribute for this dimension. */
305 rtx values
; /* List of attribute values used. */
306 rtx current_value
; /* Position in the list for the TRUE value. */
307 int num_values
; /* Length of the values list. */
310 /* Other variables. */
312 static int insn_code_number
;
313 static int insn_index_number
;
314 static int got_define_asm_attributes
;
315 static int must_extract
;
316 static int must_constrain
;
317 static int address_used
;
318 static int length_used
;
319 static int num_delays
;
320 static int have_annul_true
, have_annul_false
;
321 static int num_units
;
322 static int num_insn_ents
;
324 /* Used as operand to `operate_exp': */
326 enum operator {PLUS_OP
, MINUS_OP
, POS_MINUS_OP
, EQ_OP
, OR_OP
, MAX_OP
, MIN_OP
, RANGE_OP
};
328 /* Stores, for each insn code, the number of constraint alternatives. */
330 static int *insn_n_alternatives
;
332 /* Stores, for each insn code, a bitmap that has bits on for each possible
335 static int *insn_alternatives
;
337 /* If nonzero, assume that the `alternative' attr has this value.
338 This is the hashed, unique string for the numeral
339 whose value is chosen alternative. */
341 static char *current_alternative_string
;
343 /* Used to simplify expressions. */
345 static rtx true_rtx
, false_rtx
;
347 /* Used to reduce calls to `strcmp' */
349 static char *alternative_name
;
351 /* Simplify an expression. Only call the routine if there is something to
353 #define SIMPLIFY_TEST_EXP(EXP,INSN_CODE,INSN_INDEX) \
354 (RTX_UNCHANGING_P (EXP) || MEM_IN_STRUCT_P (EXP) ? (EXP) \
355 : simplify_test_exp (EXP, INSN_CODE, INSN_INDEX))
357 /* Simplify (eq_attr ("alternative") ...)
358 when we are working with a particular alternative. */
359 #define SIMPLIFY_ALTERNATIVE(EXP) \
360 if (current_alternative_string \
361 && GET_CODE ((EXP)) == EQ_ATTR \
362 && XSTR ((EXP), 0) == alternative_name) \
363 (EXP) = (XSTR ((EXP), 1) == current_alternative_string \
364 ? true_rtx : false_rtx);
366 /* These are referenced by rtlanal.c and hence need to be defined somewhere.
367 They won't actually be used. */
369 rtx frame_pointer_rtx
, hard_frame_pointer_rtx
, stack_pointer_rtx
;
372 static rtx attr_rtx
PVPROTO((enum rtx_code
, ...));
374 static char *attr_printf
PVPROTO((int, char *, ...));
376 static char *attr_printf ();
379 static char *attr_string
PROTO((char *, int));
380 static rtx check_attr_test
PROTO((rtx
, int));
381 static rtx check_attr_value
PROTO((rtx
, struct attr_desc
*));
382 static rtx convert_set_attr_alternative
PROTO((rtx
, int, int, int));
383 static rtx convert_set_attr
PROTO((rtx
, int, int, int));
384 static void check_defs
PROTO((void));
385 static rtx convert_const_symbol_ref
PROTO((rtx
, struct attr_desc
*));
386 static rtx make_canonical
PROTO((struct attr_desc
*, rtx
));
387 static struct attr_value
*get_attr_value
PROTO((rtx
, struct attr_desc
*, int));
388 static rtx copy_rtx_unchanging
PROTO((rtx
));
389 static rtx copy_boolean
PROTO((rtx
));
390 static void expand_delays
PROTO((void));
391 static rtx operate_exp
PROTO((enum operator, rtx
, rtx
));
392 static void expand_units
PROTO((void));
393 static rtx simplify_knowing
PROTO((rtx
, rtx
));
394 static rtx encode_units_mask
PROTO((rtx
));
395 static void fill_attr
PROTO((struct attr_desc
*));
396 /* dpx2 compiler chokes if we specify the arg types of the args. */
397 static rtx substitute_address
PROTO((rtx
, rtx (*) (), rtx (*) ()));
398 static void make_length_attrs
PROTO((void));
399 static rtx identity_fn
PROTO((rtx
));
400 static rtx zero_fn
PROTO((rtx
));
401 static rtx one_fn
PROTO((rtx
));
402 static rtx max_fn
PROTO((rtx
));
403 static rtx simplify_cond
PROTO((rtx
, int, int));
405 static rtx simplify_by_alternatives
PROTO((rtx
, int, int));
407 static rtx simplify_by_exploding
PROTO((rtx
));
408 static int find_and_mark_used_attributes
PROTO((rtx
, rtx
*, int *));
409 static void unmark_used_attributes
PROTO((rtx
, struct dimension
*, int));
410 static int add_values_to_cover
PROTO((struct dimension
*));
411 static int increment_current_value
PROTO((struct dimension
*, int));
412 static rtx test_for_current_value
PROTO((struct dimension
*, int));
413 static rtx simplify_with_current_value
PROTO((rtx
, struct dimension
*, int));
414 static rtx simplify_with_current_value_aux
PROTO((rtx
));
415 static void clear_struct_flag
PROTO((rtx
));
416 static int count_sub_rtxs
PROTO((rtx
, int));
417 static void remove_insn_ent
PROTO((struct attr_value
*, struct insn_ent
*));
418 static void insert_insn_ent
PROTO((struct attr_value
*, struct insn_ent
*));
419 static rtx insert_right_side
PROTO((enum rtx_code
, rtx
, rtx
, int, int));
420 static rtx make_alternative_compare
PROTO((int));
421 static int compute_alternative_mask
PROTO((rtx
, enum rtx_code
));
422 static rtx evaluate_eq_attr
PROTO((rtx
, rtx
, int, int));
423 static rtx simplify_and_tree
PROTO((rtx
, rtx
*, int, int));
424 static rtx simplify_or_tree
PROTO((rtx
, rtx
*, int, int));
425 static rtx simplify_test_exp
PROTO((rtx
, int, int));
426 static void optimize_attrs
PROTO((void));
427 static void gen_attr
PROTO((rtx
));
428 static int count_alternatives
PROTO((rtx
));
429 static int compares_alternatives_p
PROTO((rtx
));
430 static int contained_in_p
PROTO((rtx
, rtx
));
431 static void gen_insn
PROTO((rtx
));
432 static void gen_delay
PROTO((rtx
));
433 static void gen_unit
PROTO((rtx
));
434 static void write_test_expr
PROTO((rtx
, int));
435 static int max_attr_value
PROTO((rtx
));
436 static void walk_attr_value
PROTO((rtx
));
437 static void write_attr_get
PROTO((struct attr_desc
*));
438 static rtx eliminate_known_true
PROTO((rtx
, rtx
, int, int));
439 static void write_attr_set
PROTO((struct attr_desc
*, int, rtx
, char *,
440 char *, rtx
, int, int));
441 static void write_attr_case
PROTO((struct attr_desc
*, struct attr_value
*,
442 int, char *, char *, int, rtx
));
443 static void write_attr_valueq
PROTO((struct attr_desc
*, char *));
444 static void write_attr_value
PROTO((struct attr_desc
*, rtx
));
445 static void write_upcase
PROTO((char *));
446 static void write_indent
PROTO((int));
447 static void write_eligible_delay
PROTO((char *));
448 static void write_function_unit_info
PROTO((void));
449 static void write_complex_function
PROTO((struct function_unit
*, char *,
451 static int n_comma_elts
PROTO((char *));
452 static char *next_comma_elt
PROTO((char **));
453 static struct attr_desc
*find_attr
PROTO((char *, int));
454 static void make_internal_attr
PROTO((char *, rtx
, int));
455 static struct attr_value
*find_most_used
PROTO((struct attr_desc
*));
456 static rtx find_single_value
PROTO((struct attr_desc
*));
457 static rtx make_numeric_value
PROTO((int));
458 static void extend_range
PROTO((struct range
*, int, int));
459 char *xrealloc
PROTO((char *, unsigned));
460 char *xmalloc
PROTO((unsigned));
462 #define oballoc(size) obstack_alloc (hash_obstack, size)
465 /* Hash table for sharing RTL and strings. */
467 /* Each hash table slot is a bucket containing a chain of these structures.
468 Strings are given negative hash codes; RTL expressions are given positive
473 struct attr_hash
*next
; /* Next structure in the bucket. */
474 int hashcode
; /* Hash code of this rtx or string. */
477 char *str
; /* The string (negative hash codes) */
478 rtx rtl
; /* or the RTL recorded here. */
482 /* Now here is the hash table. When recording an RTL, it is added to
483 the slot whose index is the hash code mod the table size. Note
484 that the hash table is used for several kinds of RTL (see attr_rtx)
485 and for strings. While all these live in the same table, they are
486 completely independent, and the hash code is computed differently
489 #define RTL_HASH_SIZE 4093
490 struct attr_hash
*attr_hash_table
[RTL_HASH_SIZE
];
492 /* Here is how primitive or already-shared RTL's hash
494 #define RTL_HASH(RTL) ((HOST_WIDE_INT) (RTL) & 0777777)
498 /* Add an entry to the hash table for RTL with hash code HASHCODE. */
501 attr_hash_add_rtx (hashcode
, rtl
)
505 register struct attr_hash
*h
;
507 h
= (struct attr_hash
*) obstack_alloc (hash_obstack
,
508 sizeof (struct attr_hash
));
509 h
->hashcode
= hashcode
;
511 h
->next
= attr_hash_table
[hashcode
% RTL_HASH_SIZE
];
512 attr_hash_table
[hashcode
% RTL_HASH_SIZE
] = h
;
515 /* Add an entry to the hash table for STRING with hash code HASHCODE. */
518 attr_hash_add_string (hashcode
, str
)
522 register struct attr_hash
*h
;
524 h
= (struct attr_hash
*) obstack_alloc (hash_obstack
,
525 sizeof (struct attr_hash
));
526 h
->hashcode
= -hashcode
;
528 h
->next
= attr_hash_table
[hashcode
% RTL_HASH_SIZE
];
529 attr_hash_table
[hashcode
% RTL_HASH_SIZE
] = h
;
532 /* Generate an RTL expression, but avoid duplicates.
533 Set the RTX_INTEGRATED_P flag for these permanent objects.
535 In some cases we cannot uniquify; then we return an ordinary
536 impermanent rtx with RTX_INTEGRATED_P clear.
538 Args are like gen_rtx, but without the mode:
540 rtx attr_rtx (code, [element1, ..., elementn]) */
544 attr_rtx
VPROTO((enum rtx_code code
, ...))
550 register int i
; /* Array indices... */
551 register char *fmt
; /* Current rtx's format... */
552 register rtx rt_val
; /* RTX to return to caller... */
554 register struct attr_hash
*h
;
555 struct obstack
*old_obstack
= rtl_obstack
;
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
);
684 rt_val
= rtx_alloc (code
); /* Allocate the storage space. */
686 fmt
= GET_RTX_FORMAT (code
); /* Find the right format... */
687 for (i
= 0; i
< GET_RTX_LENGTH (code
); i
++)
691 case '0': /* Unused field. */
694 case 'i': /* An integer? */
695 XINT (rt_val
, i
) = va_arg (p
, int);
698 case 'w': /* A wide integer? */
699 XWINT (rt_val
, i
) = va_arg (p
, HOST_WIDE_INT
);
702 case 's': /* A string? */
703 XSTR (rt_val
, i
) = va_arg (p
, char *);
706 case 'e': /* An expression? */
707 case 'u': /* An insn? Same except when printing. */
708 XEXP (rt_val
, i
) = va_arg (p
, rtx
);
711 case 'E': /* An RTX vector? */
712 XVEC (rt_val
, i
) = va_arg (p
, rtvec
);
723 rtl_obstack
= old_obstack
;
725 attr_hash_add_rtx (hashcode
, rt_val
);
726 RTX_INTEGRATED_P (rt_val
) = 1;
734 /* Create a new string printed with the printf line arguments into a space
735 of at most LEN bytes:
737 rtx attr_printf (len, format, [arg1, ..., argn]) */
743 attr_printf
VPROTO((register int len
, char *fmt
, ...))
755 len
= va_arg (p
, int);
756 fmt
= va_arg (p
, char *);
759 /* Print the string into a temporary location. */
760 str
= (char *) alloca (len
);
761 vsprintf (str
, fmt
, p
);
764 return attr_string (str
, strlen (str
));
767 #else /* not HAVE_VPRINTF */
770 attr_printf (len
, fmt
, arg1
, arg2
, arg3
)
773 char *arg1
, *arg2
, *arg3
; /* also int */
777 /* Print the string into a temporary location. */
778 str
= (char *) alloca (len
);
779 sprintf (str
, fmt
, arg1
, arg2
, arg3
);
781 return attr_string (str
, strlen (str
));
783 #endif /* not HAVE_VPRINTF */
786 attr_eq (name
, value
)
789 return attr_rtx (EQ_ATTR
, attr_string (name
, strlen (name
)),
790 attr_string (value
, strlen (value
)));
797 return XSTR (make_numeric_value (n
), 0);
800 /* Return a permanent (possibly shared) copy of a string STR (not assumed
801 to be null terminated) with LEN bytes. */
804 attr_string (str
, len
)
808 register struct attr_hash
*h
;
811 register char *new_str
;
813 /* Compute the hash code. */
814 hashcode
= (len
+ 1) * 613 + (unsigned)str
[0];
815 for (i
= 1; i
<= len
; i
+= 2)
816 hashcode
= ((hashcode
* 613) + (unsigned)str
[i
]);
818 hashcode
= -hashcode
;
820 /* Search the table for the string. */
821 for (h
= attr_hash_table
[hashcode
% RTL_HASH_SIZE
]; h
; h
= h
->next
)
822 if (h
->hashcode
== -hashcode
&& h
->u
.str
[0] == str
[0]
823 && !strncmp (h
->u
.str
, str
, len
))
824 return h
->u
.str
; /* <-- return if found. */
826 /* Not found; create a permanent copy and add it to the hash table. */
827 new_str
= (char *) obstack_alloc (hash_obstack
, len
+ 1);
828 bcopy (str
, new_str
, len
);
830 attr_hash_add_string (hashcode
, new_str
);
832 return new_str
; /* Return the new string. */
835 /* Check two rtx's for equality of contents,
836 taking advantage of the fact that if both are hashed
837 then they can't be equal unless they are the same object. */
843 return (x
== y
|| (! (RTX_INTEGRATED_P (x
) && RTX_INTEGRATED_P (y
))
844 && rtx_equal_p (x
, y
)));
847 /* Copy an attribute value expression,
848 descending to all depths, but not copying any
849 permanent hashed subexpressions. */
857 register RTX_CODE code
;
858 register char *format_ptr
;
860 /* No need to copy a permanent object. */
861 if (RTX_INTEGRATED_P (orig
))
864 code
= GET_CODE (orig
);
882 copy
= rtx_alloc (code
);
883 PUT_MODE (copy
, GET_MODE (orig
));
884 copy
->in_struct
= orig
->in_struct
;
885 copy
->volatil
= orig
->volatil
;
886 copy
->unchanging
= orig
->unchanging
;
887 copy
->integrated
= orig
->integrated
;
889 format_ptr
= GET_RTX_FORMAT (GET_CODE (copy
));
891 for (i
= 0; i
< GET_RTX_LENGTH (GET_CODE (copy
)); i
++)
893 switch (*format_ptr
++)
896 XEXP (copy
, i
) = XEXP (orig
, i
);
897 if (XEXP (orig
, i
) != NULL
)
898 XEXP (copy
, i
) = attr_copy_rtx (XEXP (orig
, i
));
903 XVEC (copy
, i
) = XVEC (orig
, i
);
904 if (XVEC (orig
, i
) != NULL
)
906 XVEC (copy
, i
) = rtvec_alloc (XVECLEN (orig
, i
));
907 for (j
= 0; j
< XVECLEN (copy
, i
); j
++)
908 XVECEXP (copy
, i
, j
) = attr_copy_rtx (XVECEXP (orig
, i
, j
));
914 XINT (copy
, i
) = XINT (orig
, i
);
918 XWINT (copy
, i
) = XWINT (orig
, i
);
923 XSTR (copy
, i
) = XSTR (orig
, i
);
933 /* Given a test expression for an attribute, ensure it is validly formed.
934 IS_CONST indicates whether the expression is constant for each compiler
935 run (a constant expression may not test any particular insn).
937 Convert (eq_attr "att" "a1,a2") to (ior (eq_attr ... ) (eq_attrq ..))
938 and (eq_attr "att" "!a1") to (not (eq_attr "att" "a1")). Do the latter
939 test first so that (eq_attr "att" "!a1,a2,a3") works as expected.
941 Update the string address in EQ_ATTR expression to be the same used
942 in the attribute (or `alternative_name') to speed up subsequent
943 `find_attr' calls and eliminate most `strcmp' calls.
945 Return the new expression, if any. */
948 check_attr_test (exp
, is_const
)
952 struct attr_desc
*attr
;
953 struct attr_value
*av
;
957 switch (GET_CODE (exp
))
960 /* Handle negation test. */
961 if (XSTR (exp
, 1)[0] == '!')
962 return check_attr_test (attr_rtx (NOT
,
963 attr_eq (XSTR (exp
, 0),
967 else if (n_comma_elts (XSTR (exp
, 1)) == 1)
969 attr
= find_attr (XSTR (exp
, 0), 0);
972 if (! strcmp (XSTR (exp
, 0), "alternative"))
974 XSTR (exp
, 0) = alternative_name
;
975 /* This can't be simplified any further. */
976 RTX_UNCHANGING_P (exp
) = 1;
980 fatal ("Unknown attribute `%s' in EQ_ATTR", XEXP (exp
, 0));
983 if (is_const
&& ! attr
->is_const
)
984 fatal ("Constant expression uses insn attribute `%s' in EQ_ATTR",
987 /* Copy this just to make it permanent,
988 so expressions using it can be permanent too. */
989 exp
= attr_eq (XSTR (exp
, 0), XSTR (exp
, 1));
991 /* It shouldn't be possible to simplify the value given to a
992 constant attribute, so don't expand this until it's time to
993 write the test expression. */
995 RTX_UNCHANGING_P (exp
) = 1;
997 if (attr
->is_numeric
)
999 for (p
= XSTR (exp
, 1); *p
; p
++)
1000 if (*p
< '0' || *p
> '9')
1001 fatal ("Attribute `%s' takes only numeric values",
1006 for (av
= attr
->first_value
; av
; av
= av
->next
)
1007 if (GET_CODE (av
->value
) == CONST_STRING
1008 && ! strcmp (XSTR (exp
, 1), XSTR (av
->value
, 0)))
1012 fatal ("Unknown value `%s' for `%s' attribute",
1013 XEXP (exp
, 1), XEXP (exp
, 0));
1018 /* Make an IOR tree of the possible values. */
1020 name_ptr
= XSTR (exp
, 1);
1021 while ((p
= next_comma_elt (&name_ptr
)) != NULL
)
1023 newexp
= attr_eq (XSTR (exp
, 0), p
);
1024 orexp
= insert_right_side (IOR
, orexp
, newexp
, -2, -2);
1027 return check_attr_test (orexp
, is_const
);
1035 /* Either TRUE or FALSE. */
1043 XEXP (exp
, 0) = check_attr_test (XEXP (exp
, 0), is_const
);
1044 XEXP (exp
, 1) = check_attr_test (XEXP (exp
, 1), is_const
);
1048 XEXP (exp
, 0) = check_attr_test (XEXP (exp
, 0), is_const
);
1053 fatal ("RTL operator \"%s\" not valid in constant attribute test",
1054 GET_RTX_NAME (MATCH_OPERAND
));
1055 /* These cases can't be simplified. */
1056 RTX_UNCHANGING_P (exp
) = 1;
1059 case LE
: case LT
: case GT
: case GE
:
1060 case LEU
: case LTU
: case GTU
: case GEU
:
1062 if (GET_CODE (XEXP (exp
, 0)) == SYMBOL_REF
1063 && GET_CODE (XEXP (exp
, 1)) == SYMBOL_REF
)
1064 exp
= attr_rtx (GET_CODE (exp
),
1065 attr_rtx (SYMBOL_REF
, XSTR (XEXP (exp
, 0), 0)),
1066 attr_rtx (SYMBOL_REF
, XSTR (XEXP (exp
, 1), 0)));
1067 /* These cases can't be simplified. */
1068 RTX_UNCHANGING_P (exp
) = 1;
1074 /* These cases are valid for constant attributes, but can't be
1076 exp
= attr_rtx (SYMBOL_REF
, XSTR (exp
, 0));
1077 RTX_UNCHANGING_P (exp
) = 1;
1081 fatal ("RTL operator \"%s\" not valid in attribute test",
1082 GET_RTX_NAME (GET_CODE (exp
)));
1088 /* Given an expression, ensure that it is validly formed and that all named
1089 attribute values are valid for the given attribute. Issue a fatal error
1090 if not. If no attribute is specified, assume a numeric attribute.
1092 Return a perhaps modified replacement expression for the value. */
1095 check_attr_value (exp
, attr
)
1097 struct attr_desc
*attr
;
1099 struct attr_value
*av
;
1103 switch (GET_CODE (exp
))
1106 if (attr
&& ! attr
->is_numeric
)
1107 fatal ("CONST_INT not valid for non-numeric `%s' attribute",
1110 if (INTVAL (exp
) < 0)
1111 fatal ("Negative numeric value specified for `%s' attribute",
1117 if (! strcmp (XSTR (exp
, 0), "*"))
1120 if (attr
== 0 || attr
->is_numeric
)
1123 if (attr
&& attr
->negative_ok
&& *p
== '-')
1126 if (*p
> '9' || *p
< '0')
1127 fatal ("Non-numeric value for numeric `%s' attribute",
1128 attr
? attr
->name
: "internal");
1132 for (av
= attr
->first_value
; av
; av
= av
->next
)
1133 if (GET_CODE (av
->value
) == CONST_STRING
1134 && ! strcmp (XSTR (av
->value
, 0), XSTR (exp
, 0)))
1138 fatal ("Unknown value `%s' for `%s' attribute",
1139 XSTR (exp
, 0), attr
? attr
->name
: "internal");
1144 XEXP (exp
, 0) = check_attr_test (XEXP (exp
, 0),
1145 attr
? attr
->is_const
: 0);
1146 XEXP (exp
, 1) = check_attr_value (XEXP (exp
, 1), attr
);
1147 XEXP (exp
, 2) = check_attr_value (XEXP (exp
, 2), attr
);
1151 if (XVECLEN (exp
, 0) % 2 != 0)
1152 fatal ("First operand of COND must have even length");
1154 for (i
= 0; i
< XVECLEN (exp
, 0); i
+= 2)
1156 XVECEXP (exp
, 0, i
) = check_attr_test (XVECEXP (exp
, 0, i
),
1157 attr
? attr
->is_const
: 0);
1158 XVECEXP (exp
, 0, i
+ 1)
1159 = check_attr_value (XVECEXP (exp
, 0, i
+ 1), attr
);
1162 XEXP (exp
, 1) = check_attr_value (XEXP (exp
, 1), attr
);
1166 if (attr
&& attr
->is_const
)
1167 /* A constant SYMBOL_REF is valid as a constant attribute test and
1168 is expanded later by make_canonical into a COND. */
1169 return attr_rtx (SYMBOL_REF
, XSTR (exp
, 0));
1170 /* Otherwise, fall through... */
1173 fatal ("Invalid operation `%s' for attribute value",
1174 GET_RTX_NAME (GET_CODE (exp
)));
1180 /* Given an SET_ATTR_ALTERNATIVE expression, convert to the canonical SET.
1181 It becomes a COND with each test being (eq_attr "alternative "n") */
1184 convert_set_attr_alternative (exp
, num_alt
, insn_code
, insn_index
)
1187 int insn_code
, insn_index
;
1192 if (XVECLEN (exp
, 1) != num_alt
)
1193 fatal ("Bad number of entries in SET_ATTR_ALTERNATIVE for insn %d",
1196 /* Make a COND with all tests but the last. Select the last value via the
1198 condexp
= rtx_alloc (COND
);
1199 XVEC (condexp
, 0) = rtvec_alloc ((num_alt
- 1) * 2);
1201 for (i
= 0; i
< num_alt
- 1; i
++)
1204 p
= attr_numeral (i
);
1206 XVECEXP (condexp
, 0, 2 * i
) = attr_eq (alternative_name
, p
);
1208 /* Sharing this EQ_ATTR rtl causes trouble. */
1209 XVECEXP (condexp
, 0, 2 * i
) = rtx_alloc (EQ_ATTR
);
1210 XSTR (XVECEXP (condexp
, 0, 2 * i
), 0) = alternative_name
;
1211 XSTR (XVECEXP (condexp
, 0, 2 * i
), 1) = p
;
1213 XVECEXP (condexp
, 0, 2 * i
+ 1) = XVECEXP (exp
, 1, i
);
1216 XEXP (condexp
, 1) = XVECEXP (exp
, 1, i
);
1218 return attr_rtx (SET
, attr_rtx (ATTR
, XSTR (exp
, 0)), condexp
);
1221 /* Given a SET_ATTR, convert to the appropriate SET. If a comma-separated
1222 list of values is given, convert to SET_ATTR_ALTERNATIVE first. */
1225 convert_set_attr (exp
, num_alt
, insn_code
, insn_index
)
1228 int insn_code
, insn_index
;
1235 /* See how many alternative specified. */
1236 n
= n_comma_elts (XSTR (exp
, 1));
1238 return attr_rtx (SET
,
1239 attr_rtx (ATTR
, XSTR (exp
, 0)),
1240 attr_rtx (CONST_STRING
, XSTR (exp
, 1)));
1242 newexp
= rtx_alloc (SET_ATTR_ALTERNATIVE
);
1243 XSTR (newexp
, 0) = XSTR (exp
, 0);
1244 XVEC (newexp
, 1) = rtvec_alloc (n
);
1246 /* Process each comma-separated name. */
1247 name_ptr
= XSTR (exp
, 1);
1249 while ((p
= next_comma_elt (&name_ptr
)) != NULL
)
1250 XVECEXP (newexp
, 1, n
++) = attr_rtx (CONST_STRING
, p
);
1252 return convert_set_attr_alternative (newexp
, num_alt
, insn_code
, insn_index
);
1255 /* Scan all definitions, checking for validity. Also, convert any SET_ATTR
1256 and SET_ATTR_ALTERNATIVE expressions to the corresponding SET
1262 struct insn_def
*id
;
1263 struct attr_desc
*attr
;
1267 for (id
= defs
; id
; id
= id
->next
)
1269 if (XVEC (id
->def
, id
->vec_idx
) == NULL
)
1272 for (i
= 0; i
< XVECLEN (id
->def
, id
->vec_idx
); i
++)
1274 value
= XVECEXP (id
->def
, id
->vec_idx
, i
);
1275 switch (GET_CODE (value
))
1278 if (GET_CODE (XEXP (value
, 0)) != ATTR
)
1279 fatal ("Bad attribute set in pattern %d", id
->insn_index
);
1282 case SET_ATTR_ALTERNATIVE
:
1283 value
= convert_set_attr_alternative (value
,
1284 id
->num_alternatives
,
1290 value
= convert_set_attr (value
, id
->num_alternatives
,
1291 id
->insn_code
, id
->insn_index
);
1295 fatal ("Invalid attribute code `%s' for pattern %d",
1296 GET_RTX_NAME (GET_CODE (value
)), id
->insn_index
);
1299 if ((attr
= find_attr (XSTR (XEXP (value
, 0), 0), 0)) == NULL
)
1300 fatal ("Unknown attribute `%s' for pattern number %d",
1301 XSTR (XEXP (value
, 0), 0), id
->insn_index
);
1303 XVECEXP (id
->def
, id
->vec_idx
, i
) = value
;
1304 XEXP (value
, 1) = check_attr_value (XEXP (value
, 1), attr
);
1309 /* Given a constant SYMBOL_REF expression, convert to a COND that
1310 explicitly tests each enumerated value. */
1313 convert_const_symbol_ref (exp
, attr
)
1315 struct attr_desc
*attr
;
1318 struct attr_value
*av
;
1322 for (av
= attr
->first_value
; av
; av
= av
->next
)
1325 /* Make a COND with all tests but the last, and in the original order.
1326 Select the last value via the default. Note that the attr values
1327 are constructed in reverse order. */
1329 condexp
= rtx_alloc (COND
);
1330 XVEC (condexp
, 0) = rtvec_alloc ((num_alt
- 1) * 2);
1331 av
= attr
->first_value
;
1332 XEXP (condexp
, 1) = av
->value
;
1334 for (i
= num_alt
- 2; av
= av
->next
, i
>= 0; i
--)
1339 string
= p
= (char *) oballoc (2
1340 + strlen (attr
->name
)
1341 + strlen (XSTR (av
->value
, 0)));
1342 strcpy (p
, attr
->name
);
1344 strcat (p
, XSTR (av
->value
, 0));
1345 for (; *p
!= '\0'; p
++)
1346 if (*p
>= 'a' && *p
<= 'z')
1349 value
= attr_rtx (SYMBOL_REF
, string
);
1350 RTX_UNCHANGING_P (value
) = 1;
1352 XVECEXP (condexp
, 0, 2 * i
) = attr_rtx (EQ
, exp
, value
);
1354 XVECEXP (condexp
, 0, 2 * i
+ 1) = av
->value
;
1360 /* Given a valid expression for an attribute value, remove any IF_THEN_ELSE
1361 expressions by converting them into a COND. This removes cases from this
1362 program. Also, replace an attribute value of "*" with the default attribute
1366 make_canonical (attr
, exp
)
1367 struct attr_desc
*attr
;
1373 switch (GET_CODE (exp
))
1376 exp
= make_numeric_value (INTVAL (exp
));
1380 if (! strcmp (XSTR (exp
, 0), "*"))
1382 if (attr
== 0 || attr
->default_val
== 0)
1383 fatal ("(attr_value \"*\") used in invalid context.");
1384 exp
= attr
->default_val
->value
;
1390 if (!attr
->is_const
|| RTX_UNCHANGING_P (exp
))
1392 /* The SYMBOL_REF is constant for a given run, so mark it as unchanging.
1393 This makes the COND something that won't be considered an arbitrary
1394 expression by walk_attr_value. */
1395 RTX_UNCHANGING_P (exp
) = 1;
1396 exp
= convert_const_symbol_ref (exp
, attr
);
1397 RTX_UNCHANGING_P (exp
) = 1;
1398 exp
= check_attr_value (exp
, attr
);
1399 /* Goto COND case since this is now a COND. Note that while the
1400 new expression is rescanned, all symbol_ref notes are marked as
1405 newexp
= rtx_alloc (COND
);
1406 XVEC (newexp
, 0) = rtvec_alloc (2);
1407 XVECEXP (newexp
, 0, 0) = XEXP (exp
, 0);
1408 XVECEXP (newexp
, 0, 1) = XEXP (exp
, 1);
1410 XEXP (newexp
, 1) = XEXP (exp
, 2);
1413 /* Fall through to COND case since this is now a COND. */
1421 /* First, check for degenerate COND. */
1422 if (XVECLEN (exp
, 0) == 0)
1423 return make_canonical (attr
, XEXP (exp
, 1));
1424 defval
= XEXP (exp
, 1) = make_canonical (attr
, XEXP (exp
, 1));
1426 for (i
= 0; i
< XVECLEN (exp
, 0); i
+= 2)
1428 XVECEXP (exp
, 0, i
) = copy_boolean (XVECEXP (exp
, 0, i
));
1429 XVECEXP (exp
, 0, i
+ 1)
1430 = make_canonical (attr
, XVECEXP (exp
, 0, i
+ 1));
1431 if (! rtx_equal_p (XVECEXP (exp
, 0, i
+ 1), defval
))
1450 if (GET_CODE (exp
) == AND
|| GET_CODE (exp
) == IOR
)
1451 return attr_rtx (GET_CODE (exp
), copy_boolean (XEXP (exp
, 0)),
1452 copy_boolean (XEXP (exp
, 1)));
1456 /* Given a value and an attribute description, return a `struct attr_value *'
1457 that represents that value. This is either an existing structure, if the
1458 value has been previously encountered, or a newly-created structure.
1460 `insn_code' is the code of an insn whose attribute has the specified
1461 value (-2 if not processing an insn). We ensure that all insns for
1462 a given value have the same number of alternatives if the value checks
1465 static struct attr_value
*
1466 get_attr_value (value
, attr
, insn_code
)
1468 struct attr_desc
*attr
;
1471 struct attr_value
*av
;
1474 value
= make_canonical (attr
, value
);
1475 if (compares_alternatives_p (value
))
1477 if (insn_code
< 0 || insn_alternatives
== NULL
)
1478 fatal ("(eq_attr \"alternatives\" ...) used in non-insn context");
1480 num_alt
= insn_alternatives
[insn_code
];
1483 for (av
= attr
->first_value
; av
; av
= av
->next
)
1484 if (rtx_equal_p (value
, av
->value
)
1485 && (num_alt
== 0 || av
->first_insn
== NULL
1486 || insn_alternatives
[av
->first_insn
->insn_code
]))
1489 av
= (struct attr_value
*) oballoc (sizeof (struct attr_value
));
1491 av
->next
= attr
->first_value
;
1492 attr
->first_value
= av
;
1493 av
->first_insn
= NULL
;
1495 av
->has_asm_insn
= 0;
1500 /* After all DEFINE_DELAYs have been read in, create internal attributes
1501 to generate the required routines.
1503 First, we compute the number of delay slots for each insn (as a COND of
1504 each of the test expressions in DEFINE_DELAYs). Then, if more than one
1505 delay type is specified, we compute a similar function giving the
1506 DEFINE_DELAY ordinal for each insn.
1508 Finally, for each [DEFINE_DELAY, slot #] pair, we compute an attribute that
1509 tells whether a given insn can be in that delay slot.
1511 Normal attribute filling and optimization expands these to contain the
1512 information needed to handle delay slots. */
1517 struct delay_desc
*delay
;
1523 /* First, generate data for `num_delay_slots' function. */
1525 condexp
= rtx_alloc (COND
);
1526 XVEC (condexp
, 0) = rtvec_alloc (num_delays
* 2);
1527 XEXP (condexp
, 1) = make_numeric_value (0);
1529 for (i
= 0, delay
= delays
; delay
; i
+= 2, delay
= delay
->next
)
1531 XVECEXP (condexp
, 0, i
) = XEXP (delay
->def
, 0);
1532 XVECEXP (condexp
, 0, i
+ 1)
1533 = make_numeric_value (XVECLEN (delay
->def
, 1) / 3);
1536 make_internal_attr ("*num_delay_slots", condexp
, 0);
1538 /* If more than one delay type, do the same for computing the delay type. */
1541 condexp
= rtx_alloc (COND
);
1542 XVEC (condexp
, 0) = rtvec_alloc (num_delays
* 2);
1543 XEXP (condexp
, 1) = make_numeric_value (0);
1545 for (i
= 0, delay
= delays
; delay
; i
+= 2, delay
= delay
->next
)
1547 XVECEXP (condexp
, 0, i
) = XEXP (delay
->def
, 0);
1548 XVECEXP (condexp
, 0, i
+ 1) = make_numeric_value (delay
->num
);
1551 make_internal_attr ("*delay_type", condexp
, 1);
1554 /* For each delay possibility and delay slot, compute an eligibility
1555 attribute for non-annulled insns and for each type of annulled (annul
1556 if true and annul if false). */
1557 for (delay
= delays
; delay
; delay
= delay
->next
)
1559 for (i
= 0; i
< XVECLEN (delay
->def
, 1); i
+= 3)
1561 condexp
= XVECEXP (delay
->def
, 1, i
);
1562 if (condexp
== 0) condexp
= false_rtx
;
1563 newexp
= attr_rtx (IF_THEN_ELSE
, condexp
,
1564 make_numeric_value (1), make_numeric_value (0));
1566 p
= attr_printf (sizeof ("*delay__") + MAX_DIGITS
*2, "*delay_%d_%d",
1568 make_internal_attr (p
, newexp
, 1);
1570 if (have_annul_true
)
1572 condexp
= XVECEXP (delay
->def
, 1, i
+ 1);
1573 if (condexp
== 0) condexp
= false_rtx
;
1574 newexp
= attr_rtx (IF_THEN_ELSE
, condexp
,
1575 make_numeric_value (1),
1576 make_numeric_value (0));
1577 p
= attr_printf (sizeof ("*annul_true__") + MAX_DIGITS
*2,
1578 "*annul_true_%d_%d", delay
->num
, i
/ 3);
1579 make_internal_attr (p
, newexp
, 1);
1582 if (have_annul_false
)
1584 condexp
= XVECEXP (delay
->def
, 1, i
+ 2);
1585 if (condexp
== 0) condexp
= false_rtx
;
1586 newexp
= attr_rtx (IF_THEN_ELSE
, condexp
,
1587 make_numeric_value (1),
1588 make_numeric_value (0));
1589 p
= attr_printf (sizeof ("*annul_false__") + MAX_DIGITS
*2,
1590 "*annul_false_%d_%d", delay
->num
, i
/ 3);
1591 make_internal_attr (p
, newexp
, 1);
1597 /* This function is given a left and right side expression and an operator.
1598 Each side is a conditional expression, each alternative of which has a
1599 numerical value. The function returns another conditional expression
1600 which, for every possible set of condition values, returns a value that is
1601 the operator applied to the values of the two sides.
1603 Since this is called early, it must also support IF_THEN_ELSE. */
1606 operate_exp (op
, left
, right
)
1610 int left_value
, right_value
;
1614 /* If left is a string, apply operator to it and the right side. */
1615 if (GET_CODE (left
) == CONST_STRING
)
1617 /* If right is also a string, just perform the operation. */
1618 if (GET_CODE (right
) == CONST_STRING
)
1620 left_value
= atoi (XSTR (left
, 0));
1621 right_value
= atoi (XSTR (right
, 0));
1625 i
= left_value
+ right_value
;
1629 i
= left_value
- right_value
;
1632 case POS_MINUS_OP
: /* The positive part of LEFT - RIGHT. */
1633 if (left_value
> right_value
)
1634 i
= left_value
- right_value
;
1640 i
= left_value
| right_value
;
1644 i
= left_value
== right_value
;
1648 i
= (left_value
<< (HOST_BITS_PER_INT
/ 2)) | right_value
;
1652 if (left_value
> right_value
)
1659 if (left_value
< right_value
)
1669 return make_numeric_value (i
);
1671 else if (GET_CODE (right
) == IF_THEN_ELSE
)
1673 /* Apply recursively to all values within. */
1674 rtx newleft
= operate_exp (op
, left
, XEXP (right
, 1));
1675 rtx newright
= operate_exp (op
, left
, XEXP (right
, 2));
1676 if (rtx_equal_p (newleft
, newright
))
1678 return attr_rtx (IF_THEN_ELSE
, XEXP (right
, 0), newleft
, newright
);
1680 else if (GET_CODE (right
) == COND
)
1685 newexp
= rtx_alloc (COND
);
1686 XVEC (newexp
, 0) = rtvec_alloc (XVECLEN (right
, 0));
1687 defval
= XEXP (newexp
, 1) = operate_exp (op
, left
, XEXP (right
, 1));
1689 for (i
= 0; i
< XVECLEN (right
, 0); i
+= 2)
1691 XVECEXP (newexp
, 0, i
) = XVECEXP (right
, 0, i
);
1692 XVECEXP (newexp
, 0, i
+ 1)
1693 = operate_exp (op
, left
, XVECEXP (right
, 0, i
+ 1));
1694 if (! rtx_equal_p (XVECEXP (newexp
, 0, i
+ 1),
1699 /* If the resulting cond is trivial (all alternatives
1700 give the same value), optimize it away. */
1703 obstack_free (rtl_obstack
, newexp
);
1704 return operate_exp (op
, left
, XEXP (right
, 1));
1707 /* If the result is the same as the RIGHT operand,
1709 if (rtx_equal_p (newexp
, right
))
1711 obstack_free (rtl_obstack
, newexp
);
1718 fatal ("Badly formed attribute value");
1721 /* Otherwise, do recursion the other way. */
1722 else if (GET_CODE (left
) == IF_THEN_ELSE
)
1724 rtx newleft
= operate_exp (op
, XEXP (left
, 1), right
);
1725 rtx newright
= operate_exp (op
, XEXP (left
, 2), right
);
1726 if (rtx_equal_p (newleft
, newright
))
1728 return attr_rtx (IF_THEN_ELSE
, XEXP (left
, 0), newleft
, newright
);
1730 else if (GET_CODE (left
) == COND
)
1735 newexp
= rtx_alloc (COND
);
1736 XVEC (newexp
, 0) = rtvec_alloc (XVECLEN (left
, 0));
1737 defval
= XEXP (newexp
, 1) = operate_exp (op
, XEXP (left
, 1), right
);
1739 for (i
= 0; i
< XVECLEN (left
, 0); i
+= 2)
1741 XVECEXP (newexp
, 0, i
) = XVECEXP (left
, 0, i
);
1742 XVECEXP (newexp
, 0, i
+ 1)
1743 = operate_exp (op
, XVECEXP (left
, 0, i
+ 1), right
);
1744 if (! rtx_equal_p (XVECEXP (newexp
, 0, i
+ 1),
1749 /* If the cond is trivial (all alternatives give the same value),
1750 optimize it away. */
1753 obstack_free (rtl_obstack
, newexp
);
1754 return operate_exp (op
, XEXP (left
, 1), right
);
1757 /* If the result is the same as the LEFT operand,
1759 if (rtx_equal_p (newexp
, left
))
1761 obstack_free (rtl_obstack
, newexp
);
1769 fatal ("Badly formed attribute value.");
1774 /* Once all attributes and DEFINE_FUNCTION_UNITs have been read, we
1775 construct a number of attributes.
1777 The first produces a function `function_units_used' which is given an
1778 insn and produces an encoding showing which function units are required
1779 for the execution of that insn. If the value is non-negative, the insn
1780 uses that unit; otherwise, the value is a one's compliment mask of units
1783 The second produces a function `result_ready_cost' which is used to
1784 determine the time that the result of an insn will be ready and hence
1785 a worst-case schedule.
1787 Both of these produce quite complex expressions which are then set as the
1788 default value of internal attributes. Normal attribute simplification
1789 should produce reasonable expressions.
1791 For each unit, a `<name>_unit_ready_cost' function will take an
1792 insn and give the delay until that unit will be ready with the result
1793 and a `<name>_unit_conflict_cost' function is given an insn already
1794 executing on the unit and a candidate to execute and will give the
1795 cost from the time the executing insn started until the candidate
1796 can start (ignore limitations on the number of simultaneous insns).
1798 For each unit, a `<name>_unit_blockage' function is given an insn
1799 already executing on the unit and a candidate to execute and will
1800 give the delay incurred due to function unit conflicts. The range of
1801 blockage cost values for a given executing insn is given by the
1802 `<name>_unit_blockage_range' function. These values are encoded in
1803 an int where the upper half gives the minimum value and the lower
1804 half gives the maximum value. */
1809 struct function_unit
*unit
, **unit_num
;
1810 struct function_unit_op
*op
, **op_array
, ***unit_ops
;
1815 int i
, j
, u
, num
, nvalues
;
1817 /* Rebuild the condition for the unit to share the RTL expressions.
1818 Sharing is required by simplify_by_exploding. Build the issue delay
1819 expressions. Validate the expressions we were given for the conditions
1820 and conflict vector. Then make attributes for use in the conflict
1823 for (unit
= units
; unit
; unit
= unit
->next
)
1825 unit
->condexp
= check_attr_test (unit
->condexp
, 0);
1827 for (op
= unit
->ops
; op
; op
= op
->next
)
1829 rtx issue_delay
= make_numeric_value (op
->issue_delay
);
1830 rtx issue_exp
= issue_delay
;
1832 /* Build, validate, and simplify the issue delay expression. */
1833 if (op
->conflict_exp
!= true_rtx
)
1834 issue_exp
= attr_rtx (IF_THEN_ELSE
, op
->conflict_exp
,
1835 issue_exp
, make_numeric_value (0));
1836 issue_exp
= check_attr_value (make_canonical (NULL_ATTR
,
1839 issue_exp
= simplify_knowing (issue_exp
, unit
->condexp
);
1840 op
->issue_exp
= issue_exp
;
1842 /* Make an attribute for use in the conflict function if needed. */
1843 unit
->needs_conflict_function
= (unit
->issue_delay
.min
1844 != unit
->issue_delay
.max
);
1845 if (unit
->needs_conflict_function
)
1847 str
= attr_printf (strlen (unit
->name
) + sizeof ("*_cost_") + MAX_DIGITS
,
1848 "*%s_cost_%d", unit
->name
, op
->num
);
1849 make_internal_attr (str
, issue_exp
, 1);
1852 /* Validate the condition. */
1853 op
->condexp
= check_attr_test (op
->condexp
, 0);
1857 /* Compute the mask of function units used. Initially, the unitsmask is
1858 zero. Set up a conditional to compute each unit's contribution. */
1859 unitsmask
= make_numeric_value (0);
1860 newexp
= rtx_alloc (IF_THEN_ELSE
);
1861 XEXP (newexp
, 2) = make_numeric_value (0);
1863 /* Merge each function unit into the unit mask attributes. */
1864 for (unit
= units
; unit
; unit
= unit
->next
)
1866 XEXP (newexp
, 0) = unit
->condexp
;
1867 XEXP (newexp
, 1) = make_numeric_value (1 << unit
->num
);
1868 unitsmask
= operate_exp (OR_OP
, unitsmask
, newexp
);
1871 /* Simplify the unit mask expression, encode it, and make an attribute
1872 for the function_units_used function. */
1873 unitsmask
= simplify_by_exploding (unitsmask
);
1874 unitsmask
= encode_units_mask (unitsmask
);
1875 make_internal_attr ("*function_units_used", unitsmask
, 2);
1877 /* Create an array of ops for each unit. Add an extra unit for the
1878 result_ready_cost function that has the ops of all other units. */
1879 unit_ops
= (struct function_unit_op
***)
1880 alloca ((num_units
+ 1) * sizeof (struct function_unit_op
**));
1881 unit_num
= (struct function_unit
**)
1882 alloca ((num_units
+ 1) * sizeof (struct function_unit
*));
1884 unit_num
[num_units
] = unit
= (struct function_unit
*)
1885 alloca (sizeof (struct function_unit
));
1886 unit
->num
= num_units
;
1887 unit
->num_opclasses
= 0;
1889 for (unit
= units
; unit
; unit
= unit
->next
)
1891 unit_num
[num_units
]->num_opclasses
+= unit
->num_opclasses
;
1892 unit_num
[unit
->num
] = unit
;
1893 unit_ops
[unit
->num
] = op_array
= (struct function_unit_op
**)
1894 alloca (unit
->num_opclasses
* sizeof (struct function_unit_op
*));
1896 for (op
= unit
->ops
; op
; op
= op
->next
)
1897 op_array
[op
->num
] = op
;
1900 /* Compose the array of ops for the extra unit. */
1901 unit_ops
[num_units
] = op_array
= (struct function_unit_op
**)
1902 alloca (unit_num
[num_units
]->num_opclasses
1903 * sizeof (struct function_unit_op
*));
1905 for (unit
= units
, i
= 0; unit
; i
+= unit
->num_opclasses
, unit
= unit
->next
)
1906 bcopy ((char *) unit_ops
[unit
->num
], (char *) &op_array
[i
],
1907 unit
->num_opclasses
* sizeof (struct function_unit_op
*));
1909 /* Compute the ready cost function for each unit by computing the
1910 condition for each non-default value. */
1911 for (u
= 0; u
<= num_units
; u
++)
1917 op_array
= unit_ops
[unit
->num
];
1918 num
= unit
->num_opclasses
;
1920 /* Sort the array of ops into increasing ready cost order. */
1921 for (i
= 0; i
< num
; i
++)
1922 for (j
= num
- 1; j
> i
; j
--)
1923 if (op_array
[j
-1]->ready
< op_array
[j
]->ready
)
1926 op_array
[j
] = op_array
[j
-1];
1930 /* Determine how many distinct non-default ready cost values there
1931 are. We use a default ready cost value of 1. */
1932 nvalues
= 0; value
= 1;
1933 for (i
= num
- 1; i
>= 0; i
--)
1934 if (op_array
[i
]->ready
> value
)
1936 value
= op_array
[i
]->ready
;
1941 readycost
= make_numeric_value (1);
1944 /* Construct the ready cost expression as a COND of each value from
1945 the largest to the smallest. */
1946 readycost
= rtx_alloc (COND
);
1947 XVEC (readycost
, 0) = rtvec_alloc (nvalues
* 2);
1948 XEXP (readycost
, 1) = make_numeric_value (1);
1950 nvalues
= 0; orexp
= false_rtx
; value
= op_array
[0]->ready
;
1951 for (i
= 0; i
< num
; i
++)
1956 else if (op
->ready
== value
)
1957 orexp
= insert_right_side (IOR
, orexp
, op
->condexp
, -2, -2);
1960 XVECEXP (readycost
, 0, nvalues
* 2) = orexp
;
1961 XVECEXP (readycost
, 0, nvalues
* 2 + 1)
1962 = make_numeric_value (value
);
1965 orexp
= op
->condexp
;
1968 XVECEXP (readycost
, 0, nvalues
* 2) = orexp
;
1969 XVECEXP (readycost
, 0, nvalues
* 2 + 1) = make_numeric_value (value
);
1974 rtx max_blockage
= 0, min_blockage
= 0;
1976 /* Simplify the readycost expression by only considering insns
1977 that use the unit. */
1978 readycost
= simplify_knowing (readycost
, unit
->condexp
);
1980 /* Determine the blockage cost the executing insn (E) given
1981 the candidate insn (C). This is the maximum of the issue
1982 delay, the pipeline delay, and the simultaneity constraint.
1983 Each function_unit_op represents the characteristics of the
1984 candidate insn, so in the expressions below, C is a known
1985 term and E is an unknown term.
1987 We compute the blockage cost for each E for every possible C.
1988 Thus OP represents E, and READYCOST is a list of values for
1991 The issue delay function for C is op->issue_exp and is used to
1992 write the `<name>_unit_conflict_cost' function. Symbolicly
1993 this is "ISSUE-DELAY (E,C)".
1995 The pipeline delay results form the FIFO constraint on the
1996 function unit and is "READY-COST (E) + 1 - READY-COST (C)".
1998 The simultaneity constraint is based on how long it takes to
1999 fill the unit given the minimum issue delay. FILL-TIME is the
2000 constant "MIN (ISSUE-DELAY (*,*)) * (SIMULTANEITY - 1)", and
2001 the simultaneity constraint is "READY-COST (E) - FILL-TIME"
2002 if SIMULTANEITY is non-zero and zero otherwise.
2004 Thus, BLOCKAGE (E,C) when SIMULTANEITY is zero is
2006 MAX (ISSUE-DELAY (E,C),
2007 READY-COST (E) - (READY-COST (C) - 1))
2011 MAX (ISSUE-DELAY (E,C),
2012 READY-COST (E) - (READY-COST (C) - 1),
2013 READY-COST (E) - FILL-TIME)
2015 The `<name>_unit_blockage' function is computed by determining
2016 this value for each candidate insn. As these values are
2017 computed, we also compute the upper and lower bounds for
2018 BLOCKAGE (E,*). These are combined to form the function
2019 `<name>_unit_blockage_range'. Finally, the maximum blockage
2020 cost, MAX (BLOCKAGE (*,*)), is computed. */
2022 for (op
= unit
->ops
; op
; op
= op
->next
)
2024 rtx blockage
= operate_exp (POS_MINUS_OP
, readycost
,
2025 make_numeric_value (1));
2027 if (unit
->simultaneity
!= 0)
2029 rtx filltime
= make_numeric_value ((unit
->simultaneity
- 1)
2030 * unit
->issue_delay
.min
);
2031 blockage
= operate_exp (MIN_OP
, blockage
, filltime
);
2034 blockage
= operate_exp (POS_MINUS_OP
,
2035 make_numeric_value (op
->ready
),
2038 blockage
= operate_exp (MAX_OP
, blockage
, op
->issue_exp
);
2039 blockage
= simplify_knowing (blockage
, unit
->condexp
);
2041 /* Add this op's contribution to MAX (BLOCKAGE (E,*)) and
2042 MIN (BLOCKAGE (E,*)). */
2043 if (max_blockage
== 0)
2044 max_blockage
= min_blockage
= blockage
;
2048 = simplify_knowing (operate_exp (MAX_OP
, max_blockage
,
2052 = simplify_knowing (operate_exp (MIN_OP
, min_blockage
,
2057 /* Make an attribute for use in the blockage function. */
2058 str
= attr_printf (strlen (unit
->name
) + sizeof ("*_block_") + MAX_DIGITS
,
2059 "*%s_block_%d", unit
->name
, op
->num
);
2060 make_internal_attr (str
, blockage
, 1);
2063 /* Record MAX (BLOCKAGE (*,*)). */
2064 unit
->max_blockage
= max_attr_value (max_blockage
);
2066 /* See if the upper and lower bounds of BLOCKAGE (E,*) are the
2067 same. If so, the blockage function carries no additional
2068 information and is not written. */
2069 newexp
= operate_exp (EQ_OP
, max_blockage
, min_blockage
);
2070 newexp
= simplify_knowing (newexp
, unit
->condexp
);
2071 unit
->needs_blockage_function
2072 = (GET_CODE (newexp
) != CONST_STRING
2073 || atoi (XSTR (newexp
, 0)) != 1);
2075 /* If the all values of BLOCKAGE (E,C) have the same value,
2076 neither blockage function is written. */
2077 unit
->needs_range_function
2078 = (unit
->needs_blockage_function
2079 || GET_CODE (max_blockage
) != CONST_STRING
);
2081 if (unit
->needs_range_function
)
2083 /* Compute the blockage range function and make an attribute
2084 for writing it's value. */
2085 newexp
= operate_exp (RANGE_OP
, min_blockage
, max_blockage
);
2086 newexp
= simplify_knowing (newexp
, unit
->condexp
);
2088 str
= attr_printf (strlen (unit
->name
) + sizeof ("*_unit_blockage_range"),
2089 "*%s_unit_blockage_range", unit
->name
);
2090 make_internal_attr (str
, newexp
, 4);
2093 str
= attr_printf (strlen (unit
->name
) + sizeof ("*_unit_ready_cost"),
2094 "*%s_unit_ready_cost", unit
->name
);
2097 str
= "*result_ready_cost";
2099 /* Make an attribute for the ready_cost function. Simplifying
2100 further with simplify_by_exploding doesn't win. */
2101 make_internal_attr (str
, readycost
, 0);
2104 /* For each unit that requires a conflict cost function, make an attribute
2105 that maps insns to the operation number. */
2106 for (unit
= units
; unit
; unit
= unit
->next
)
2110 if (! unit
->needs_conflict_function
2111 && ! unit
->needs_blockage_function
)
2114 caseexp
= rtx_alloc (COND
);
2115 XVEC (caseexp
, 0) = rtvec_alloc ((unit
->num_opclasses
- 1) * 2);
2117 for (op
= unit
->ops
; op
; op
= op
->next
)
2119 /* Make our adjustment to the COND being computed. If we are the
2120 last operation class, place our values into the default of the
2122 if (op
->num
== unit
->num_opclasses
- 1)
2124 XEXP (caseexp
, 1) = make_numeric_value (op
->num
);
2128 XVECEXP (caseexp
, 0, op
->num
* 2) = op
->condexp
;
2129 XVECEXP (caseexp
, 0, op
->num
* 2 + 1)
2130 = make_numeric_value (op
->num
);
2134 /* Simplifying caseexp with simplify_by_exploding doesn't win. */
2135 str
= attr_printf (strlen (unit
->name
) + sizeof ("*_cases"),
2136 "*%s_cases", unit
->name
);
2137 make_internal_attr (str
, caseexp
, 1);
2141 /* Simplify EXP given KNOWN_TRUE. */
2144 simplify_knowing (exp
, known_true
)
2145 rtx exp
, known_true
;
2147 if (GET_CODE (exp
) != CONST_STRING
)
2149 exp
= attr_rtx (IF_THEN_ELSE
, known_true
, exp
,
2150 make_numeric_value (max_attr_value (exp
)));
2151 exp
= simplify_by_exploding (exp
);
2156 /* Translate the CONST_STRING expressions in X to change the encoding of
2157 value. On input, the value is a bitmask with a one bit for each unit
2158 used; on output, the value is the unit number (zero based) if one
2159 and only one unit is used or the one's compliment of the bitmask. */
2162 encode_units_mask (x
)
2167 register enum rtx_code code
;
2170 code
= GET_CODE (x
);
2175 i
= atoi (XSTR (x
, 0));
2177 abort (); /* The sign bit encodes a one's compliment mask. */
2178 else if (i
!= 0 && i
== (i
& -i
))
2179 /* Only one bit is set, so yield that unit number. */
2180 for (j
= 0; (i
>>= 1) != 0; j
++)
2184 return attr_rtx (CONST_STRING
, attr_printf (MAX_DIGITS
, "%d", j
));
2201 /* Compare the elements. If any pair of corresponding elements
2202 fail to match, return 0 for the whole things. */
2204 fmt
= GET_RTX_FORMAT (code
);
2205 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
2211 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
2212 XVECEXP (x
, i
, j
) = encode_units_mask (XVECEXP (x
, i
, j
));
2216 XEXP (x
, i
) = encode_units_mask (XEXP (x
, i
));
2223 /* Once all attributes and insns have been read and checked, we construct for
2224 each attribute value a list of all the insns that have that value for
2229 struct attr_desc
*attr
;
2231 struct attr_value
*av
;
2232 struct insn_ent
*ie
;
2233 struct insn_def
*id
;
2237 /* Don't fill constant attributes. The value is independent of
2238 any particular insn. */
2242 for (id
= defs
; id
; id
= id
->next
)
2244 /* If no value is specified for this insn for this attribute, use the
2247 if (XVEC (id
->def
, id
->vec_idx
))
2248 for (i
= 0; i
< XVECLEN (id
->def
, id
->vec_idx
); i
++)
2249 if (! strcmp (XSTR (XEXP (XVECEXP (id
->def
, id
->vec_idx
, i
), 0), 0),
2251 value
= XEXP (XVECEXP (id
->def
, id
->vec_idx
, i
), 1);
2254 av
= attr
->default_val
;
2256 av
= get_attr_value (value
, attr
, id
->insn_code
);
2258 ie
= (struct insn_ent
*) oballoc (sizeof (struct insn_ent
));
2259 ie
->insn_code
= id
->insn_code
;
2260 ie
->insn_index
= id
->insn_code
;
2261 insert_insn_ent (av
, ie
);
2265 /* Given an expression EXP, see if it is a COND or IF_THEN_ELSE that has a
2266 test that checks relative positions of insns (uses MATCH_DUP or PC).
2267 If so, replace it with what is obtained by passing the expression to
2268 ADDRESS_FN. If not but it is a COND or IF_THEN_ELSE, call this routine
2269 recursively on each value (including the default value). Otherwise,
2270 return the value returned by NO_ADDRESS_FN applied to EXP. */
2273 substitute_address (exp
, no_address_fn
, address_fn
)
2275 rtx (*no_address_fn
) ();
2276 rtx (*address_fn
) ();
2281 if (GET_CODE (exp
) == COND
)
2283 /* See if any tests use addresses. */
2285 for (i
= 0; i
< XVECLEN (exp
, 0); i
+= 2)
2286 walk_attr_value (XVECEXP (exp
, 0, i
));
2289 return (*address_fn
) (exp
);
2291 /* Make a new copy of this COND, replacing each element. */
2292 newexp
= rtx_alloc (COND
);
2293 XVEC (newexp
, 0) = rtvec_alloc (XVECLEN (exp
, 0));
2294 for (i
= 0; i
< XVECLEN (exp
, 0); i
+= 2)
2296 XVECEXP (newexp
, 0, i
) = XVECEXP (exp
, 0, i
);
2297 XVECEXP (newexp
, 0, i
+ 1)
2298 = substitute_address (XVECEXP (exp
, 0, i
+ 1),
2299 no_address_fn
, address_fn
);
2302 XEXP (newexp
, 1) = substitute_address (XEXP (exp
, 1),
2303 no_address_fn
, address_fn
);
2308 else if (GET_CODE (exp
) == IF_THEN_ELSE
)
2311 walk_attr_value (XEXP (exp
, 0));
2313 return (*address_fn
) (exp
);
2315 return attr_rtx (IF_THEN_ELSE
,
2316 substitute_address (XEXP (exp
, 0),
2317 no_address_fn
, address_fn
),
2318 substitute_address (XEXP (exp
, 1),
2319 no_address_fn
, address_fn
),
2320 substitute_address (XEXP (exp
, 2),
2321 no_address_fn
, address_fn
));
2324 return (*no_address_fn
) (exp
);
2327 /* Make new attributes from the `length' attribute. The following are made,
2328 each corresponding to a function called from `shorten_branches' or
2331 *insn_default_length This is the length of the insn to be returned
2332 by `get_attr_length' before `shorten_branches'
2333 has been called. In each case where the length
2334 depends on relative addresses, the largest
2335 possible is used. This routine is also used
2336 to compute the initial size of the insn.
2338 *insn_variable_length_p This returns 1 if the insn's length depends
2339 on relative addresses, zero otherwise.
2341 *insn_current_length This is only called when it is known that the
2342 insn has a variable length and returns the
2343 current length, based on relative addresses.
2347 make_length_attrs ()
2349 static char *new_names
[] = {"*insn_default_length",
2350 "*insn_variable_length_p",
2351 "*insn_current_length"};
2352 static rtx (*no_address_fn
[]) PROTO((rtx
)) = {identity_fn
, zero_fn
, zero_fn
};
2353 static rtx (*address_fn
[]) PROTO((rtx
)) = {max_fn
, one_fn
, identity_fn
};
2355 struct attr_desc
*length_attr
, *new_attr
;
2356 struct attr_value
*av
, *new_av
;
2357 struct insn_ent
*ie
, *new_ie
;
2359 /* See if length attribute is defined. If so, it must be numeric. Make
2360 it special so we don't output anything for it. */
2361 length_attr
= find_attr ("length", 0);
2362 if (length_attr
== 0)
2365 if (! length_attr
->is_numeric
)
2366 fatal ("length attribute must be numeric.");
2368 length_attr
->is_const
= 0;
2369 length_attr
->is_special
= 1;
2371 /* Make each new attribute, in turn. */
2372 for (i
= 0; i
< sizeof new_names
/ sizeof new_names
[0]; i
++)
2374 make_internal_attr (new_names
[i
],
2375 substitute_address (length_attr
->default_val
->value
,
2376 no_address_fn
[i
], address_fn
[i
]),
2378 new_attr
= find_attr (new_names
[i
], 0);
2379 for (av
= length_attr
->first_value
; av
; av
= av
->next
)
2380 for (ie
= av
->first_insn
; ie
; ie
= ie
->next
)
2382 new_av
= get_attr_value (substitute_address (av
->value
,
2385 new_attr
, ie
->insn_code
);
2386 new_ie
= (struct insn_ent
*) oballoc (sizeof (struct insn_ent
));
2387 new_ie
->insn_code
= ie
->insn_code
;
2388 new_ie
->insn_index
= ie
->insn_index
;
2389 insert_insn_ent (new_av
, new_ie
);
2394 /* Utility functions called from above routine. */
2407 return make_numeric_value (0);
2414 return make_numeric_value (1);
2421 return make_numeric_value (max_attr_value (exp
));
2424 /* Take a COND expression and see if any of the conditions in it can be
2425 simplified. If any are known true or known false for the particular insn
2426 code, the COND can be further simplified.
2428 Also call ourselves on any COND operations that are values of this COND.
2430 We do not modify EXP; rather, we make and return a new rtx. */
2433 simplify_cond (exp
, insn_code
, insn_index
)
2435 int insn_code
, insn_index
;
2438 /* We store the desired contents here,
2439 then build a new expression if they don't match EXP. */
2440 rtx defval
= XEXP (exp
, 1);
2441 rtx new_defval
= XEXP (exp
, 1);
2442 int len
= XVECLEN (exp
, 0);
2443 rtunion
*tests
= (rtunion
*) alloca (len
* sizeof (rtunion
));
2447 /* This lets us free all storage allocated below, if appropriate. */
2448 first_spacer
= (char *) obstack_finish (rtl_obstack
);
2450 bcopy ((char *) XVEC (exp
, 0)->elem
, (char *) tests
, len
* sizeof (rtunion
));
2452 /* See if default value needs simplification. */
2453 if (GET_CODE (defval
) == COND
)
2454 new_defval
= simplify_cond (defval
, insn_code
, insn_index
);
2456 /* Simplify the subexpressions, and see what tests we can get rid of. */
2458 for (i
= 0; i
< len
; i
+= 2)
2460 rtx newtest
, newval
;
2462 /* Simplify this test. */
2463 newtest
= SIMPLIFY_TEST_EXP (tests
[i
].rtx
, insn_code
, insn_index
);
2464 tests
[i
].rtx
= newtest
;
2466 newval
= tests
[i
+ 1].rtx
;
2467 /* See if this value may need simplification. */
2468 if (GET_CODE (newval
) == COND
)
2469 newval
= simplify_cond (newval
, insn_code
, insn_index
);
2471 /* Look for ways to delete or combine this test. */
2472 if (newtest
== true_rtx
)
2474 /* If test is true, make this value the default
2475 and discard this + any following tests. */
2477 defval
= tests
[i
+ 1].rtx
;
2478 new_defval
= newval
;
2481 else if (newtest
== false_rtx
)
2483 /* If test is false, discard it and its value. */
2484 for (j
= i
; j
< len
- 2; j
++)
2485 tests
[j
].rtx
= tests
[j
+ 2].rtx
;
2489 else if (i
> 0 && attr_equal_p (newval
, tests
[i
- 1].rtx
))
2491 /* If this value and the value for the prev test are the same,
2495 = insert_right_side (IOR
, tests
[i
- 2].rtx
, newtest
,
2496 insn_code
, insn_index
);
2498 /* Delete this test/value. */
2499 for (j
= i
; j
< len
- 2; j
++)
2500 tests
[j
].rtx
= tests
[j
+ 2].rtx
;
2505 tests
[i
+ 1].rtx
= newval
;
2508 /* If the last test in a COND has the same value
2509 as the default value, that test isn't needed. */
2511 while (len
> 0 && attr_equal_p (tests
[len
- 1].rtx
, new_defval
))
2514 /* See if we changed anything. */
2515 if (len
!= XVECLEN (exp
, 0) || new_defval
!= XEXP (exp
, 1))
2518 for (i
= 0; i
< len
; i
++)
2519 if (! attr_equal_p (tests
[i
].rtx
, XVECEXP (exp
, 0, i
)))
2527 obstack_free (rtl_obstack
, first_spacer
);
2528 if (GET_CODE (defval
) == COND
)
2529 return simplify_cond (defval
, insn_code
, insn_index
);
2534 obstack_free (rtl_obstack
, first_spacer
);
2539 rtx newexp
= rtx_alloc (COND
);
2541 XVEC (newexp
, 0) = rtvec_alloc (len
);
2542 bcopy ((char *) tests
, (char *) XVEC (newexp
, 0)->elem
,
2543 len
* sizeof (rtunion
));
2544 XEXP (newexp
, 1) = new_defval
;
2549 /* Remove an insn entry from an attribute value. */
2552 remove_insn_ent (av
, ie
)
2553 struct attr_value
*av
;
2554 struct insn_ent
*ie
;
2556 struct insn_ent
*previe
;
2558 if (av
->first_insn
== ie
)
2559 av
->first_insn
= ie
->next
;
2562 for (previe
= av
->first_insn
; previe
->next
!= ie
; previe
= previe
->next
)
2564 previe
->next
= ie
->next
;
2568 if (ie
->insn_code
== -1)
2569 av
->has_asm_insn
= 0;
2574 /* Insert an insn entry in an attribute value list. */
2577 insert_insn_ent (av
, ie
)
2578 struct attr_value
*av
;
2579 struct insn_ent
*ie
;
2581 ie
->next
= av
->first_insn
;
2582 av
->first_insn
= ie
;
2584 if (ie
->insn_code
== -1)
2585 av
->has_asm_insn
= 1;
2590 /* This is a utility routine to take an expression that is a tree of either
2591 AND or IOR expressions and insert a new term. The new term will be
2592 inserted at the right side of the first node whose code does not match
2593 the root. A new node will be created with the root's code. Its left
2594 side will be the old right side and its right side will be the new
2597 If the `term' is itself a tree, all its leaves will be inserted. */
2600 insert_right_side (code
, exp
, term
, insn_code
, insn_index
)
2604 int insn_code
, insn_index
;
2608 /* Avoid consing in some special cases. */
2609 if (code
== AND
&& term
== true_rtx
)
2611 if (code
== AND
&& term
== false_rtx
)
2613 if (code
== AND
&& exp
== true_rtx
)
2615 if (code
== AND
&& exp
== false_rtx
)
2617 if (code
== IOR
&& term
== true_rtx
)
2619 if (code
== IOR
&& term
== false_rtx
)
2621 if (code
== IOR
&& exp
== true_rtx
)
2623 if (code
== IOR
&& exp
== false_rtx
)
2625 if (attr_equal_p (exp
, term
))
2628 if (GET_CODE (term
) == code
)
2630 exp
= insert_right_side (code
, exp
, XEXP (term
, 0),
2631 insn_code
, insn_index
);
2632 exp
= insert_right_side (code
, exp
, XEXP (term
, 1),
2633 insn_code
, insn_index
);
2638 if (GET_CODE (exp
) == code
)
2640 rtx
new = insert_right_side (code
, XEXP (exp
, 1),
2641 term
, insn_code
, insn_index
);
2642 if (new != XEXP (exp
, 1))
2643 /* Make a copy of this expression and call recursively. */
2644 newexp
= attr_rtx (code
, XEXP (exp
, 0), new);
2650 /* Insert the new term. */
2651 newexp
= attr_rtx (code
, exp
, term
);
2654 return SIMPLIFY_TEST_EXP (newexp
, insn_code
, insn_index
);
2657 /* If we have an expression which AND's a bunch of
2658 (not (eq_attrq "alternative" "n"))
2659 terms, we may have covered all or all but one of the possible alternatives.
2660 If so, we can optimize. Similarly for IOR's of EQ_ATTR.
2662 This routine is passed an expression and either AND or IOR. It returns a
2663 bitmask indicating which alternatives are mentioned within EXP. */
2666 compute_alternative_mask (exp
, code
)
2671 if (GET_CODE (exp
) == code
)
2672 return compute_alternative_mask (XEXP (exp
, 0), code
)
2673 | compute_alternative_mask (XEXP (exp
, 1), code
);
2675 else if (code
== AND
&& GET_CODE (exp
) == NOT
2676 && GET_CODE (XEXP (exp
, 0)) == EQ_ATTR
2677 && XSTR (XEXP (exp
, 0), 0) == alternative_name
)
2678 string
= XSTR (XEXP (exp
, 0), 1);
2680 else if (code
== IOR
&& GET_CODE (exp
) == EQ_ATTR
2681 && XSTR (exp
, 0) == alternative_name
)
2682 string
= XSTR (exp
, 1);
2688 return 1 << (string
[0] - '0');
2689 return 1 << atoi (string
);
2692 /* Given I, a single-bit mask, return RTX to compare the `alternative'
2693 attribute with the value represented by that bit. */
2696 make_alternative_compare (mask
)
2703 for (i
= 0; (mask
& (1 << i
)) == 0; i
++)
2706 newexp
= attr_rtx (EQ_ATTR
, alternative_name
, attr_numeral (i
));
2707 RTX_UNCHANGING_P (newexp
) = 1;
2712 /* If we are processing an (eq_attr "attr" "value") test, we find the value
2713 of "attr" for this insn code. From that value, we can compute a test
2714 showing when the EQ_ATTR will be true. This routine performs that
2715 computation. If a test condition involves an address, we leave the EQ_ATTR
2716 intact because addresses are only valid for the `length' attribute.
2718 EXP is the EQ_ATTR expression and VALUE is the value of that attribute
2719 for the insn corresponding to INSN_CODE and INSN_INDEX. */
2722 evaluate_eq_attr (exp
, value
, insn_code
, insn_index
)
2725 int insn_code
, insn_index
;
2732 if (GET_CODE (value
) == CONST_STRING
)
2734 if (! strcmp (XSTR (value
, 0), XSTR (exp
, 1)))
2739 else if (GET_CODE (value
) == COND
)
2741 /* We construct an IOR of all the cases for which the requested attribute
2742 value is present. Since we start with FALSE, if it is not present,
2743 FALSE will be returned.
2745 Each case is the AND of the NOT's of the previous conditions with the
2746 current condition; in the default case the current condition is TRUE.
2748 For each possible COND value, call ourselves recursively.
2750 The extra TRUE and FALSE expressions will be eliminated by another
2751 call to the simplification routine. */
2756 if (current_alternative_string
)
2757 clear_struct_flag (value
);
2759 for (i
= 0; i
< XVECLEN (value
, 0); i
+= 2)
2761 rtx
this = SIMPLIFY_TEST_EXP (XVECEXP (value
, 0, i
),
2762 insn_code
, insn_index
);
2764 SIMPLIFY_ALTERNATIVE (this);
2766 right
= insert_right_side (AND
, andexp
, this,
2767 insn_code
, insn_index
);
2768 right
= insert_right_side (AND
, right
,
2769 evaluate_eq_attr (exp
,
2772 insn_code
, insn_index
),
2773 insn_code
, insn_index
);
2774 orexp
= insert_right_side (IOR
, orexp
, right
,
2775 insn_code
, insn_index
);
2777 /* Add this condition into the AND expression. */
2778 newexp
= attr_rtx (NOT
, this);
2779 andexp
= insert_right_side (AND
, andexp
, newexp
,
2780 insn_code
, insn_index
);
2783 /* Handle the default case. */
2784 right
= insert_right_side (AND
, andexp
,
2785 evaluate_eq_attr (exp
, XEXP (value
, 1),
2786 insn_code
, insn_index
),
2787 insn_code
, insn_index
);
2788 newexp
= insert_right_side (IOR
, orexp
, right
, insn_code
, insn_index
);
2793 /* If uses an address, must return original expression. But set the
2794 RTX_UNCHANGING_P bit so we don't try to simplify it again. */
2797 walk_attr_value (newexp
);
2801 /* This had `&& current_alternative_string', which seems to be wrong. */
2802 if (! RTX_UNCHANGING_P (exp
))
2803 return copy_rtx_unchanging (exp
);
2810 /* This routine is called when an AND of a term with a tree of AND's is
2811 encountered. If the term or its complement is present in the tree, it
2812 can be replaced with TRUE or FALSE, respectively.
2814 Note that (eq_attr "att" "v1") and (eq_attr "att" "v2") cannot both
2815 be true and hence are complementary.
2817 There is one special case: If we see
2818 (and (not (eq_attr "att" "v1"))
2819 (eq_attr "att" "v2"))
2820 this can be replaced by (eq_attr "att" "v2"). To do this we need to
2821 replace the term, not anything in the AND tree. So we pass a pointer to
2825 simplify_and_tree (exp
, pterm
, insn_code
, insn_index
)
2828 int insn_code
, insn_index
;
2833 int left_eliminates_term
, right_eliminates_term
;
2835 if (GET_CODE (exp
) == AND
)
2837 left
= simplify_and_tree (XEXP (exp
, 0), pterm
, insn_code
, insn_index
);
2838 right
= simplify_and_tree (XEXP (exp
, 1), pterm
, insn_code
, insn_index
);
2839 if (left
!= XEXP (exp
, 0) || right
!= XEXP (exp
, 1))
2841 newexp
= attr_rtx (GET_CODE (exp
), left
, right
);
2843 exp
= SIMPLIFY_TEST_EXP (newexp
, insn_code
, insn_index
);
2847 else if (GET_CODE (exp
) == IOR
)
2849 /* For the IOR case, we do the same as above, except that we can
2850 only eliminate `term' if both sides of the IOR would do so. */
2852 left
= simplify_and_tree (XEXP (exp
, 0), &temp
, insn_code
, insn_index
);
2853 left_eliminates_term
= (temp
== true_rtx
);
2856 right
= simplify_and_tree (XEXP (exp
, 1), &temp
, insn_code
, insn_index
);
2857 right_eliminates_term
= (temp
== true_rtx
);
2859 if (left_eliminates_term
&& right_eliminates_term
)
2862 if (left
!= XEXP (exp
, 0) || right
!= XEXP (exp
, 1))
2864 newexp
= attr_rtx (GET_CODE (exp
), left
, right
);
2866 exp
= SIMPLIFY_TEST_EXP (newexp
, insn_code
, insn_index
);
2870 /* Check for simplifications. Do some extra checking here since this
2871 routine is called so many times. */
2876 else if (GET_CODE (exp
) == NOT
&& XEXP (exp
, 0) == *pterm
)
2879 else if (GET_CODE (*pterm
) == NOT
&& exp
== XEXP (*pterm
, 0))
2882 else if (GET_CODE (exp
) == EQ_ATTR
&& GET_CODE (*pterm
) == EQ_ATTR
)
2884 if (XSTR (exp
, 0) != XSTR (*pterm
, 0))
2887 if (! strcmp (XSTR (exp
, 1), XSTR (*pterm
, 1)))
2893 else if (GET_CODE (*pterm
) == EQ_ATTR
&& GET_CODE (exp
) == NOT
2894 && GET_CODE (XEXP (exp
, 0)) == EQ_ATTR
)
2896 if (XSTR (*pterm
, 0) != XSTR (XEXP (exp
, 0), 0))
2899 if (! strcmp (XSTR (*pterm
, 1), XSTR (XEXP (exp
, 0), 1)))
2905 else if (GET_CODE (exp
) == EQ_ATTR
&& GET_CODE (*pterm
) == NOT
2906 && GET_CODE (XEXP (*pterm
, 0)) == EQ_ATTR
)
2908 if (XSTR (exp
, 0) != XSTR (XEXP (*pterm
, 0), 0))
2911 if (! strcmp (XSTR (exp
, 1), XSTR (XEXP (*pterm
, 0), 1)))
2917 else if (GET_CODE (exp
) == NOT
&& GET_CODE (*pterm
) == NOT
)
2919 if (attr_equal_p (XEXP (exp
, 0), XEXP (*pterm
, 0)))
2923 else if (GET_CODE (exp
) == NOT
)
2925 if (attr_equal_p (XEXP (exp
, 0), *pterm
))
2929 else if (GET_CODE (*pterm
) == NOT
)
2931 if (attr_equal_p (XEXP (*pterm
, 0), exp
))
2935 else if (attr_equal_p (exp
, *pterm
))
2941 /* Similar to `simplify_and_tree', but for IOR trees. */
2944 simplify_or_tree (exp
, pterm
, insn_code
, insn_index
)
2947 int insn_code
, insn_index
;
2952 int left_eliminates_term
, right_eliminates_term
;
2954 if (GET_CODE (exp
) == IOR
)
2956 left
= simplify_or_tree (XEXP (exp
, 0), pterm
, insn_code
, insn_index
);
2957 right
= simplify_or_tree (XEXP (exp
, 1), pterm
, insn_code
, insn_index
);
2958 if (left
!= XEXP (exp
, 0) || right
!= XEXP (exp
, 1))
2960 newexp
= attr_rtx (GET_CODE (exp
), left
, right
);
2962 exp
= SIMPLIFY_TEST_EXP (newexp
, insn_code
, insn_index
);
2966 else if (GET_CODE (exp
) == AND
)
2968 /* For the AND case, we do the same as above, except that we can
2969 only eliminate `term' if both sides of the AND would do so. */
2971 left
= simplify_or_tree (XEXP (exp
, 0), &temp
, insn_code
, insn_index
);
2972 left_eliminates_term
= (temp
== false_rtx
);
2975 right
= simplify_or_tree (XEXP (exp
, 1), &temp
, insn_code
, insn_index
);
2976 right_eliminates_term
= (temp
== false_rtx
);
2978 if (left_eliminates_term
&& right_eliminates_term
)
2981 if (left
!= XEXP (exp
, 0) || right
!= XEXP (exp
, 1))
2983 newexp
= attr_rtx (GET_CODE (exp
), left
, right
);
2985 exp
= SIMPLIFY_TEST_EXP (newexp
, insn_code
, insn_index
);
2989 if (attr_equal_p (exp
, *pterm
))
2992 else if (GET_CODE (exp
) == NOT
&& attr_equal_p (XEXP (exp
, 0), *pterm
))
2995 else if (GET_CODE (*pterm
) == NOT
&& attr_equal_p (XEXP (*pterm
, 0), exp
))
2998 else if (GET_CODE (*pterm
) == EQ_ATTR
&& GET_CODE (exp
) == NOT
2999 && GET_CODE (XEXP (exp
, 0)) == EQ_ATTR
3000 && XSTR (*pterm
, 0) == XSTR (XEXP (exp
, 0), 0))
3003 else if (GET_CODE (exp
) == EQ_ATTR
&& GET_CODE (*pterm
) == NOT
3004 && GET_CODE (XEXP (*pterm
, 0)) == EQ_ATTR
3005 && XSTR (exp
, 0) == XSTR (XEXP (*pterm
, 0), 0))
3011 /* Given an expression, see if it can be simplified for a particular insn
3012 code based on the values of other attributes being tested. This can
3013 eliminate nested get_attr_... calls.
3015 Note that if an endless recursion is specified in the patterns, the
3016 optimization will loop. However, it will do so in precisely the cases where
3017 an infinite recursion loop could occur during compilation. It's better that
3021 simplify_test_exp (exp
, insn_code
, insn_index
)
3023 int insn_code
, insn_index
;
3026 struct attr_desc
*attr
;
3027 struct attr_value
*av
;
3028 struct insn_ent
*ie
;
3031 char *spacer
= (char *) obstack_finish (rtl_obstack
);
3033 /* Don't re-simplify something we already simplified. */
3034 if (RTX_UNCHANGING_P (exp
) || MEM_IN_STRUCT_P (exp
))
3037 switch (GET_CODE (exp
))
3040 left
= SIMPLIFY_TEST_EXP (XEXP (exp
, 0), insn_code
, insn_index
);
3041 SIMPLIFY_ALTERNATIVE (left
);
3042 if (left
== false_rtx
)
3044 obstack_free (rtl_obstack
, spacer
);
3047 right
= SIMPLIFY_TEST_EXP (XEXP (exp
, 1), insn_code
, insn_index
);
3048 SIMPLIFY_ALTERNATIVE (right
);
3049 if (left
== false_rtx
)
3051 obstack_free (rtl_obstack
, spacer
);
3055 /* If either side is an IOR and we have (eq_attr "alternative" ..")
3056 present on both sides, apply the distributive law since this will
3057 yield simplifications. */
3058 if ((GET_CODE (left
) == IOR
|| GET_CODE (right
) == IOR
)
3059 && compute_alternative_mask (left
, IOR
)
3060 && compute_alternative_mask (right
, IOR
))
3062 if (GET_CODE (left
) == IOR
)
3069 newexp
= attr_rtx (IOR
,
3070 attr_rtx (AND
, left
, XEXP (right
, 0)),
3071 attr_rtx (AND
, left
, XEXP (right
, 1)));
3073 return SIMPLIFY_TEST_EXP (newexp
, insn_code
, insn_index
);
3076 /* Try with the term on both sides. */
3077 right
= simplify_and_tree (right
, &left
, insn_code
, insn_index
);
3078 if (left
== XEXP (exp
, 0) && right
== XEXP (exp
, 1))
3079 left
= simplify_and_tree (left
, &right
, insn_code
, insn_index
);
3081 if (left
== false_rtx
|| right
== false_rtx
)
3083 obstack_free (rtl_obstack
, spacer
);
3086 else if (left
== true_rtx
)
3090 else if (right
== true_rtx
)
3094 /* See if all or all but one of the insn's alternatives are specified
3095 in this tree. Optimize if so. */
3097 else if (insn_code
>= 0
3098 && (GET_CODE (left
) == AND
3099 || (GET_CODE (left
) == NOT
3100 && GET_CODE (XEXP (left
, 0)) == EQ_ATTR
3101 && XSTR (XEXP (left
, 0), 0) == alternative_name
)
3102 || GET_CODE (right
) == AND
3103 || (GET_CODE (right
) == NOT
3104 && GET_CODE (XEXP (right
, 0)) == EQ_ATTR
3105 && XSTR (XEXP (right
, 0), 0) == alternative_name
)))
3107 i
= compute_alternative_mask (exp
, AND
);
3108 if (i
& ~insn_alternatives
[insn_code
])
3109 fatal ("Invalid alternative specified for pattern number %d",
3112 /* If all alternatives are excluded, this is false. */
3113 i
^= insn_alternatives
[insn_code
];
3116 else if ((i
& (i
- 1)) == 0 && insn_alternatives
[insn_code
] > 1)
3118 /* If just one excluded, AND a comparison with that one to the
3119 front of the tree. The others will be eliminated by
3120 optimization. We do not want to do this if the insn has one
3121 alternative and we have tested none of them! */
3122 left
= make_alternative_compare (i
);
3123 right
= simplify_and_tree (exp
, &left
, insn_code
, insn_index
);
3124 newexp
= attr_rtx (AND
, left
, right
);
3126 return SIMPLIFY_TEST_EXP (newexp
, insn_code
, insn_index
);
3130 if (left
!= XEXP (exp
, 0) || right
!= XEXP (exp
, 1))
3132 newexp
= attr_rtx (AND
, left
, right
);
3133 return SIMPLIFY_TEST_EXP (newexp
, insn_code
, insn_index
);
3138 left
= SIMPLIFY_TEST_EXP (XEXP (exp
, 0), insn_code
, insn_index
);
3139 SIMPLIFY_ALTERNATIVE (left
);
3140 if (left
== true_rtx
)
3142 obstack_free (rtl_obstack
, spacer
);
3145 right
= SIMPLIFY_TEST_EXP (XEXP (exp
, 1), insn_code
, insn_index
);
3146 SIMPLIFY_ALTERNATIVE (right
);
3147 if (right
== true_rtx
)
3149 obstack_free (rtl_obstack
, spacer
);
3153 right
= simplify_or_tree (right
, &left
, insn_code
, insn_index
);
3154 if (left
== XEXP (exp
, 0) && right
== XEXP (exp
, 1))
3155 left
= simplify_or_tree (left
, &right
, insn_code
, insn_index
);
3157 if (right
== true_rtx
|| left
== true_rtx
)
3159 obstack_free (rtl_obstack
, spacer
);
3162 else if (left
== false_rtx
)
3166 else if (right
== false_rtx
)
3171 /* Test for simple cases where the distributive law is useful. I.e.,
3172 convert (ior (and (x) (y))
3178 else if (GET_CODE (left
) == AND
&& GET_CODE (right
) == AND
3179 && attr_equal_p (XEXP (left
, 0), XEXP (right
, 0)))
3181 newexp
= attr_rtx (IOR
, XEXP (left
, 1), XEXP (right
, 1));
3183 left
= XEXP (left
, 0);
3185 newexp
= attr_rtx (AND
, left
, right
);
3186 return SIMPLIFY_TEST_EXP (newexp
, insn_code
, insn_index
);
3189 /* See if all or all but one of the insn's alternatives are specified
3190 in this tree. Optimize if so. */
3192 else if (insn_code
>= 0
3193 && (GET_CODE (left
) == IOR
3194 || (GET_CODE (left
) == EQ_ATTR
3195 && XSTR (left
, 0) == alternative_name
)
3196 || GET_CODE (right
) == IOR
3197 || (GET_CODE (right
) == EQ_ATTR
3198 && XSTR (right
, 0) == alternative_name
)))
3200 i
= compute_alternative_mask (exp
, IOR
);
3201 if (i
& ~insn_alternatives
[insn_code
])
3202 fatal ("Invalid alternative specified for pattern number %d",
3205 /* If all alternatives are included, this is true. */
3206 i
^= insn_alternatives
[insn_code
];
3209 else if ((i
& (i
- 1)) == 0 && insn_alternatives
[insn_code
] > 1)
3211 /* If just one excluded, IOR a comparison with that one to the
3212 front of the tree. The others will be eliminated by
3213 optimization. We do not want to do this if the insn has one
3214 alternative and we have tested none of them! */
3215 left
= make_alternative_compare (i
);
3216 right
= simplify_and_tree (exp
, &left
, insn_code
, insn_index
);
3217 newexp
= attr_rtx (IOR
, attr_rtx (NOT
, left
), right
);
3219 return SIMPLIFY_TEST_EXP (newexp
, insn_code
, insn_index
);
3223 if (left
!= XEXP (exp
, 0) || right
!= XEXP (exp
, 1))
3225 newexp
= attr_rtx (IOR
, left
, right
);
3226 return SIMPLIFY_TEST_EXP (newexp
, insn_code
, insn_index
);
3231 if (GET_CODE (XEXP (exp
, 0)) == NOT
)
3233 left
= SIMPLIFY_TEST_EXP (XEXP (XEXP (exp
, 0), 0),
3234 insn_code
, insn_index
);
3235 SIMPLIFY_ALTERNATIVE (left
);
3239 left
= SIMPLIFY_TEST_EXP (XEXP (exp
, 0), insn_code
, insn_index
);
3240 SIMPLIFY_ALTERNATIVE (left
);
3241 if (GET_CODE (left
) == NOT
)
3242 return XEXP (left
, 0);
3244 if (left
== false_rtx
)
3246 obstack_free (rtl_obstack
, spacer
);
3249 else if (left
== true_rtx
)
3251 obstack_free (rtl_obstack
, spacer
);
3255 /* Try to apply De`Morgan's laws. */
3256 else if (GET_CODE (left
) == IOR
)
3258 newexp
= attr_rtx (AND
,
3259 attr_rtx (NOT
, XEXP (left
, 0)),
3260 attr_rtx (NOT
, XEXP (left
, 1)));
3262 newexp
= SIMPLIFY_TEST_EXP (newexp
, insn_code
, insn_index
);
3264 else if (GET_CODE (left
) == AND
)
3266 newexp
= attr_rtx (IOR
,
3267 attr_rtx (NOT
, XEXP (left
, 0)),
3268 attr_rtx (NOT
, XEXP (left
, 1)));
3270 newexp
= SIMPLIFY_TEST_EXP (newexp
, insn_code
, insn_index
);
3272 else if (left
!= XEXP (exp
, 0))
3274 newexp
= attr_rtx (NOT
, left
);
3279 if (current_alternative_string
&& XSTR (exp
, 0) == alternative_name
)
3280 return (XSTR (exp
, 1) == current_alternative_string
3281 ? true_rtx
: false_rtx
);
3283 /* Look at the value for this insn code in the specified attribute.
3284 We normally can replace this comparison with the condition that
3285 would give this insn the values being tested for. */
3286 if (XSTR (exp
, 0) != alternative_name
3287 && (attr
= find_attr (XSTR (exp
, 0), 0)) != NULL
)
3288 for (av
= attr
->first_value
; av
; av
= av
->next
)
3289 for (ie
= av
->first_insn
; ie
; ie
= ie
->next
)
3290 if (ie
->insn_code
== insn_code
)
3291 return evaluate_eq_attr (exp
, av
->value
, insn_code
, insn_index
);
3298 /* We have already simplified this expression. Simplifying it again
3299 won't buy anything unless we weren't given a valid insn code
3300 to process (i.e., we are canonicalizing something.). */
3301 if (insn_code
!= -2 /* Seems wrong: && current_alternative_string. */
3302 && ! RTX_UNCHANGING_P (newexp
))
3303 return copy_rtx_unchanging (newexp
);
3308 /* Optimize the attribute lists by seeing if we can determine conditional
3309 values from the known values of other attributes. This will save subroutine
3310 calls during the compilation. */
3315 struct attr_desc
*attr
;
3316 struct attr_value
*av
;
3317 struct insn_ent
*ie
;
3319 int something_changed
= 1;
3321 struct attr_value_list
{ struct attr_value
*av
;
3322 struct insn_ent
*ie
;
3323 struct attr_desc
* attr
;
3324 struct attr_value_list
*next
; };
3325 struct attr_value_list
**insn_code_values
;
3326 struct attr_value_list
*ivbuf
;
3327 struct attr_value_list
*iv
;
3329 /* For each insn code, make a list of all the insn_ent's for it,
3330 for all values for all attributes. */
3332 if (num_insn_ents
== 0)
3335 /* Make 2 extra elements, for "code" values -2 and -1. */
3337 = (struct attr_value_list
**) alloca ((insn_code_number
+ 2)
3338 * sizeof (struct attr_value_list
*));
3339 bzero ((char *) insn_code_values
,
3340 (insn_code_number
+ 2) * sizeof (struct attr_value_list
*));
3342 /* Offset the table address so we can index by -2 or -1. */
3343 insn_code_values
+= 2;
3345 /* Allocate the attr_value_list structures using xmalloc rather than
3346 alloca, because using alloca can overflow the maximum permitted
3347 stack limit on SPARC Lynx. */
3348 iv
= ivbuf
= ((struct attr_value_list
*)
3349 xmalloc (num_insn_ents
* sizeof (struct attr_value_list
)));
3351 for (i
= 0; i
< MAX_ATTRS_INDEX
; i
++)
3352 for (attr
= attrs
[i
]; attr
; attr
= attr
->next
)
3353 for (av
= attr
->first_value
; av
; av
= av
->next
)
3354 for (ie
= av
->first_insn
; ie
; ie
= ie
->next
)
3359 iv
->next
= insn_code_values
[ie
->insn_code
];
3360 insn_code_values
[ie
->insn_code
] = iv
;
3364 /* Sanity check on num_insn_ents. */
3365 if (iv
!= ivbuf
+ num_insn_ents
)
3368 /* Process one insn code at a time. */
3369 for (i
= -2; i
< insn_code_number
; i
++)
3371 /* Clear the MEM_IN_STRUCT_P flag everywhere relevant.
3372 We use it to mean "already simplified for this insn". */
3373 for (iv
= insn_code_values
[i
]; iv
; iv
= iv
->next
)
3374 clear_struct_flag (iv
->av
->value
);
3376 /* Loop until nothing changes for one iteration. */
3377 something_changed
= 1;
3378 while (something_changed
)
3380 something_changed
= 0;
3381 for (iv
= insn_code_values
[i
]; iv
; iv
= iv
->next
)
3383 struct obstack
*old
= rtl_obstack
;
3384 char *spacer
= (char *) obstack_finish (temp_obstack
);
3389 if (GET_CODE (av
->value
) != COND
)
3392 rtl_obstack
= temp_obstack
;
3393 #if 0 /* This was intended as a speed up, but it was slower. */
3394 if (insn_n_alternatives
[ie
->insn_code
] > 6
3395 && count_sub_rtxs (av
->value
, 200) >= 200)
3396 newexp
= simplify_by_alternatives (av
->value
, ie
->insn_code
,
3400 newexp
= simplify_cond (av
->value
, ie
->insn_code
,
3404 if (newexp
!= av
->value
)
3406 newexp
= attr_copy_rtx (newexp
);
3407 remove_insn_ent (av
, ie
);
3408 av
= get_attr_value (newexp
, attr
, ie
->insn_code
);
3410 insert_insn_ent (av
, ie
);
3411 something_changed
= 1;
3413 obstack_free (temp_obstack
, spacer
);
3423 simplify_by_alternatives (exp
, insn_code
, insn_index
)
3425 int insn_code
, insn_index
;
3428 int len
= insn_n_alternatives
[insn_code
];
3429 rtx newexp
= rtx_alloc (COND
);
3433 XVEC (newexp
, 0) = rtvec_alloc (len
* 2);
3435 /* It will not matter what value we use as the default value
3436 of the new COND, since that default will never be used.
3437 Choose something of the right type. */
3438 for (ultimate
= exp
; GET_CODE (ultimate
) == COND
;)
3439 ultimate
= XEXP (ultimate
, 1);
3440 XEXP (newexp
, 1) = ultimate
;
3442 for (i
= 0; i
< insn_n_alternatives
[insn_code
]; i
++)
3444 current_alternative_string
= attr_numeral (i
);
3445 XVECEXP (newexp
, 0, i
* 2) = make_alternative_compare (1 << i
);
3446 XVECEXP (newexp
, 0, i
* 2 + 1)
3447 = simplify_cond (exp
, insn_code
, insn_index
);
3450 current_alternative_string
= 0;
3451 return simplify_cond (newexp
, insn_code
, insn_index
);
3455 /* If EXP is a suitable expression, reorganize it by constructing an
3456 equivalent expression that is a COND with the tests being all combinations
3457 of attribute values and the values being simple constants. */
3460 simplify_by_exploding (exp
)
3463 rtx list
= 0, link
, condexp
, defval
;
3464 struct dimension
*space
;
3465 rtx
*condtest
, *condval
;
3466 int i
, j
, total
, ndim
= 0;
3467 int most_tests
, num_marks
, new_marks
;
3469 /* Locate all the EQ_ATTR expressions. */
3470 if (! find_and_mark_used_attributes (exp
, &list
, &ndim
) || ndim
== 0)
3472 unmark_used_attributes (list
, 0, 0);
3476 /* Create an attribute space from the list of used attributes. For each
3477 dimension in the attribute space, record the attribute, list of values
3478 used, and number of values used. Add members to the list of values to
3479 cover the domain of the attribute. This makes the expanded COND form
3480 order independent. */
3482 space
= (struct dimension
*) alloca (ndim
* sizeof (struct dimension
));
3485 for (ndim
= 0; list
; ndim
++)
3487 /* Pull the first attribute value from the list and record that
3488 attribute as another dimension in the attribute space. */
3489 char *name
= XSTR (XEXP (list
, 0), 0);
3492 if ((space
[ndim
].attr
= find_attr (name
, 0)) == 0
3493 || space
[ndim
].attr
->is_numeric
)
3495 unmark_used_attributes (list
, space
, ndim
);
3499 /* Add all remaining attribute values that refer to this attribute. */
3500 space
[ndim
].num_values
= 0;
3501 space
[ndim
].values
= 0;
3503 for (link
= list
; link
; link
= *prev
)
3504 if (! strcmp (XSTR (XEXP (link
, 0), 0), name
))
3506 space
[ndim
].num_values
++;
3507 *prev
= XEXP (link
, 1);
3508 XEXP (link
, 1) = space
[ndim
].values
;
3509 space
[ndim
].values
= link
;
3512 prev
= &XEXP (link
, 1);
3514 /* Add sufficient members to the list of values to make the list
3515 mutually exclusive and record the total size of the attribute
3517 total
*= add_values_to_cover (&space
[ndim
]);
3520 /* Sort the attribute space so that the attributes go from non-constant
3521 to constant and from most values to least values. */
3522 for (i
= 0; i
< ndim
; i
++)
3523 for (j
= ndim
- 1; j
> i
; j
--)
3524 if ((space
[j
-1].attr
->is_const
&& !space
[j
].attr
->is_const
)
3525 || space
[j
-1].num_values
< space
[j
].num_values
)
3527 struct dimension tmp
;
3529 space
[j
] = space
[j
-1];
3533 /* Establish the initial current value. */
3534 for (i
= 0; i
< ndim
; i
++)
3535 space
[i
].current_value
= space
[i
].values
;
3537 condtest
= (rtx
*) alloca (total
* sizeof (rtx
));
3538 condval
= (rtx
*) alloca (total
* sizeof (rtx
));
3540 /* Expand the tests and values by iterating over all values in the
3544 condtest
[i
] = test_for_current_value (space
, ndim
);
3545 condval
[i
] = simplify_with_current_value (exp
, space
, ndim
);
3546 if (! increment_current_value (space
, ndim
))
3552 /* We are now finished with the original expression. */
3553 unmark_used_attributes (0, space
, ndim
);
3555 /* Find the most used constant value and make that the default. */
3557 for (i
= num_marks
= 0; i
< total
; i
++)
3558 if (GET_CODE (condval
[i
]) == CONST_STRING
3559 && ! MEM_VOLATILE_P (condval
[i
]))
3561 /* Mark the unmarked constant value and count how many are marked. */
3562 MEM_VOLATILE_P (condval
[i
]) = 1;
3563 for (j
= new_marks
= 0; j
< total
; j
++)
3564 if (GET_CODE (condval
[j
]) == CONST_STRING
3565 && MEM_VOLATILE_P (condval
[j
]))
3567 if (new_marks
- num_marks
> most_tests
)
3569 most_tests
= new_marks
- num_marks
;
3570 defval
= condval
[i
];
3572 num_marks
= new_marks
;
3574 /* Clear all the marks. */
3575 for (i
= 0; i
< total
; i
++)
3576 MEM_VOLATILE_P (condval
[i
]) = 0;
3578 /* Give up if nothing is constant. */
3582 /* If all values are the default, use that. */
3583 if (total
== most_tests
)
3586 /* Make a COND with the most common constant value the default. (A more
3587 complex method where tests with the same value were combined didn't
3588 seem to improve things.) */
3589 condexp
= rtx_alloc (COND
);
3590 XVEC (condexp
, 0) = rtvec_alloc ((total
- most_tests
) * 2);
3591 XEXP (condexp
, 1) = defval
;
3592 for (i
= j
= 0; i
< total
; i
++)
3593 if (condval
[i
] != defval
)
3595 XVECEXP (condexp
, 0, 2 * j
) = condtest
[i
];
3596 XVECEXP (condexp
, 0, 2 * j
+ 1) = condval
[i
];
3603 /* Set the MEM_VOLATILE_P flag for all EQ_ATTR expressions in EXP and
3604 verify that EXP can be simplified to a constant term if all the EQ_ATTR
3605 tests have known value. */
3608 find_and_mark_used_attributes (exp
, terms
, nterms
)
3614 switch (GET_CODE (exp
))
3617 if (! MEM_VOLATILE_P (exp
))
3619 rtx link
= rtx_alloc (EXPR_LIST
);
3620 XEXP (link
, 0) = exp
;
3621 XEXP (link
, 1) = *terms
;
3624 MEM_VOLATILE_P (exp
) = 1;
3630 if (! find_and_mark_used_attributes (XEXP (exp
, 2), terms
, nterms
))
3634 if (! find_and_mark_used_attributes (XEXP (exp
, 1), terms
, nterms
))
3637 if (! find_and_mark_used_attributes (XEXP (exp
, 0), terms
, nterms
))
3642 for (i
= 0; i
< XVECLEN (exp
, 0); i
++)
3643 if (! find_and_mark_used_attributes (XVECEXP (exp
, 0, i
), terms
, nterms
))
3645 if (! find_and_mark_used_attributes (XEXP (exp
, 1), terms
, nterms
))
3654 /* Clear the MEM_VOLATILE_P flag in all EQ_ATTR expressions on LIST and
3655 in the values of the NDIM-dimensional attribute space SPACE. */
3658 unmark_used_attributes (list
, space
, ndim
)
3660 struct dimension
*space
;
3666 for (i
= 0; i
< ndim
; i
++)
3667 unmark_used_attributes (space
[i
].values
, 0, 0);
3669 for (link
= list
; link
; link
= XEXP (link
, 1))
3671 exp
= XEXP (link
, 0);
3672 if (GET_CODE (exp
) == EQ_ATTR
)
3673 MEM_VOLATILE_P (exp
) = 0;
3677 /* Update the attribute dimension DIM so that all values of the attribute
3678 are tested. Return the updated number of values. */
3681 add_values_to_cover (dim
)
3682 struct dimension
*dim
;
3684 struct attr_value
*av
;
3685 rtx exp
, link
, *prev
;
3688 for (av
= dim
->attr
->first_value
; av
; av
= av
->next
)
3689 if (GET_CODE (av
->value
) == CONST_STRING
)
3692 if (nalt
< dim
->num_values
)
3694 else if (nalt
== dim
->num_values
)
3696 else if (nalt
* 2 < dim
->num_values
* 3)
3698 /* Most all the values of the attribute are used, so add all the unused
3700 prev
= &dim
->values
;
3701 for (link
= dim
->values
; link
; link
= *prev
)
3702 prev
= &XEXP (link
, 1);
3704 for (av
= dim
->attr
->first_value
; av
; av
= av
->next
)
3705 if (GET_CODE (av
->value
) == CONST_STRING
)
3707 exp
= attr_eq (dim
->attr
->name
, XSTR (av
->value
, 0));
3708 if (MEM_VOLATILE_P (exp
))
3711 link
= rtx_alloc (EXPR_LIST
);
3712 XEXP (link
, 0) = exp
;
3715 prev
= &XEXP (link
, 1);
3717 dim
->num_values
= nalt
;
3721 rtx orexp
= false_rtx
;
3723 /* Very few values are used, so compute a mutually exclusive
3724 expression. (We could do this for numeric values if that becomes
3726 prev
= &dim
->values
;
3727 for (link
= dim
->values
; link
; link
= *prev
)
3729 orexp
= insert_right_side (IOR
, orexp
, XEXP (link
, 0), -2, -2);
3730 prev
= &XEXP (link
, 1);
3732 link
= rtx_alloc (EXPR_LIST
);
3733 XEXP (link
, 0) = attr_rtx (NOT
, orexp
);
3738 return dim
->num_values
;
3741 /* Increment the current value for the NDIM-dimensional attribute space SPACE
3742 and return FALSE if the increment overflowed. */
3745 increment_current_value (space
, ndim
)
3746 struct dimension
*space
;
3751 for (i
= ndim
- 1; i
>= 0; i
--)
3753 if ((space
[i
].current_value
= XEXP (space
[i
].current_value
, 1)) == 0)
3754 space
[i
].current_value
= space
[i
].values
;
3761 /* Construct an expression corresponding to the current value for the
3762 NDIM-dimensional attribute space SPACE. */
3765 test_for_current_value (space
, ndim
)
3766 struct dimension
*space
;
3772 for (i
= 0; i
< ndim
; i
++)
3773 exp
= insert_right_side (AND
, exp
, XEXP (space
[i
].current_value
, 0),
3779 /* Given the current value of the NDIM-dimensional attribute space SPACE,
3780 set the corresponding EQ_ATTR expressions to that value and reduce
3781 the expression EXP as much as possible. On input [and output], all
3782 known EQ_ATTR expressions are set to FALSE. */
3785 simplify_with_current_value (exp
, space
, ndim
)
3787 struct dimension
*space
;
3793 /* Mark each current value as TRUE. */
3794 for (i
= 0; i
< ndim
; i
++)
3796 x
= XEXP (space
[i
].current_value
, 0);
3797 if (GET_CODE (x
) == EQ_ATTR
)
3798 MEM_VOLATILE_P (x
) = 0;
3801 exp
= simplify_with_current_value_aux (exp
);
3803 /* Change each current value back to FALSE. */
3804 for (i
= 0; i
< ndim
; i
++)
3806 x
= XEXP (space
[i
].current_value
, 0);
3807 if (GET_CODE (x
) == EQ_ATTR
)
3808 MEM_VOLATILE_P (x
) = 1;
3814 /* Reduce the expression EXP based on the MEM_VOLATILE_P settings of
3815 all EQ_ATTR expressions. */
3818 simplify_with_current_value_aux (exp
)
3824 switch (GET_CODE (exp
))
3827 if (MEM_VOLATILE_P (exp
))
3835 cond
= simplify_with_current_value_aux (XEXP (exp
, 0));
3836 if (cond
== true_rtx
)
3837 return simplify_with_current_value_aux (XEXP (exp
, 1));
3838 else if (cond
== false_rtx
)
3839 return simplify_with_current_value_aux (XEXP (exp
, 2));
3841 return attr_rtx (IF_THEN_ELSE
, cond
,
3842 simplify_with_current_value_aux (XEXP (exp
, 1)),
3843 simplify_with_current_value_aux (XEXP (exp
, 2)));
3846 cond
= simplify_with_current_value_aux (XEXP (exp
, 1));
3847 if (cond
== true_rtx
)
3849 else if (cond
== false_rtx
)
3850 return simplify_with_current_value_aux (XEXP (exp
, 0));
3852 return attr_rtx (IOR
, cond
,
3853 simplify_with_current_value_aux (XEXP (exp
, 0)));
3856 cond
= simplify_with_current_value_aux (XEXP (exp
, 1));
3857 if (cond
== true_rtx
)
3858 return simplify_with_current_value_aux (XEXP (exp
, 0));
3859 else if (cond
== false_rtx
)
3862 return attr_rtx (AND
, cond
,
3863 simplify_with_current_value_aux (XEXP (exp
, 0)));
3866 cond
= simplify_with_current_value_aux (XEXP (exp
, 0));
3867 if (cond
== true_rtx
)
3869 else if (cond
== false_rtx
)
3872 return attr_rtx (NOT
, cond
);
3875 for (i
= 0; i
< XVECLEN (exp
, 0); i
+= 2)
3877 cond
= simplify_with_current_value_aux (XVECEXP (exp
, 0, i
));
3878 if (cond
== true_rtx
)
3879 return simplify_with_current_value_aux (XVECEXP (exp
, 0, i
+ 1));
3880 else if (cond
== false_rtx
)
3883 abort (); /* With all EQ_ATTR's of known value, a case should
3884 have been selected. */
3886 return simplify_with_current_value_aux (XEXP (exp
, 1));
3893 /* Clear the MEM_IN_STRUCT_P flag in EXP and its subexpressions. */
3896 clear_struct_flag (x
)
3901 register enum rtx_code code
;
3904 MEM_IN_STRUCT_P (x
) = 0;
3905 if (RTX_UNCHANGING_P (x
))
3908 code
= GET_CODE (x
);
3928 /* Compare the elements. If any pair of corresponding elements
3929 fail to match, return 0 for the whole things. */
3931 fmt
= GET_RTX_FORMAT (code
);
3932 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
3938 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
3939 clear_struct_flag (XVECEXP (x
, i
, j
));
3943 clear_struct_flag (XEXP (x
, i
));
3949 /* Return the number of RTX objects making up the expression X.
3950 But if we count more more than MAX objects, stop counting. */
3953 count_sub_rtxs (x
, max
)
3959 register enum rtx_code code
;
3963 code
= GET_CODE (x
);
3983 /* Compare the elements. If any pair of corresponding elements
3984 fail to match, return 0 for the whole things. */
3986 fmt
= GET_RTX_FORMAT (code
);
3987 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
3996 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
3997 total
+= count_sub_rtxs (XVECEXP (x
, i
, j
), max
);
4001 total
+= count_sub_rtxs (XEXP (x
, i
), max
);
4009 /* Create table entries for DEFINE_ATTR. */
4015 struct attr_desc
*attr
;
4016 struct attr_value
*av
;
4020 /* Make a new attribute structure. Check for duplicate by looking at
4021 attr->default_val, since it is initialized by this routine. */
4022 attr
= find_attr (XSTR (exp
, 0), 1);
4023 if (attr
->default_val
)
4024 fatal ("Duplicate definition for `%s' attribute", attr
->name
);
4026 if (*XSTR (exp
, 1) == '\0')
4027 attr
->is_numeric
= 1;
4030 name_ptr
= XSTR (exp
, 1);
4031 while ((p
= next_comma_elt (&name_ptr
)) != NULL
)
4033 av
= (struct attr_value
*) oballoc (sizeof (struct attr_value
));
4034 av
->value
= attr_rtx (CONST_STRING
, p
);
4035 av
->next
= attr
->first_value
;
4036 attr
->first_value
= av
;
4037 av
->first_insn
= NULL
;
4039 av
->has_asm_insn
= 0;
4043 if (GET_CODE (XEXP (exp
, 2)) == CONST
)
4046 if (attr
->is_numeric
)
4047 fatal ("Constant attributes may not take numeric values");
4048 /* Get rid of the CONST node. It is allowed only at top-level. */
4049 XEXP (exp
, 2) = XEXP (XEXP (exp
, 2), 0);
4052 if (! strcmp (attr
->name
, "length") && ! attr
->is_numeric
)
4053 fatal ("`length' attribute must take numeric values");
4055 /* Set up the default value. */
4056 XEXP (exp
, 2) = check_attr_value (XEXP (exp
, 2), attr
);
4057 attr
->default_val
= get_attr_value (XEXP (exp
, 2), attr
, -2);
4060 /* Given a pattern for DEFINE_PEEPHOLE or DEFINE_INSN, return the number of
4061 alternatives in the constraints. Assume all MATCH_OPERANDs have the same
4062 number of alternatives as this should be checked elsewhere. */
4065 count_alternatives (exp
)
4071 if (GET_CODE (exp
) == MATCH_OPERAND
)
4072 return n_comma_elts (XSTR (exp
, 2));
4074 for (i
= 0, fmt
= GET_RTX_FORMAT (GET_CODE (exp
));
4075 i
< GET_RTX_LENGTH (GET_CODE (exp
)); i
++)
4080 n
= count_alternatives (XEXP (exp
, i
));
4087 if (XVEC (exp
, i
) != NULL
)
4088 for (j
= 0; j
< XVECLEN (exp
, i
); j
++)
4090 n
= count_alternatives (XVECEXP (exp
, i
, j
));
4099 /* Returns non-zero if the given expression contains an EQ_ATTR with the
4100 `alternative' attribute. */
4103 compares_alternatives_p (exp
)
4109 if (GET_CODE (exp
) == EQ_ATTR
&& XSTR (exp
, 0) == alternative_name
)
4112 for (i
= 0, fmt
= GET_RTX_FORMAT (GET_CODE (exp
));
4113 i
< GET_RTX_LENGTH (GET_CODE (exp
)); i
++)
4118 if (compares_alternatives_p (XEXP (exp
, i
)))
4123 for (j
= 0; j
< XVECLEN (exp
, i
); j
++)
4124 if (compares_alternatives_p (XVECEXP (exp
, i
, j
)))
4132 /* Returns non-zero is INNER is contained in EXP. */
4135 contained_in_p (inner
, exp
)
4142 if (rtx_equal_p (inner
, exp
))
4145 for (i
= 0, fmt
= GET_RTX_FORMAT (GET_CODE (exp
));
4146 i
< GET_RTX_LENGTH (GET_CODE (exp
)); i
++)
4151 if (contained_in_p (inner
, XEXP (exp
, i
)))
4156 for (j
= 0; j
< XVECLEN (exp
, i
); j
++)
4157 if (contained_in_p (inner
, XVECEXP (exp
, i
, j
)))
4165 /* Process DEFINE_PEEPHOLE, DEFINE_INSN, and DEFINE_ASM_ATTRIBUTES. */
4171 struct insn_def
*id
;
4173 id
= (struct insn_def
*) oballoc (sizeof (struct insn_def
));
4178 switch (GET_CODE (exp
))
4181 id
->insn_code
= insn_code_number
++;
4182 id
->insn_index
= insn_index_number
++;
4183 id
->num_alternatives
= count_alternatives (exp
);
4184 if (id
->num_alternatives
== 0)
4185 id
->num_alternatives
= 1;
4189 case DEFINE_PEEPHOLE
:
4190 id
->insn_code
= insn_code_number
++;
4191 id
->insn_index
= insn_index_number
++;
4192 id
->num_alternatives
= count_alternatives (exp
);
4193 if (id
->num_alternatives
== 0)
4194 id
->num_alternatives
= 1;
4198 case DEFINE_ASM_ATTRIBUTES
:
4200 id
->insn_index
= -1;
4201 id
->num_alternatives
= 1;
4203 got_define_asm_attributes
= 1;
4211 /* Process a DEFINE_DELAY. Validate the vector length, check if annul
4212 true or annul false is specified, and make a `struct delay_desc'. */
4218 struct delay_desc
*delay
;
4221 if (XVECLEN (def
, 1) % 3 != 0)
4222 fatal ("Number of elements in DEFINE_DELAY must be multiple of three.");
4224 for (i
= 0; i
< XVECLEN (def
, 1); i
+= 3)
4226 if (XVECEXP (def
, 1, i
+ 1))
4227 have_annul_true
= 1;
4228 if (XVECEXP (def
, 1, i
+ 2))
4229 have_annul_false
= 1;
4232 delay
= (struct delay_desc
*) oballoc (sizeof (struct delay_desc
));
4234 delay
->num
= ++num_delays
;
4235 delay
->next
= delays
;
4239 /* Process a DEFINE_FUNCTION_UNIT.
4241 This gives information about a function unit contained in the CPU.
4242 We fill in a `struct function_unit_op' and a `struct function_unit'
4243 with information used later by `expand_unit'. */
4249 struct function_unit
*unit
;
4250 struct function_unit_op
*op
;
4251 char *name
= XSTR (def
, 0);
4252 int multiplicity
= XINT (def
, 1);
4253 int simultaneity
= XINT (def
, 2);
4254 rtx condexp
= XEXP (def
, 3);
4255 int ready_cost
= MAX (XINT (def
, 4), 1);
4256 int issue_delay
= MAX (XINT (def
, 5), 1);
4258 /* See if we have already seen this function unit. If so, check that
4259 the multiplicity and simultaneity values are the same. If not, make
4260 a structure for this function unit. */
4261 for (unit
= units
; unit
; unit
= unit
->next
)
4262 if (! strcmp (unit
->name
, name
))
4264 if (unit
->multiplicity
!= multiplicity
4265 || unit
->simultaneity
!= simultaneity
)
4266 fatal ("Differing specifications given for `%s' function unit.",
4273 unit
= (struct function_unit
*) oballoc (sizeof (struct function_unit
));
4275 unit
->multiplicity
= multiplicity
;
4276 unit
->simultaneity
= simultaneity
;
4277 unit
->issue_delay
.min
= unit
->issue_delay
.max
= issue_delay
;
4278 unit
->num
= num_units
++;
4279 unit
->num_opclasses
= 0;
4280 unit
->condexp
= false_rtx
;
4286 /* Make a new operation class structure entry and initialize it. */
4287 op
= (struct function_unit_op
*) oballoc (sizeof (struct function_unit_op
));
4288 op
->condexp
= condexp
;
4289 op
->num
= unit
->num_opclasses
++;
4290 op
->ready
= ready_cost
;
4291 op
->issue_delay
= issue_delay
;
4292 op
->next
= unit
->ops
;
4295 /* Set our issue expression based on whether or not an optional conflict
4296 vector was specified. */
4299 /* Compute the IOR of all the specified expressions. */
4300 rtx orexp
= false_rtx
;
4303 for (i
= 0; i
< XVECLEN (def
, 6); i
++)
4304 orexp
= insert_right_side (IOR
, orexp
, XVECEXP (def
, 6, i
), -2, -2);
4306 op
->conflict_exp
= orexp
;
4307 extend_range (&unit
->issue_delay
, 1, issue_delay
);
4311 op
->conflict_exp
= true_rtx
;
4312 extend_range (&unit
->issue_delay
, issue_delay
, issue_delay
);
4315 /* Merge our conditional into that of the function unit so we can determine
4316 which insns are used by the function unit. */
4317 unit
->condexp
= insert_right_side (IOR
, unit
->condexp
, op
->condexp
, -2, -2);
4320 /* Given a piece of RTX, print a C expression to test it's truth value.
4321 We use AND and IOR both for logical and bit-wise operations, so
4322 interpret them as logical unless they are inside a comparison expression.
4323 The second operand of this function will be non-zero in that case. */
4326 write_test_expr (exp
, in_comparison
)
4330 int comparison_operator
= 0;
4332 struct attr_desc
*attr
;
4334 /* In order not to worry about operator precedence, surround our part of
4335 the expression with parentheses. */
4338 code
= GET_CODE (exp
);
4341 /* Binary operators. */
4343 case GE
: case GT
: case GEU
: case GTU
:
4344 case LE
: case LT
: case LEU
: case LTU
:
4345 comparison_operator
= 1;
4347 case PLUS
: case MINUS
: case MULT
: case DIV
: case MOD
:
4348 case AND
: case IOR
: case XOR
:
4349 case ASHIFT
: case LSHIFTRT
: case ASHIFTRT
:
4350 write_test_expr (XEXP (exp
, 0), in_comparison
|| comparison_operator
);
4366 printf (" >= (unsigned) ");
4369 printf (" > (unsigned) ");
4378 printf (" <= (unsigned) ");
4381 printf (" < (unsigned) ");
4424 write_test_expr (XEXP (exp
, 1), in_comparison
|| comparison_operator
);
4428 /* Special-case (not (eq_attrq "alternative" "x")) */
4429 if (! in_comparison
&& GET_CODE (XEXP (exp
, 0)) == EQ_ATTR
4430 && XSTR (XEXP (exp
, 0), 0) == alternative_name
)
4432 printf ("which_alternative != %s", XSTR (XEXP (exp
, 0), 1));
4436 /* Otherwise, fall through to normal unary operator. */
4438 /* Unary operators. */
4458 write_test_expr (XEXP (exp
, 0), in_comparison
);
4461 /* Comparison test of an attribute with a value. Most of these will
4462 have been removed by optimization. Handle "alternative"
4463 specially and give error if EQ_ATTR present inside a comparison. */
4466 fatal ("EQ_ATTR not valid inside comparison");
4468 if (XSTR (exp
, 0) == alternative_name
)
4470 printf ("which_alternative == %s", XSTR (exp
, 1));
4474 attr
= find_attr (XSTR (exp
, 0), 0);
4475 if (! attr
) abort ();
4477 /* Now is the time to expand the value of a constant attribute. */
4480 write_test_expr (evaluate_eq_attr (exp
, attr
->default_val
->value
,
4486 printf ("get_attr_%s (insn) == ", attr
->name
);
4487 write_attr_valueq (attr
, XSTR (exp
, 1));
4491 /* Comparison test of flags for define_delays. */
4494 fatal ("ATTR_FLAG not valid inside comparison");
4495 printf ("(flags & ATTR_FLAG_%s) != 0", XSTR (exp
, 0));
4498 /* See if an operand matches a predicate. */
4500 /* If only a mode is given, just ensure the mode matches the operand.
4501 If neither a mode nor predicate is given, error. */
4502 if (XSTR (exp
, 1) == NULL
|| *XSTR (exp
, 1) == '\0')
4504 if (GET_MODE (exp
) == VOIDmode
)
4505 fatal ("Null MATCH_OPERAND specified as test");
4507 printf ("GET_MODE (operands[%d]) == %smode",
4508 XINT (exp
, 0), GET_MODE_NAME (GET_MODE (exp
)));
4511 printf ("%s (operands[%d], %smode)",
4512 XSTR (exp
, 1), XINT (exp
, 0), GET_MODE_NAME (GET_MODE (exp
)));
4515 /* Constant integer. */
4517 #if HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_INT
4518 printf ("%d", XWINT (exp
, 0));
4520 printf ("%ld", XWINT (exp
, 0));
4524 /* A random C expression. */
4526 printf ("%s", XSTR (exp
, 0));
4529 /* The address of the branch target. */
4531 printf ("insn_addresses[INSN_UID (GET_CODE (operands[%d]) == LABEL_REF ? XEXP (operands[%d], 0) : operands[%d])]",
4532 XINT (exp
, 0), XINT (exp
, 0), XINT (exp
, 0));
4535 /* The address of the current insn. It would be more consistent with
4536 other usage to make this the address of the NEXT insn, but this gets
4537 too confusing because of the ambiguity regarding the length of the
4540 printf ("insn_current_address");
4544 fatal ("bad RTX code `%s' in attribute calculation\n",
4545 GET_RTX_NAME (code
));
4551 /* Given an attribute value, return the maximum CONST_STRING argument
4552 encountered. It is assumed that they are all numeric. */
4555 max_attr_value (exp
)
4558 int current_max
= 0;
4562 if (GET_CODE (exp
) == CONST_STRING
)
4563 return atoi (XSTR (exp
, 0));
4565 else if (GET_CODE (exp
) == COND
)
4567 for (i
= 0; i
< XVECLEN (exp
, 0); i
+= 2)
4569 n
= max_attr_value (XVECEXP (exp
, 0, i
+ 1));
4570 if (n
> current_max
)
4574 n
= max_attr_value (XEXP (exp
, 1));
4575 if (n
> current_max
)
4579 else if (GET_CODE (exp
) == IF_THEN_ELSE
)
4581 current_max
= max_attr_value (XEXP (exp
, 1));
4582 n
= max_attr_value (XEXP (exp
, 2));
4583 if (n
> current_max
)
4593 /* Scan an attribute value, possibly a conditional, and record what actions
4594 will be required to do any conditional tests in it.
4597 `must_extract' if we need to extract the insn operands
4598 `must_constrain' if we must compute `which_alternative'
4599 `address_used' if an address expression was used
4600 `length_used' if an (eq_attr "length" ...) was used
4604 walk_attr_value (exp
)
4614 code
= GET_CODE (exp
);
4618 if (! RTX_UNCHANGING_P (exp
))
4619 /* Since this is an arbitrary expression, it can look at anything.
4620 However, constant expressions do not depend on any particular
4622 must_extract
= must_constrain
= 1;
4630 if (XSTR (exp
, 0) == alternative_name
)
4631 must_extract
= must_constrain
= 1;
4632 else if (strcmp (XSTR (exp
, 0), "length") == 0)
4652 for (i
= 0, fmt
= GET_RTX_FORMAT (code
); i
< GET_RTX_LENGTH (code
); i
++)
4657 walk_attr_value (XEXP (exp
, i
));
4661 if (XVEC (exp
, i
) != NULL
)
4662 for (j
= 0; j
< XVECLEN (exp
, i
); j
++)
4663 walk_attr_value (XVECEXP (exp
, i
, j
));
4668 /* Write out a function to obtain the attribute for a given INSN. */
4671 write_attr_get (attr
)
4672 struct attr_desc
*attr
;
4674 struct attr_value
*av
, *common_av
;
4676 /* Find the most used attribute value. Handle that as the `default' of the
4677 switch we will generate. */
4678 common_av
= find_most_used (attr
);
4680 /* Write out start of function, then all values with explicit `case' lines,
4681 then a `default', then the value with the most uses. */
4682 if (!attr
->is_numeric
)
4683 printf ("enum attr_%s\n", attr
->name
);
4684 else if (attr
->unsigned_p
)
4685 printf ("unsigned int\n");
4689 /* If the attribute name starts with a star, the remainder is the name of
4690 the subroutine to use, instead of `get_attr_...'. */
4691 if (attr
->name
[0] == '*')
4692 printf ("%s (insn)\n", &attr
->name
[1]);
4693 else if (attr
->is_const
== 0)
4694 printf ("get_attr_%s (insn)\n", attr
->name
);
4697 printf ("get_attr_%s ()\n", attr
->name
);
4700 for (av
= attr
->first_value
; av
; av
= av
->next
)
4701 if (av
->num_insns
!= 0)
4702 write_attr_set (attr
, 2, av
->value
, "return", ";",
4703 true_rtx
, av
->first_insn
->insn_code
,
4704 av
->first_insn
->insn_index
);
4709 printf (" rtx insn;\n");
4711 printf (" switch (recog_memoized (insn))\n");
4714 for (av
= attr
->first_value
; av
; av
= av
->next
)
4715 if (av
!= common_av
)
4716 write_attr_case (attr
, av
, 1, "return", ";", 4, true_rtx
);
4718 write_attr_case (attr
, common_av
, 0, "return", ";", 4, true_rtx
);
4719 printf (" }\n}\n\n");
4722 /* Given an AND tree of known true terms (because we are inside an `if' with
4723 that as the condition or are in an `else' clause) and an expression,
4724 replace any known true terms with TRUE. Use `simplify_and_tree' to do
4725 the bulk of the work. */
4728 eliminate_known_true (known_true
, exp
, insn_code
, insn_index
)
4731 int insn_code
, insn_index
;
4735 known_true
= SIMPLIFY_TEST_EXP (known_true
, insn_code
, insn_index
);
4737 if (GET_CODE (known_true
) == AND
)
4739 exp
= eliminate_known_true (XEXP (known_true
, 0), exp
,
4740 insn_code
, insn_index
);
4741 exp
= eliminate_known_true (XEXP (known_true
, 1), exp
,
4742 insn_code
, insn_index
);
4747 exp
= simplify_and_tree (exp
, &term
, insn_code
, insn_index
);
4753 /* Write out a series of tests and assignment statements to perform tests and
4754 sets of an attribute value. We are passed an indentation amount and prefix
4755 and suffix strings to write around each attribute value (e.g., "return"
4759 write_attr_set (attr
, indent
, value
, prefix
, suffix
, known_true
,
4760 insn_code
, insn_index
)
4761 struct attr_desc
*attr
;
4767 int insn_code
, insn_index
;
4769 if (GET_CODE (value
) == CONST_STRING
)
4771 write_indent (indent
);
4772 printf ("%s ", prefix
);
4773 write_attr_value (attr
, value
);
4774 printf ("%s\n", suffix
);
4776 else if (GET_CODE (value
) == COND
)
4778 /* Assume the default value will be the default of the COND unless we
4779 find an always true expression. */
4780 rtx default_val
= XEXP (value
, 1);
4781 rtx our_known_true
= known_true
;
4786 for (i
= 0; i
< XVECLEN (value
, 0); i
+= 2)
4791 testexp
= eliminate_known_true (our_known_true
,
4792 XVECEXP (value
, 0, i
),
4793 insn_code
, insn_index
);
4794 newexp
= attr_rtx (NOT
, testexp
);
4795 newexp
= insert_right_side (AND
, our_known_true
, newexp
,
4796 insn_code
, insn_index
);
4798 /* If the test expression is always true or if the next `known_true'
4799 expression is always false, this is the last case, so break
4800 out and let this value be the `else' case. */
4801 if (testexp
== true_rtx
|| newexp
== false_rtx
)
4803 default_val
= XVECEXP (value
, 0, i
+ 1);
4807 /* Compute the expression to pass to our recursive call as being
4809 inner_true
= insert_right_side (AND
, our_known_true
,
4810 testexp
, insn_code
, insn_index
);
4812 /* If this is always false, skip it. */
4813 if (inner_true
== false_rtx
)
4816 write_indent (indent
);
4817 printf ("%sif ", first_if
? "" : "else ");
4819 write_test_expr (testexp
, 0);
4821 write_indent (indent
+ 2);
4824 write_attr_set (attr
, indent
+ 4,
4825 XVECEXP (value
, 0, i
+ 1), prefix
, suffix
,
4826 inner_true
, insn_code
, insn_index
);
4827 write_indent (indent
+ 2);
4829 our_known_true
= newexp
;
4834 write_indent (indent
);
4836 write_indent (indent
+ 2);
4840 write_attr_set (attr
, first_if
? indent
: indent
+ 4, default_val
,
4841 prefix
, suffix
, our_known_true
, insn_code
, insn_index
);
4845 write_indent (indent
+ 2);
4853 /* Write out the computation for one attribute value. */
4856 write_attr_case (attr
, av
, write_case_lines
, prefix
, suffix
, indent
,
4858 struct attr_desc
*attr
;
4859 struct attr_value
*av
;
4860 int write_case_lines
;
4861 char *prefix
, *suffix
;
4865 struct insn_ent
*ie
;
4867 if (av
->num_insns
== 0)
4870 if (av
->has_asm_insn
)
4872 write_indent (indent
);
4873 printf ("case -1:\n");
4874 write_indent (indent
+ 2);
4875 printf ("if (GET_CODE (PATTERN (insn)) != ASM_INPUT\n");
4876 write_indent (indent
+ 2);
4877 printf (" && asm_noperands (PATTERN (insn)) < 0)\n");
4878 write_indent (indent
+ 2);
4879 printf (" fatal_insn_not_found (insn);\n");
4882 if (write_case_lines
)
4884 for (ie
= av
->first_insn
; ie
; ie
= ie
->next
)
4885 if (ie
->insn_code
!= -1)
4887 write_indent (indent
);
4888 printf ("case %d:\n", ie
->insn_code
);
4893 write_indent (indent
);
4894 printf ("default:\n");
4897 /* See what we have to do to output this value. */
4898 must_extract
= must_constrain
= address_used
= 0;
4899 walk_attr_value (av
->value
);
4903 write_indent (indent
+ 2);
4904 printf ("insn_extract (insn);\n");
4909 #ifdef REGISTER_CONSTRAINTS
4910 write_indent (indent
+ 2);
4911 printf ("if (! constrain_operands (INSN_CODE (insn), reload_completed))\n");
4912 write_indent (indent
+ 2);
4913 printf (" fatal_insn_not_found (insn);\n");
4917 write_attr_set (attr
, indent
+ 2, av
->value
, prefix
, suffix
,
4918 known_true
, av
->first_insn
->insn_code
,
4919 av
->first_insn
->insn_index
);
4921 if (strncmp (prefix
, "return", 6))
4923 write_indent (indent
+ 2);
4924 printf ("break;\n");
4929 /* Utilities to write names in various forms. */
4932 write_attr_valueq (attr
, s
)
4933 struct attr_desc
*attr
;
4936 if (attr
->is_numeric
)
4939 /* Make the blockage range values easier to read. */
4941 printf (" /* 0x%x */", atoi (s
));
4945 write_upcase (attr
->name
);
4952 write_attr_value (attr
, value
)
4953 struct attr_desc
*attr
;
4956 if (GET_CODE (value
) != CONST_STRING
)
4959 write_attr_valueq (attr
, XSTR (value
, 0));
4967 if (*str
< 'a' || *str
> 'z')
4968 printf ("%c", *str
++);
4970 printf ("%c", *str
++ - 'a' + 'A');
4974 write_indent (indent
)
4977 for (; indent
> 8; indent
-= 8)
4980 for (; indent
; indent
--)
4984 /* Write a subroutine that is given an insn that requires a delay slot, a
4985 delay slot ordinal, and a candidate insn. It returns non-zero if the
4986 candidate can be placed in the specified delay slot of the insn.
4988 We can write as many as three subroutines. `eligible_for_delay'
4989 handles normal delay slots, `eligible_for_annul_true' indicates that
4990 the specified insn can be annulled if the branch is true, and likewise
4991 for `eligible_for_annul_false'.
4993 KIND is a string distinguishing these three cases ("delay", "annul_true",
4994 or "annul_false"). */
4997 write_eligible_delay (kind
)
5000 struct delay_desc
*delay
;
5003 struct attr_desc
*attr
;
5004 struct attr_value
*av
, *common_av
;
5007 /* Compute the maximum number of delay slots required. We use the delay
5008 ordinal times this number plus one, plus the slot number as an index into
5009 the appropriate predicate to test. */
5011 for (delay
= delays
, max_slots
= 0; delay
; delay
= delay
->next
)
5012 if (XVECLEN (delay
->def
, 1) / 3 > max_slots
)
5013 max_slots
= XVECLEN (delay
->def
, 1) / 3;
5015 /* Write function prelude. */
5018 printf ("eligible_for_%s (delay_insn, slot, candidate_insn, flags)\n",
5020 printf (" rtx delay_insn;\n");
5021 printf (" int slot;\n");
5022 printf (" rtx candidate_insn;\n");
5023 printf (" int flags;\n");
5025 printf (" rtx insn;\n");
5027 printf (" if (slot >= %d)\n", max_slots
);
5028 printf (" abort ();\n");
5031 /* If more than one delay type, find out which type the delay insn is. */
5035 attr
= find_attr ("*delay_type", 0);
5036 if (! attr
) abort ();
5037 common_av
= find_most_used (attr
);
5039 printf (" insn = delay_insn;\n");
5040 printf (" switch (recog_memoized (insn))\n");
5043 sprintf (str
, " * %d;\n break;", max_slots
);
5044 for (av
= attr
->first_value
; av
; av
= av
->next
)
5045 if (av
!= common_av
)
5046 write_attr_case (attr
, av
, 1, "slot +=", str
, 4, true_rtx
);
5048 write_attr_case (attr
, common_av
, 0, "slot +=", str
, 4, true_rtx
);
5051 /* Ensure matched. Otherwise, shouldn't have been called. */
5052 printf (" if (slot < %d)\n", max_slots
);
5053 printf (" abort ();\n\n");
5056 /* If just one type of delay slot, write simple switch. */
5057 if (num_delays
== 1 && max_slots
== 1)
5059 printf (" insn = candidate_insn;\n");
5060 printf (" switch (recog_memoized (insn))\n");
5063 attr
= find_attr ("*delay_1_0", 0);
5064 if (! attr
) abort ();
5065 common_av
= find_most_used (attr
);
5067 for (av
= attr
->first_value
; av
; av
= av
->next
)
5068 if (av
!= common_av
)
5069 write_attr_case (attr
, av
, 1, "return", ";", 4, true_rtx
);
5071 write_attr_case (attr
, common_av
, 0, "return", ";", 4, true_rtx
);
5077 /* Write a nested CASE. The first indicates which condition we need to
5078 test, and the inner CASE tests the condition. */
5079 printf (" insn = candidate_insn;\n");
5080 printf (" switch (slot)\n");
5083 for (delay
= delays
; delay
; delay
= delay
->next
)
5084 for (i
= 0; i
< XVECLEN (delay
->def
, 1); i
+= 3)
5086 printf (" case %d:\n",
5087 (i
/ 3) + (num_delays
== 1 ? 0 : delay
->num
* max_slots
));
5088 printf (" switch (recog_memoized (insn))\n");
5091 sprintf (str
, "*%s_%d_%d", kind
, delay
->num
, i
/ 3);
5092 attr
= find_attr (str
, 0);
5093 if (! attr
) abort ();
5094 common_av
= find_most_used (attr
);
5096 for (av
= attr
->first_value
; av
; av
= av
->next
)
5097 if (av
!= common_av
)
5098 write_attr_case (attr
, av
, 1, "return", ";", 8, true_rtx
);
5100 write_attr_case (attr
, common_av
, 0, "return", ";", 8, true_rtx
);
5104 printf (" default:\n");
5105 printf (" abort ();\n");
5112 /* Write routines to compute conflict cost for function units. Then write a
5113 table describing the available function units. */
5116 write_function_unit_info ()
5118 struct function_unit
*unit
;
5121 /* Write out conflict routines for function units. Don't bother writing
5122 one if there is only one issue delay value. */
5124 for (unit
= units
; unit
; unit
= unit
->next
)
5126 if (unit
->needs_blockage_function
)
5127 write_complex_function (unit
, "blockage", "block");
5129 /* If the minimum and maximum conflict costs are the same, there
5130 is only one value, so we don't need a function. */
5131 if (! unit
->needs_conflict_function
)
5133 unit
->default_cost
= make_numeric_value (unit
->issue_delay
.max
);
5137 /* The function first computes the case from the candidate insn. */
5138 unit
->default_cost
= make_numeric_value (0);
5139 write_complex_function (unit
, "conflict_cost", "cost");
5142 /* Now that all functions have been written, write the table describing
5143 the function units. The name is included for documentation purposes
5146 printf ("struct function_unit_desc function_units[] = {\n");
5148 /* Write out the descriptions in numeric order, but don't force that order
5149 on the list. Doing so increases the runtime of genattrtab.c. */
5150 for (i
= 0; i
< num_units
; i
++)
5152 for (unit
= units
; unit
; unit
= unit
->next
)
5156 printf (" {\"%s\", %d, %d, %d, %s, %d, %s_unit_ready_cost, ",
5157 unit
->name
, 1 << unit
->num
, unit
->multiplicity
,
5158 unit
->simultaneity
, XSTR (unit
->default_cost
, 0),
5159 unit
->issue_delay
.max
, unit
->name
);
5161 if (unit
->needs_conflict_function
)
5162 printf ("%s_unit_conflict_cost, ", unit
->name
);
5166 printf ("%d, ", unit
->max_blockage
);
5168 if (unit
->needs_range_function
)
5169 printf ("%s_unit_blockage_range, ", unit
->name
);
5173 if (unit
->needs_blockage_function
)
5174 printf ("%s_unit_blockage", unit
->name
);
5185 write_complex_function (unit
, name
, connection
)
5186 struct function_unit
*unit
;
5187 char *name
, *connection
;
5189 struct attr_desc
*case_attr
, *attr
;
5190 struct attr_value
*av
, *common_av
;
5196 printf ("static int\n");
5197 printf ("%s_unit_%s (executing_insn, candidate_insn)\n",
5199 printf (" rtx executing_insn;\n");
5200 printf (" rtx candidate_insn;\n");
5202 printf (" rtx insn;\n");
5203 printf (" int casenum;\n\n");
5204 printf (" insn = executing_insn;\n");
5205 printf (" switch (recog_memoized (insn))\n");
5208 /* Write the `switch' statement to get the case value. */
5209 str
= (char *) alloca (strlen (unit
->name
) + strlen (name
) + strlen (connection
) + 10);
5210 sprintf (str
, "*%s_cases", unit
->name
);
5211 case_attr
= find_attr (str
, 0);
5212 if (! case_attr
) abort ();
5213 common_av
= find_most_used (case_attr
);
5215 for (av
= case_attr
->first_value
; av
; av
= av
->next
)
5216 if (av
!= common_av
)
5217 write_attr_case (case_attr
, av
, 1,
5218 "casenum =", ";", 4, unit
->condexp
);
5220 write_attr_case (case_attr
, common_av
, 0,
5221 "casenum =", ";", 4, unit
->condexp
);
5224 /* Now write an outer switch statement on each case. Then write
5225 the tests on the executing function within each. */
5226 printf (" insn = candidate_insn;\n");
5227 printf (" switch (casenum)\n");
5230 for (i
= 0; i
< unit
->num_opclasses
; i
++)
5232 /* Ensure using this case. */
5234 for (av
= case_attr
->first_value
; av
; av
= av
->next
)
5236 && contained_in_p (make_numeric_value (i
), av
->value
))
5242 printf (" case %d:\n", i
);
5243 sprintf (str
, "*%s_%s_%d", unit
->name
, connection
, i
);
5244 attr
= find_attr (str
, 0);
5245 if (! attr
) abort ();
5247 /* If single value, just write it. */
5248 value
= find_single_value (attr
);
5250 write_attr_set (attr
, 6, value
, "return", ";\n", true_rtx
, -2, -2);
5253 common_av
= find_most_used (attr
);
5254 printf (" switch (recog_memoized (insn))\n");
5257 for (av
= attr
->first_value
; av
; av
= av
->next
)
5258 if (av
!= common_av
)
5259 write_attr_case (attr
, av
, 1,
5260 "return", ";", 8, unit
->condexp
);
5262 write_attr_case (attr
, common_av
, 0,
5263 "return", ";", 8, unit
->condexp
);
5268 printf (" }\n}\n\n");
5271 /* This page contains miscellaneous utility routines. */
5273 /* Given a string, return the number of comma-separated elements in it.
5274 Return 0 for the null string. */
5285 for (n
= 1; *s
; s
++)
5292 /* Given a pointer to a (char *), return a malloc'ed string containing the
5293 next comma-separated element. Advance the pointer to after the string
5294 scanned, or the end-of-string. Return NULL if at end of string. */
5297 next_comma_elt (pstr
)
5306 /* Find end of string to compute length. */
5307 for (p
= *pstr
; *p
!= ',' && *p
!= '\0'; p
++)
5310 out_str
= attr_string (*pstr
, p
- *pstr
);
5319 /* Return a `struct attr_desc' pointer for a given named attribute. If CREATE
5320 is non-zero, build a new attribute, if one does not exist. */
5322 static struct attr_desc
*
5323 find_attr (name
, create
)
5327 struct attr_desc
*attr
;
5330 /* Before we resort to using `strcmp', see if the string address matches
5331 anywhere. In most cases, it should have been canonicalized to do so. */
5332 if (name
== alternative_name
)
5335 index
= name
[0] & (MAX_ATTRS_INDEX
- 1);
5336 for (attr
= attrs
[index
]; attr
; attr
= attr
->next
)
5337 if (name
== attr
->name
)
5340 /* Otherwise, do it the slow way. */
5341 for (attr
= attrs
[index
]; attr
; attr
= attr
->next
)
5342 if (name
[0] == attr
->name
[0] && ! strcmp (name
, attr
->name
))
5348 attr
= (struct attr_desc
*) oballoc (sizeof (struct attr_desc
));
5349 attr
->name
= attr_string (name
, strlen (name
));
5350 attr
->first_value
= attr
->default_val
= NULL
;
5351 attr
->is_numeric
= attr
->negative_ok
= attr
->is_const
= attr
->is_special
= 0;
5352 attr
->next
= attrs
[index
];
5353 attrs
[index
] = attr
;
5358 /* Create internal attribute with the given default value. */
5361 make_internal_attr (name
, value
, special
)
5366 struct attr_desc
*attr
;
5368 attr
= find_attr (name
, 1);
5369 if (attr
->default_val
)
5372 attr
->is_numeric
= 1;
5374 attr
->is_special
= (special
& 1) != 0;
5375 attr
->negative_ok
= (special
& 2) != 0;
5376 attr
->unsigned_p
= (special
& 4) != 0;
5377 attr
->default_val
= get_attr_value (value
, attr
, -2);
5380 /* Find the most used value of an attribute. */
5382 static struct attr_value
*
5383 find_most_used (attr
)
5384 struct attr_desc
*attr
;
5386 struct attr_value
*av
;
5387 struct attr_value
*most_used
;
5393 for (av
= attr
->first_value
; av
; av
= av
->next
)
5394 if (av
->num_insns
> nuses
)
5395 nuses
= av
->num_insns
, most_used
= av
;
5400 /* If an attribute only has a single value used, return it. Otherwise
5404 find_single_value (attr
)
5405 struct attr_desc
*attr
;
5407 struct attr_value
*av
;
5410 unique_value
= NULL
;
5411 for (av
= attr
->first_value
; av
; av
= av
->next
)
5417 unique_value
= av
->value
;
5420 return unique_value
;
5423 /* Return (attr_value "n") */
5426 make_numeric_value (n
)
5429 static rtx int_values
[20];
5436 if (n
< 20 && int_values
[n
])
5437 return int_values
[n
];
5439 p
= attr_printf (MAX_DIGITS
, "%d", n
);
5440 exp
= attr_rtx (CONST_STRING
, p
);
5443 int_values
[n
] = exp
;
5449 extend_range (range
, min
, max
)
5450 struct range
*range
;
5454 if (range
->min
> min
) range
->min
= min
;
5455 if (range
->max
< max
) range
->max
= max
;
5459 xrealloc (ptr
, size
)
5463 char *result
= (char *) realloc (ptr
, size
);
5465 fatal ("virtual memory exhausted");
5473 register char *val
= (char *) malloc (size
);
5476 fatal ("virtual memory exhausted");
5481 copy_rtx_unchanging (orig
)
5486 register RTX_CODE code
;
5489 if (RTX_UNCHANGING_P (orig
) || MEM_IN_STRUCT_P (orig
))
5492 MEM_IN_STRUCT_P (orig
) = 1;
5496 code
= GET_CODE (orig
);
5509 copy
= rtx_alloc (code
);
5510 PUT_MODE (copy
, GET_MODE (orig
));
5511 RTX_UNCHANGING_P (copy
) = 1;
5513 bcopy ((char *) &XEXP (orig
, 0), (char *) &XEXP (copy
, 0),
5514 GET_RTX_LENGTH (GET_CODE (copy
)) * sizeof (rtx
));
5524 fprintf (stderr
, "genattrtab: ");
5525 fprintf (stderr
, s
, a1
, a2
);
5526 fprintf (stderr
, "\n");
5527 exit (FATAL_EXIT_CODE
);
5530 /* More 'friendly' abort that prints the line and file.
5531 config.h can #define abort fancy_abort if you like that sort of thing. */
5536 fatal ("Internal gcc abort.");
5539 /* Determine if an insn has a constant number of delay slots, i.e., the
5540 number of delay slots is not a function of the length of the insn. */
5543 write_const_num_delay_slots ()
5545 struct attr_desc
*attr
= find_attr ("*num_delay_slots", 0);
5546 struct attr_value
*av
;
5547 struct insn_ent
*ie
;
5552 printf ("int\nconst_num_delay_slots (insn)\n");
5553 printf (" rtx insn;\n");
5555 printf (" switch (recog_memoized (insn))\n");
5558 for (av
= attr
->first_value
; av
; av
= av
->next
)
5561 walk_attr_value (av
->value
);
5564 for (ie
= av
->first_insn
; ie
; ie
= ie
->next
)
5565 if (ie
->insn_code
!= -1)
5566 printf (" case %d:\n", ie
->insn_code
);
5567 printf (" return 0;\n");
5571 printf (" default:\n");
5572 printf (" return 1;\n");
5586 struct attr_desc
*attr
;
5587 struct insn_def
*id
;
5592 /* Get rid of any avoidable limit on stack size. */
5596 /* Set the stack limit huge so that alloca does not fail. */
5597 getrlimit (RLIMIT_STACK
, &rlim
);
5598 rlim
.rlim_cur
= rlim
.rlim_max
;
5599 setrlimit (RLIMIT_STACK
, &rlim
);
5601 #endif /* RLIMIT_STACK defined */
5603 obstack_init (rtl_obstack
);
5604 obstack_init (hash_obstack
);
5605 obstack_init (temp_obstack
);
5608 fatal ("No input file name.");
5610 infile
= fopen (argv
[1], "r");
5614 exit (FATAL_EXIT_CODE
);
5619 /* We don't use this, but it is referenced in rtlanal.c.
5620 Set it up correctly just in case someone tries to use it someday. */
5621 pc_rtx
= rtx_alloc (PC
);
5622 PUT_MODE (pc_rtx
, VOIDmode
);
5624 /* Set up true and false rtx's */
5625 true_rtx
= rtx_alloc (CONST_INT
);
5626 XWINT (true_rtx
, 0) = 1;
5627 false_rtx
= rtx_alloc (CONST_INT
);
5628 XWINT (false_rtx
, 0) = 0;
5629 RTX_UNCHANGING_P (true_rtx
) = RTX_UNCHANGING_P (false_rtx
) = 1;
5630 RTX_INTEGRATED_P (true_rtx
) = RTX_INTEGRATED_P (false_rtx
) = 1;
5632 alternative_name
= attr_string ("alternative", strlen ("alternative"));
5634 printf ("/* Generated automatically by the program `genattrtab'\n\
5635 from the machine description file `md'. */\n\n");
5637 /* Read the machine description. */
5641 c
= read_skip_spaces (infile
);
5646 desc
= read_rtx (infile
);
5647 if (GET_CODE (desc
) == DEFINE_INSN
5648 || GET_CODE (desc
) == DEFINE_PEEPHOLE
5649 || GET_CODE (desc
) == DEFINE_ASM_ATTRIBUTES
)
5652 else if (GET_CODE (desc
) == DEFINE_EXPAND
)
5653 insn_code_number
++, insn_index_number
++;
5655 else if (GET_CODE (desc
) == DEFINE_SPLIT
)
5656 insn_code_number
++, insn_index_number
++;
5658 else if (GET_CODE (desc
) == DEFINE_ATTR
)
5661 insn_index_number
++;
5664 else if (GET_CODE (desc
) == DEFINE_DELAY
)
5667 insn_index_number
++;
5670 else if (GET_CODE (desc
) == DEFINE_FUNCTION_UNIT
)
5673 insn_index_number
++;
5677 /* If we didn't have a DEFINE_ASM_ATTRIBUTES, make a null one. */
5678 if (! got_define_asm_attributes
)
5680 tem
= rtx_alloc (DEFINE_ASM_ATTRIBUTES
);
5681 XVEC (tem
, 0) = rtvec_alloc (0);
5685 /* Expand DEFINE_DELAY information into new attribute. */
5689 /* Expand DEFINE_FUNCTION_UNIT information into new attributes. */
5693 printf ("#include \"config.h\"\n");
5694 printf ("#include <stdio.h>\n");
5695 printf ("#include \"rtl.h\"\n");
5696 printf ("#include \"insn-config.h\"\n");
5697 printf ("#include \"recog.h\"\n");
5698 printf ("#include \"regs.h\"\n");
5699 printf ("#include \"real.h\"\n");
5700 printf ("#include \"output.h\"\n");
5701 printf ("#include \"insn-attr.h\"\n");
5703 printf ("#define operands recog_operand\n\n");
5705 /* Make `insn_alternatives'. */
5706 insn_alternatives
= (int *) oballoc (insn_code_number
* sizeof (int));
5707 for (id
= defs
; id
; id
= id
->next
)
5708 if (id
->insn_code
>= 0)
5709 insn_alternatives
[id
->insn_code
] = (1 << id
->num_alternatives
) - 1;
5711 /* Make `insn_n_alternatives'. */
5712 insn_n_alternatives
= (int *) oballoc (insn_code_number
* sizeof (int));
5713 for (id
= defs
; id
; id
= id
->next
)
5714 if (id
->insn_code
>= 0)
5715 insn_n_alternatives
[id
->insn_code
] = id
->num_alternatives
;
5717 /* Prepare to write out attribute subroutines by checking everything stored
5718 away and building the attribute cases. */
5721 for (i
= 0; i
< MAX_ATTRS_INDEX
; i
++)
5722 for (attr
= attrs
[i
]; attr
; attr
= attr
->next
)
5724 attr
->default_val
->value
5725 = check_attr_value (attr
->default_val
->value
, attr
);
5729 /* Construct extra attributes for `length'. */
5730 make_length_attrs ();
5732 /* Perform any possible optimizations to speed up compilation. */
5735 /* Now write out all the `gen_attr_...' routines. Do these before the
5736 special routines (specifically before write_function_unit_info), so
5737 that they get defined before they are used. */
5739 for (i
= 0; i
< MAX_ATTRS_INDEX
; i
++)
5740 for (attr
= attrs
[i
]; attr
; attr
= attr
->next
)
5742 if (! attr
->is_special
)
5743 write_attr_get (attr
);
5746 /* Write out delay eligibility information, if DEFINE_DELAY present.
5747 (The function to compute the number of delay slots will be written
5751 write_eligible_delay ("delay");
5752 if (have_annul_true
)
5753 write_eligible_delay ("annul_true");
5754 if (have_annul_false
)
5755 write_eligible_delay ("annul_false");
5758 /* Write out information about function units. */
5760 write_function_unit_info ();
5762 /* Write out constant delay slot info */
5763 write_const_num_delay_slots ();
5766 exit (ferror (stdout
) != 0 ? FATAL_EXIT_CODE
: SUCCESS_EXIT_CODE
);