1 /* Generate code from machine description to compute values of attributes.
2 Copyright (C) 1991, 93, 94, 95, 96, 97, 1998 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 HAVE_SYS_RESOURCE_H
110 # include <sys/resource.h>
113 /* We must include obstack.h after <sys/time.h>, to avoid lossage with
114 /usr/include/sys/stdtypes.h on Sun OS 4.x. */
117 static struct obstack obstack
, obstack1
, obstack2
;
118 struct obstack
*rtl_obstack
= &obstack
;
119 struct obstack
*hash_obstack
= &obstack1
;
120 struct obstack
*temp_obstack
= &obstack2
;
122 #define obstack_chunk_alloc xmalloc
123 #define obstack_chunk_free free
125 /* Define this so we can link with print-rtl.o to get debug_rtx function. */
126 char **insn_name_ptr
= 0;
128 static void fatal ();
129 void fancy_abort
PROTO((void));
131 /* enough space to reserve for printing out ints */
132 #define MAX_DIGITS (HOST_BITS_PER_INT * 3 / 10 + 3)
134 /* Define structures used to record attributes and values. */
136 /* As each DEFINE_INSN, DEFINE_PEEPHOLE, or DEFINE_ASM_ATTRIBUTES is
137 encountered, we store all the relevant information into a
138 `struct insn_def'. This is done to allow attribute definitions to occur
139 anywhere in the file. */
143 int insn_code
; /* Instruction number. */
144 int insn_index
; /* Expression numer in file, for errors. */
145 struct insn_def
*next
; /* Next insn in chain. */
146 rtx def
; /* The DEFINE_... */
147 int num_alternatives
; /* Number of alternatives. */
148 int vec_idx
; /* Index of attribute vector in `def'. */
151 /* Once everything has been read in, we store in each attribute value a list
152 of insn codes that have that value. Here is the structure used for the
157 int insn_code
; /* Instruction number. */
158 int insn_index
; /* Index of definition in file */
159 struct insn_ent
*next
; /* Next in chain. */
162 /* Each value of an attribute (either constant or computed) is assigned a
163 structure which is used as the listhead of the insns that have that
168 rtx value
; /* Value of attribute. */
169 struct attr_value
*next
; /* Next attribute value in chain. */
170 struct insn_ent
*first_insn
; /* First insn with this value. */
171 int num_insns
; /* Number of insns with this value. */
172 int has_asm_insn
; /* True if this value used for `asm' insns */
175 /* Structure for each attribute. */
179 char *name
; /* Name of attribute. */
180 struct attr_desc
*next
; /* Next attribute. */
181 int is_numeric
; /* Values of this attribute are numeric. */
182 int negative_ok
; /* Allow negative numeric values. */
183 int unsigned_p
; /* Make the output function unsigned int. */
184 int is_const
; /* Attribute value constant for each run. */
185 int is_special
; /* Don't call `write_attr_set'. */
186 struct attr_value
*first_value
; /* First value of this attribute. */
187 struct attr_value
*default_val
; /* Default value for this attribute. */
190 #define NULL_ATTR (struct attr_desc *) NULL
192 /* A range of values. */
200 /* Structure for each DEFINE_DELAY. */
204 rtx def
; /* DEFINE_DELAY expression. */
205 struct delay_desc
*next
; /* Next DEFINE_DELAY. */
206 int num
; /* Number of DEFINE_DELAY, starting at 1. */
209 /* Record information about each DEFINE_FUNCTION_UNIT. */
211 struct function_unit_op
213 rtx condexp
; /* Expression TRUE for applicable insn. */
214 struct function_unit_op
*next
; /* Next operation for this function unit. */
215 int num
; /* Ordinal for this operation type in unit. */
216 int ready
; /* Cost until data is ready. */
217 int issue_delay
; /* Cost until unit can accept another insn. */
218 rtx conflict_exp
; /* Expression TRUE for insns incurring issue delay. */
219 rtx issue_exp
; /* Expression computing issue delay. */
222 /* Record information about each function unit mentioned in a
223 DEFINE_FUNCTION_UNIT. */
227 char *name
; /* Function unit name. */
228 struct function_unit
*next
; /* Next function unit. */
229 int num
; /* Ordinal of this unit type. */
230 int multiplicity
; /* Number of units of this type. */
231 int simultaneity
; /* Maximum number of simultaneous insns
232 on this function unit or 0 if unlimited. */
233 rtx condexp
; /* Expression TRUE for insn needing unit. */
234 int num_opclasses
; /* Number of different operation types. */
235 struct function_unit_op
*ops
; /* Pointer to first operation type. */
236 int needs_conflict_function
; /* Nonzero if a conflict function required. */
237 int needs_blockage_function
; /* Nonzero if a blockage function required. */
238 int needs_range_function
; /* Nonzero if blockage range function needed.*/
239 rtx default_cost
; /* Conflict cost, if constant. */
240 struct range issue_delay
; /* Range of issue delay values. */
241 int max_blockage
; /* Maximum time an insn blocks the unit. */
244 /* Listheads of above structures. */
246 /* This one is indexed by the first character of the attribute name. */
247 #define MAX_ATTRS_INDEX 256
248 static struct attr_desc
*attrs
[MAX_ATTRS_INDEX
];
249 static struct insn_def
*defs
;
250 static struct delay_desc
*delays
;
251 static struct function_unit
*units
;
253 /* An expression where all the unknown terms are EQ_ATTR tests can be
254 rearranged into a COND provided we can enumerate all possible
255 combinations of the unknown values. The set of combinations become the
256 tests of the COND; the value of the expression given that combination is
257 computed and becomes the corresponding value. To do this, we must be
258 able to enumerate all values for each attribute used in the expression
259 (currently, we give up if we find a numeric attribute).
261 If the set of EQ_ATTR tests used in an expression tests the value of N
262 different attributes, the list of all possible combinations can be made
263 by walking the N-dimensional attribute space defined by those
264 attributes. We record each of these as a struct dimension.
266 The algorithm relies on sharing EQ_ATTR nodes: if two nodes in an
267 expression are the same, the will also have the same address. We find
268 all the EQ_ATTR nodes by marking them MEM_VOLATILE_P. This bit later
269 represents the value of an EQ_ATTR node, so once all nodes are marked,
270 they are also given an initial value of FALSE.
272 We then separate the set of EQ_ATTR nodes into dimensions for each
273 attribute and put them on the VALUES list. Terms are added as needed by
274 `add_values_to_cover' so that all possible values of the attribute are
277 Each dimension also has a current value. This is the node that is
278 currently considered to be TRUE. If this is one of the nodes added by
279 `add_values_to_cover', all the EQ_ATTR tests in the original expression
280 will be FALSE. Otherwise, only the CURRENT_VALUE will be true.
282 NUM_VALUES is simply the length of the VALUES list and is there for
285 Once the dimensions are created, the algorithm enumerates all possible
286 values and computes the current value of the given expression. */
290 struct attr_desc
*attr
; /* Attribute for this dimension. */
291 rtx values
; /* List of attribute values used. */
292 rtx current_value
; /* Position in the list for the TRUE value. */
293 int num_values
; /* Length of the values list. */
296 /* Other variables. */
298 static int insn_code_number
;
299 static int insn_index_number
;
300 static int got_define_asm_attributes
;
301 static int must_extract
;
302 static int must_constrain
;
303 static int address_used
;
304 static int length_used
;
305 static int num_delays
;
306 static int have_annul_true
, have_annul_false
;
307 static int num_units
, num_unit_opclasses
;
308 static int num_insn_ents
;
310 /* Used as operand to `operate_exp': */
312 enum operator {PLUS_OP
, MINUS_OP
, POS_MINUS_OP
, EQ_OP
, OR_OP
, ORX_OP
, MAX_OP
, MIN_OP
, RANGE_OP
};
314 /* Stores, for each insn code, the number of constraint alternatives. */
316 static int *insn_n_alternatives
;
318 /* Stores, for each insn code, a bitmap that has bits on for each possible
321 static int *insn_alternatives
;
323 /* If nonzero, assume that the `alternative' attr has this value.
324 This is the hashed, unique string for the numeral
325 whose value is chosen alternative. */
327 static char *current_alternative_string
;
329 /* Used to simplify expressions. */
331 static rtx true_rtx
, false_rtx
;
333 /* Used to reduce calls to `strcmp' */
335 static char *alternative_name
;
337 /* Indicate that REG_DEAD notes are valid if dead_or_set_p is ever
340 int reload_completed
= 0;
342 /* Similarly since PRESERVE_DEATH_INFO_REGNO_P might reference "optimize". */
345 /* Simplify an expression. Only call the routine if there is something to
347 #define SIMPLIFY_TEST_EXP(EXP,INSN_CODE,INSN_INDEX) \
348 (RTX_UNCHANGING_P (EXP) || MEM_IN_STRUCT_P (EXP) ? (EXP) \
349 : simplify_test_exp (EXP, INSN_CODE, INSN_INDEX))
351 /* Simplify (eq_attr ("alternative") ...)
352 when we are working with a particular alternative. */
353 #define SIMPLIFY_ALTERNATIVE(EXP) \
354 if (current_alternative_string \
355 && GET_CODE ((EXP)) == EQ_ATTR \
356 && XSTR ((EXP), 0) == alternative_name) \
357 (EXP) = (XSTR ((EXP), 1) == current_alternative_string \
358 ? true_rtx : false_rtx);
360 /* These are referenced by rtlanal.c and hence need to be defined somewhere.
361 They won't actually be used. */
363 struct _global_rtl global_rtl
;
364 rtx pic_offset_table_rtx
;
366 static rtx attr_rtx
PVPROTO((enum rtx_code
, ...));
368 static char *attr_printf
PVPROTO((int, char *, ...));
370 static char *attr_printf ();
373 static char *attr_string
PROTO((char *, int));
374 static rtx check_attr_test
PROTO((rtx
, int));
375 static rtx check_attr_value
PROTO((rtx
, struct attr_desc
*));
376 static rtx convert_set_attr_alternative
PROTO((rtx
, int, int, int));
377 static rtx convert_set_attr
PROTO((rtx
, int, int, int));
378 static void check_defs
PROTO((void));
380 static rtx convert_const_symbol_ref
PROTO((rtx
, struct attr_desc
*));
382 static rtx make_canonical
PROTO((struct attr_desc
*, rtx
));
383 static struct attr_value
*get_attr_value
PROTO((rtx
, struct attr_desc
*, int));
384 static rtx copy_rtx_unchanging
PROTO((rtx
));
385 static rtx copy_boolean
PROTO((rtx
));
386 static void expand_delays
PROTO((void));
387 static rtx operate_exp
PROTO((enum operator, rtx
, rtx
));
388 static void expand_units
PROTO((void));
389 static rtx simplify_knowing
PROTO((rtx
, rtx
));
390 static rtx encode_units_mask
PROTO((rtx
));
391 static void fill_attr
PROTO((struct attr_desc
*));
392 /* dpx2 compiler chokes if we specify the arg types of the args. */
393 static rtx substitute_address
PROTO((rtx
, rtx (*) (), rtx (*) ()));
394 static void make_length_attrs
PROTO((void));
395 static rtx identity_fn
PROTO((rtx
));
396 static rtx zero_fn
PROTO((rtx
));
397 static rtx one_fn
PROTO((rtx
));
398 static rtx max_fn
PROTO((rtx
));
399 static rtx simplify_cond
PROTO((rtx
, int, int));
401 static rtx simplify_by_alternatives
PROTO((rtx
, int, int));
403 static rtx simplify_by_exploding
PROTO((rtx
));
404 static int find_and_mark_used_attributes
PROTO((rtx
, rtx
*, int *));
405 static void unmark_used_attributes
PROTO((rtx
, struct dimension
*, int));
406 static int add_values_to_cover
PROTO((struct dimension
*));
407 static int increment_current_value
PROTO((struct dimension
*, int));
408 static rtx test_for_current_value
PROTO((struct dimension
*, int));
409 static rtx simplify_with_current_value
PROTO((rtx
, struct dimension
*, int));
410 static rtx simplify_with_current_value_aux
PROTO((rtx
));
411 static void clear_struct_flag
PROTO((rtx
));
412 static int count_sub_rtxs
PROTO((rtx
, int));
413 static void remove_insn_ent
PROTO((struct attr_value
*, struct insn_ent
*));
414 static void insert_insn_ent
PROTO((struct attr_value
*, struct insn_ent
*));
415 static rtx insert_right_side
PROTO((enum rtx_code
, rtx
, rtx
, int, int));
416 static rtx make_alternative_compare
PROTO((int));
417 static int compute_alternative_mask
PROTO((rtx
, enum rtx_code
));
418 static rtx evaluate_eq_attr
PROTO((rtx
, rtx
, int, int));
419 static rtx simplify_and_tree
PROTO((rtx
, rtx
*, int, int));
420 static rtx simplify_or_tree
PROTO((rtx
, rtx
*, int, int));
421 static rtx simplify_test_exp
PROTO((rtx
, int, int));
422 static void optimize_attrs
PROTO((void));
423 static void gen_attr
PROTO((rtx
));
424 static int count_alternatives
PROTO((rtx
));
425 static int compares_alternatives_p
PROTO((rtx
));
426 static int contained_in_p
PROTO((rtx
, rtx
));
427 static void gen_insn
PROTO((rtx
));
428 static void gen_delay
PROTO((rtx
));
429 static void gen_unit
PROTO((rtx
));
430 static void write_test_expr
PROTO((rtx
, int));
431 static int max_attr_value
PROTO((rtx
));
432 static int or_attr_value
PROTO((rtx
));
433 static void walk_attr_value
PROTO((rtx
));
434 static void write_attr_get
PROTO((struct attr_desc
*));
435 static rtx eliminate_known_true
PROTO((rtx
, rtx
, int, int));
436 static void write_attr_set
PROTO((struct attr_desc
*, int, rtx
, char *,
437 char *, rtx
, int, int));
438 static void write_attr_case
PROTO((struct attr_desc
*, struct attr_value
*,
439 int, char *, char *, int, rtx
));
440 static void write_attr_valueq
PROTO((struct attr_desc
*, char *));
441 static void write_attr_value
PROTO((struct attr_desc
*, rtx
));
442 static void write_upcase
PROTO((char *));
443 static void write_indent
PROTO((int));
444 static void write_eligible_delay
PROTO((char *));
445 static void write_function_unit_info
PROTO((void));
446 static void write_complex_function
PROTO((struct function_unit
*, char *,
448 static int write_expr_attr_cache
PROTO((rtx
, struct attr_desc
*));
449 static void write_toplevel_expr
PROTO((rtx
));
450 static int n_comma_elts
PROTO((char *));
451 static char *next_comma_elt
PROTO((char **));
452 static struct attr_desc
*find_attr
PROTO((char *, int));
453 static void make_internal_attr
PROTO((char *, rtx
, int));
454 static struct attr_value
*find_most_used
PROTO((struct attr_desc
*));
455 static rtx find_single_value
PROTO((struct attr_desc
*));
456 static rtx make_numeric_value
PROTO((int));
457 static void extend_range
PROTO((struct range
*, int, int));
458 char *xrealloc
PROTO((char *, unsigned));
459 char *xmalloc
PROTO((unsigned));
461 #define oballoc(size) obstack_alloc (hash_obstack, size)
464 /* Hash table for sharing RTL and strings. */
466 /* Each hash table slot is a bucket containing a chain of these structures.
467 Strings are given negative hash codes; RTL expressions are given positive
472 struct attr_hash
*next
; /* Next structure in the bucket. */
473 int hashcode
; /* Hash code of this rtx or string. */
476 char *str
; /* The string (negative hash codes) */
477 rtx rtl
; /* or the RTL recorded here. */
481 /* Now here is the hash table. When recording an RTL, it is added to
482 the slot whose index is the hash code mod the table size. Note
483 that the hash table is used for several kinds of RTL (see attr_rtx)
484 and for strings. While all these live in the same table, they are
485 completely independent, and the hash code is computed differently
488 #define RTL_HASH_SIZE 4093
489 struct attr_hash
*attr_hash_table
[RTL_HASH_SIZE
];
491 /* Here is how primitive or already-shared RTL's hash
493 #define RTL_HASH(RTL) ((long) (RTL) & 0777777)
495 /* Add an entry to the hash table for RTL with hash code HASHCODE. */
498 attr_hash_add_rtx (hashcode
, rtl
)
502 register struct attr_hash
*h
;
504 h
= (struct attr_hash
*) obstack_alloc (hash_obstack
,
505 sizeof (struct attr_hash
));
506 h
->hashcode
= hashcode
;
508 h
->next
= attr_hash_table
[hashcode
% RTL_HASH_SIZE
];
509 attr_hash_table
[hashcode
% RTL_HASH_SIZE
] = h
;
512 /* Add an entry to the hash table for STRING with hash code HASHCODE. */
515 attr_hash_add_string (hashcode
, str
)
519 register struct attr_hash
*h
;
521 h
= (struct attr_hash
*) obstack_alloc (hash_obstack
,
522 sizeof (struct attr_hash
));
523 h
->hashcode
= -hashcode
;
525 h
->next
= attr_hash_table
[hashcode
% RTL_HASH_SIZE
];
526 attr_hash_table
[hashcode
% RTL_HASH_SIZE
] = h
;
529 /* Generate an RTL expression, but avoid duplicates.
530 Set the RTX_INTEGRATED_P flag for these permanent objects.
532 In some cases we cannot uniquify; then we return an ordinary
533 impermanent rtx with RTX_INTEGRATED_P clear.
535 Args are like gen_rtx, but without the mode:
537 rtx attr_rtx (code, [element1, ..., elementn]) */
541 attr_rtx
VPROTO((enum rtx_code code
, ...))
547 register int i
; /* Array indices... */
548 register char *fmt
; /* Current rtx's format... */
549 register rtx rt_val
; /* RTX to return to caller... */
551 register struct attr_hash
*h
;
552 struct obstack
*old_obstack
= rtl_obstack
;
557 code
= va_arg (p
, enum rtx_code
);
560 /* For each of several cases, search the hash table for an existing entry.
561 Use that entry if one is found; otherwise create a new RTL and add it
564 if (GET_RTX_CLASS (code
) == '1')
566 rtx arg0
= va_arg (p
, rtx
);
568 /* A permanent object cannot point to impermanent ones. */
569 if (! RTX_INTEGRATED_P (arg0
))
571 rt_val
= rtx_alloc (code
);
572 XEXP (rt_val
, 0) = arg0
;
577 hashcode
= ((HOST_WIDE_INT
) code
+ RTL_HASH (arg0
));
578 for (h
= attr_hash_table
[hashcode
% RTL_HASH_SIZE
]; h
; h
= h
->next
)
579 if (h
->hashcode
== hashcode
580 && GET_CODE (h
->u
.rtl
) == code
581 && XEXP (h
->u
.rtl
, 0) == arg0
)
586 rtl_obstack
= hash_obstack
;
587 rt_val
= rtx_alloc (code
);
588 XEXP (rt_val
, 0) = arg0
;
591 else if (GET_RTX_CLASS (code
) == 'c'
592 || GET_RTX_CLASS (code
) == '2'
593 || GET_RTX_CLASS (code
) == '<')
595 rtx arg0
= va_arg (p
, rtx
);
596 rtx arg1
= va_arg (p
, rtx
);
598 /* A permanent object cannot point to impermanent ones. */
599 if (! RTX_INTEGRATED_P (arg0
) || ! RTX_INTEGRATED_P (arg1
))
601 rt_val
= rtx_alloc (code
);
602 XEXP (rt_val
, 0) = arg0
;
603 XEXP (rt_val
, 1) = arg1
;
608 hashcode
= ((HOST_WIDE_INT
) code
+ RTL_HASH (arg0
) + RTL_HASH (arg1
));
609 for (h
= attr_hash_table
[hashcode
% RTL_HASH_SIZE
]; h
; h
= h
->next
)
610 if (h
->hashcode
== hashcode
611 && GET_CODE (h
->u
.rtl
) == code
612 && XEXP (h
->u
.rtl
, 0) == arg0
613 && XEXP (h
->u
.rtl
, 1) == arg1
)
618 rtl_obstack
= hash_obstack
;
619 rt_val
= rtx_alloc (code
);
620 XEXP (rt_val
, 0) = arg0
;
621 XEXP (rt_val
, 1) = arg1
;
624 else if (GET_RTX_LENGTH (code
) == 1
625 && GET_RTX_FORMAT (code
)[0] == 's')
627 char * arg0
= va_arg (p
, char *);
629 if (code
== SYMBOL_REF
)
630 arg0
= attr_string (arg0
, strlen (arg0
));
632 hashcode
= ((HOST_WIDE_INT
) code
+ RTL_HASH (arg0
));
633 for (h
= attr_hash_table
[hashcode
% RTL_HASH_SIZE
]; h
; h
= h
->next
)
634 if (h
->hashcode
== hashcode
635 && GET_CODE (h
->u
.rtl
) == code
636 && XSTR (h
->u
.rtl
, 0) == arg0
)
641 rtl_obstack
= hash_obstack
;
642 rt_val
= rtx_alloc (code
);
643 XSTR (rt_val
, 0) = arg0
;
646 else if (GET_RTX_LENGTH (code
) == 2
647 && GET_RTX_FORMAT (code
)[0] == 's'
648 && GET_RTX_FORMAT (code
)[1] == 's')
650 char *arg0
= va_arg (p
, char *);
651 char *arg1
= va_arg (p
, char *);
653 hashcode
= ((HOST_WIDE_INT
) code
+ RTL_HASH (arg0
) + RTL_HASH (arg1
));
654 for (h
= attr_hash_table
[hashcode
% RTL_HASH_SIZE
]; h
; h
= h
->next
)
655 if (h
->hashcode
== hashcode
656 && GET_CODE (h
->u
.rtl
) == code
657 && XSTR (h
->u
.rtl
, 0) == arg0
658 && XSTR (h
->u
.rtl
, 1) == arg1
)
663 rtl_obstack
= hash_obstack
;
664 rt_val
= rtx_alloc (code
);
665 XSTR (rt_val
, 0) = arg0
;
666 XSTR (rt_val
, 1) = arg1
;
669 else if (code
== CONST_INT
)
671 HOST_WIDE_INT arg0
= va_arg (p
, HOST_WIDE_INT
);
681 rt_val
= rtx_alloc (code
); /* Allocate the storage space. */
683 fmt
= GET_RTX_FORMAT (code
); /* Find the right format... */
684 for (i
= 0; i
< GET_RTX_LENGTH (code
); i
++)
688 case '0': /* Unused field. */
691 case 'i': /* An integer? */
692 XINT (rt_val
, i
) = va_arg (p
, int);
695 case 'w': /* A wide integer? */
696 XWINT (rt_val
, i
) = va_arg (p
, HOST_WIDE_INT
);
699 case 's': /* A string? */
700 XSTR (rt_val
, i
) = va_arg (p
, char *);
703 case 'e': /* An expression? */
704 case 'u': /* An insn? Same except when printing. */
705 XEXP (rt_val
, i
) = va_arg (p
, rtx
);
708 case 'E': /* An RTX vector? */
709 XVEC (rt_val
, i
) = va_arg (p
, rtvec
);
720 rtl_obstack
= old_obstack
;
722 attr_hash_add_rtx (hashcode
, rt_val
);
723 RTX_INTEGRATED_P (rt_val
) = 1;
731 /* Create a new string printed with the printf line arguments into a space
732 of at most LEN bytes:
734 rtx attr_printf (len, format, [arg1, ..., argn]) */
740 attr_printf
VPROTO((register int len
, char *fmt
, ...))
752 len
= va_arg (p
, int);
753 fmt
= va_arg (p
, char *);
756 /* Print the string into a temporary location. */
757 str
= (char *) alloca (len
);
758 vsprintf (str
, fmt
, p
);
761 return attr_string (str
, strlen (str
));
764 #else /* not HAVE_VPRINTF */
767 attr_printf (len
, fmt
, arg1
, arg2
, arg3
)
770 char *arg1
, *arg2
, *arg3
; /* also int */
774 /* Print the string into a temporary location. */
775 str
= (char *) alloca (len
);
776 sprintf (str
, fmt
, arg1
, arg2
, arg3
);
778 return attr_string (str
, strlen (str
));
780 #endif /* not HAVE_VPRINTF */
783 attr_eq (name
, value
)
786 return attr_rtx (EQ_ATTR
, attr_string (name
, strlen (name
)),
787 attr_string (value
, strlen (value
)));
794 return XSTR (make_numeric_value (n
), 0);
797 /* Return a permanent (possibly shared) copy of a string STR (not assumed
798 to be null terminated) with LEN bytes. */
801 attr_string (str
, len
)
805 register struct attr_hash
*h
;
808 register char *new_str
;
810 /* Compute the hash code. */
811 hashcode
= (len
+ 1) * 613 + (unsigned)str
[0];
812 for (i
= 1; i
<= len
; i
+= 2)
813 hashcode
= ((hashcode
* 613) + (unsigned)str
[i
]);
815 hashcode
= -hashcode
;
817 /* Search the table for the string. */
818 for (h
= attr_hash_table
[hashcode
% RTL_HASH_SIZE
]; h
; h
= h
->next
)
819 if (h
->hashcode
== -hashcode
&& h
->u
.str
[0] == str
[0]
820 && !strncmp (h
->u
.str
, str
, len
))
821 return h
->u
.str
; /* <-- return if found. */
823 /* Not found; create a permanent copy and add it to the hash table. */
824 new_str
= (char *) obstack_alloc (hash_obstack
, len
+ 1);
825 bcopy (str
, new_str
, len
);
827 attr_hash_add_string (hashcode
, new_str
);
829 return new_str
; /* Return the new string. */
832 /* Check two rtx's for equality of contents,
833 taking advantage of the fact that if both are hashed
834 then they can't be equal unless they are the same object. */
840 return (x
== y
|| (! (RTX_INTEGRATED_P (x
) && RTX_INTEGRATED_P (y
))
841 && rtx_equal_p (x
, y
)));
844 /* Copy an attribute value expression,
845 descending to all depths, but not copying any
846 permanent hashed subexpressions. */
854 register RTX_CODE code
;
855 register char *format_ptr
;
857 /* No need to copy a permanent object. */
858 if (RTX_INTEGRATED_P (orig
))
861 code
= GET_CODE (orig
);
879 copy
= rtx_alloc (code
);
880 PUT_MODE (copy
, GET_MODE (orig
));
881 copy
->in_struct
= orig
->in_struct
;
882 copy
->volatil
= orig
->volatil
;
883 copy
->unchanging
= orig
->unchanging
;
884 copy
->integrated
= orig
->integrated
;
886 format_ptr
= GET_RTX_FORMAT (GET_CODE (copy
));
888 for (i
= 0; i
< GET_RTX_LENGTH (GET_CODE (copy
)); i
++)
890 switch (*format_ptr
++)
893 XEXP (copy
, i
) = XEXP (orig
, i
);
894 if (XEXP (orig
, i
) != NULL
)
895 XEXP (copy
, i
) = attr_copy_rtx (XEXP (orig
, i
));
900 XVEC (copy
, i
) = XVEC (orig
, i
);
901 if (XVEC (orig
, i
) != NULL
)
903 XVEC (copy
, i
) = rtvec_alloc (XVECLEN (orig
, i
));
904 for (j
= 0; j
< XVECLEN (copy
, i
); j
++)
905 XVECEXP (copy
, i
, j
) = attr_copy_rtx (XVECEXP (orig
, i
, j
));
911 XINT (copy
, i
) = XINT (orig
, i
);
915 XWINT (copy
, i
) = XWINT (orig
, i
);
920 XSTR (copy
, i
) = XSTR (orig
, i
);
930 /* Given a test expression for an attribute, ensure it is validly formed.
931 IS_CONST indicates whether the expression is constant for each compiler
932 run (a constant expression may not test any particular insn).
934 Convert (eq_attr "att" "a1,a2") to (ior (eq_attr ... ) (eq_attrq ..))
935 and (eq_attr "att" "!a1") to (not (eq_attr "att" "a1")). Do the latter
936 test first so that (eq_attr "att" "!a1,a2,a3") works as expected.
938 Update the string address in EQ_ATTR expression to be the same used
939 in the attribute (or `alternative_name') to speed up subsequent
940 `find_attr' calls and eliminate most `strcmp' calls.
942 Return the new expression, if any. */
945 check_attr_test (exp
, is_const
)
949 struct attr_desc
*attr
;
950 struct attr_value
*av
;
954 switch (GET_CODE (exp
))
957 /* Handle negation test. */
958 if (XSTR (exp
, 1)[0] == '!')
959 return check_attr_test (attr_rtx (NOT
,
960 attr_eq (XSTR (exp
, 0),
964 else if (n_comma_elts (XSTR (exp
, 1)) == 1)
966 attr
= find_attr (XSTR (exp
, 0), 0);
969 if (! strcmp (XSTR (exp
, 0), "alternative"))
971 XSTR (exp
, 0) = alternative_name
;
972 /* This can't be simplified any further. */
973 RTX_UNCHANGING_P (exp
) = 1;
977 fatal ("Unknown attribute `%s' in EQ_ATTR", XEXP (exp
, 0));
980 if (is_const
&& ! attr
->is_const
)
981 fatal ("Constant expression uses insn attribute `%s' in EQ_ATTR",
984 /* Copy this just to make it permanent,
985 so expressions using it can be permanent too. */
986 exp
= attr_eq (XSTR (exp
, 0), XSTR (exp
, 1));
988 /* It shouldn't be possible to simplify the value given to a
989 constant attribute, so don't expand this until it's time to
990 write the test expression. */
992 RTX_UNCHANGING_P (exp
) = 1;
994 if (attr
->is_numeric
)
996 for (p
= XSTR (exp
, 1); *p
; p
++)
997 if (*p
< '0' || *p
> '9')
998 fatal ("Attribute `%s' takes only numeric values",
1003 for (av
= attr
->first_value
; av
; av
= av
->next
)
1004 if (GET_CODE (av
->value
) == CONST_STRING
1005 && ! strcmp (XSTR (exp
, 1), XSTR (av
->value
, 0)))
1009 fatal ("Unknown value `%s' for `%s' attribute",
1010 XEXP (exp
, 1), XEXP (exp
, 0));
1015 /* Make an IOR tree of the possible values. */
1017 name_ptr
= XSTR (exp
, 1);
1018 while ((p
= next_comma_elt (&name_ptr
)) != NULL
)
1020 newexp
= attr_eq (XSTR (exp
, 0), p
);
1021 orexp
= insert_right_side (IOR
, orexp
, newexp
, -2, -2);
1024 return check_attr_test (orexp
, is_const
);
1032 /* Either TRUE or FALSE. */
1040 XEXP (exp
, 0) = check_attr_test (XEXP (exp
, 0), is_const
);
1041 XEXP (exp
, 1) = check_attr_test (XEXP (exp
, 1), is_const
);
1045 XEXP (exp
, 0) = check_attr_test (XEXP (exp
, 0), is_const
);
1050 fatal ("RTL operator \"%s\" not valid in constant attribute test",
1051 GET_RTX_NAME (MATCH_OPERAND
));
1052 /* These cases can't be simplified. */
1053 RTX_UNCHANGING_P (exp
) = 1;
1056 case LE
: case LT
: case GT
: case GE
:
1057 case LEU
: case LTU
: case GTU
: case GEU
:
1059 if (GET_CODE (XEXP (exp
, 0)) == SYMBOL_REF
1060 && GET_CODE (XEXP (exp
, 1)) == SYMBOL_REF
)
1061 exp
= attr_rtx (GET_CODE (exp
),
1062 attr_rtx (SYMBOL_REF
, XSTR (XEXP (exp
, 0), 0)),
1063 attr_rtx (SYMBOL_REF
, XSTR (XEXP (exp
, 1), 0)));
1064 /* These cases can't be simplified. */
1065 RTX_UNCHANGING_P (exp
) = 1;
1071 /* These cases are valid for constant attributes, but can't be
1073 exp
= attr_rtx (SYMBOL_REF
, XSTR (exp
, 0));
1074 RTX_UNCHANGING_P (exp
) = 1;
1078 fatal ("RTL operator \"%s\" not valid in attribute test",
1079 GET_RTX_NAME (GET_CODE (exp
)));
1085 /* Given an expression, ensure that it is validly formed and that all named
1086 attribute values are valid for the given attribute. Issue a fatal error
1087 if not. If no attribute is specified, assume a numeric attribute.
1089 Return a perhaps modified replacement expression for the value. */
1092 check_attr_value (exp
, attr
)
1094 struct attr_desc
*attr
;
1096 struct attr_value
*av
;
1100 switch (GET_CODE (exp
))
1103 if (attr
&& ! attr
->is_numeric
)
1104 fatal ("CONST_INT not valid for non-numeric `%s' attribute",
1107 if (INTVAL (exp
) < 0)
1108 fatal ("Negative numeric value specified for `%s' attribute",
1114 if (! strcmp (XSTR (exp
, 0), "*"))
1117 if (attr
== 0 || attr
->is_numeric
)
1120 if (attr
&& attr
->negative_ok
&& *p
== '-')
1123 if (*p
> '9' || *p
< '0')
1124 fatal ("Non-numeric value for numeric `%s' attribute",
1125 attr
? attr
->name
: "internal");
1129 for (av
= attr
->first_value
; av
; av
= av
->next
)
1130 if (GET_CODE (av
->value
) == CONST_STRING
1131 && ! strcmp (XSTR (av
->value
, 0), XSTR (exp
, 0)))
1135 fatal ("Unknown value `%s' for `%s' attribute",
1136 XSTR (exp
, 0), attr
? attr
->name
: "internal");
1141 XEXP (exp
, 0) = check_attr_test (XEXP (exp
, 0),
1142 attr
? attr
->is_const
: 0);
1143 XEXP (exp
, 1) = check_attr_value (XEXP (exp
, 1), attr
);
1144 XEXP (exp
, 2) = check_attr_value (XEXP (exp
, 2), attr
);
1149 XEXP (exp
, 0) = check_attr_value (XEXP (exp
, 0), attr
);
1150 XEXP (exp
, 1) = check_attr_value (XEXP (exp
, 1), attr
);
1154 XEXP (exp
, 0) = check_attr_value (XEXP (exp
, 0), attr
);
1158 if (XVECLEN (exp
, 0) % 2 != 0)
1159 fatal ("First operand of COND must have even length");
1161 for (i
= 0; i
< XVECLEN (exp
, 0); i
+= 2)
1163 XVECEXP (exp
, 0, i
) = check_attr_test (XVECEXP (exp
, 0, i
),
1164 attr
? attr
->is_const
: 0);
1165 XVECEXP (exp
, 0, i
+ 1)
1166 = check_attr_value (XVECEXP (exp
, 0, i
+ 1), attr
);
1169 XEXP (exp
, 1) = check_attr_value (XEXP (exp
, 1), attr
);
1173 if (attr
&& attr
->is_const
)
1174 /* A constant SYMBOL_REF is valid as a constant attribute test and
1175 is expanded later by make_canonical into a COND. */
1176 return attr_rtx (SYMBOL_REF
, XSTR (exp
, 0));
1177 /* Otherwise, fall through... */
1180 fatal ("Invalid operation `%s' for attribute value",
1181 GET_RTX_NAME (GET_CODE (exp
)));
1187 /* Given an SET_ATTR_ALTERNATIVE expression, convert to the canonical SET.
1188 It becomes a COND with each test being (eq_attr "alternative "n") */
1191 convert_set_attr_alternative (exp
, num_alt
, insn_code
, insn_index
)
1194 int insn_code
, insn_index
;
1199 if (XVECLEN (exp
, 1) != num_alt
)
1200 fatal ("Bad number of entries in SET_ATTR_ALTERNATIVE for insn %d",
1203 /* Make a COND with all tests but the last. Select the last value via the
1205 condexp
= rtx_alloc (COND
);
1206 XVEC (condexp
, 0) = rtvec_alloc ((num_alt
- 1) * 2);
1208 for (i
= 0; i
< num_alt
- 1; i
++)
1211 p
= attr_numeral (i
);
1213 XVECEXP (condexp
, 0, 2 * i
) = attr_eq (alternative_name
, p
);
1215 /* Sharing this EQ_ATTR rtl causes trouble. */
1216 XVECEXP (condexp
, 0, 2 * i
) = rtx_alloc (EQ_ATTR
);
1217 XSTR (XVECEXP (condexp
, 0, 2 * i
), 0) = alternative_name
;
1218 XSTR (XVECEXP (condexp
, 0, 2 * i
), 1) = p
;
1220 XVECEXP (condexp
, 0, 2 * i
+ 1) = XVECEXP (exp
, 1, i
);
1223 XEXP (condexp
, 1) = XVECEXP (exp
, 1, i
);
1225 return attr_rtx (SET
, attr_rtx (ATTR
, XSTR (exp
, 0)), condexp
);
1228 /* Given a SET_ATTR, convert to the appropriate SET. If a comma-separated
1229 list of values is given, convert to SET_ATTR_ALTERNATIVE first. */
1232 convert_set_attr (exp
, num_alt
, insn_code
, insn_index
)
1235 int insn_code
, insn_index
;
1242 /* See how many alternative specified. */
1243 n
= n_comma_elts (XSTR (exp
, 1));
1245 return attr_rtx (SET
,
1246 attr_rtx (ATTR
, XSTR (exp
, 0)),
1247 attr_rtx (CONST_STRING
, XSTR (exp
, 1)));
1249 newexp
= rtx_alloc (SET_ATTR_ALTERNATIVE
);
1250 XSTR (newexp
, 0) = XSTR (exp
, 0);
1251 XVEC (newexp
, 1) = rtvec_alloc (n
);
1253 /* Process each comma-separated name. */
1254 name_ptr
= XSTR (exp
, 1);
1256 while ((p
= next_comma_elt (&name_ptr
)) != NULL
)
1257 XVECEXP (newexp
, 1, n
++) = attr_rtx (CONST_STRING
, p
);
1259 return convert_set_attr_alternative (newexp
, num_alt
, insn_code
, insn_index
);
1262 /* Scan all definitions, checking for validity. Also, convert any SET_ATTR
1263 and SET_ATTR_ALTERNATIVE expressions to the corresponding SET
1269 struct insn_def
*id
;
1270 struct attr_desc
*attr
;
1274 for (id
= defs
; id
; id
= id
->next
)
1276 if (XVEC (id
->def
, id
->vec_idx
) == NULL
)
1279 for (i
= 0; i
< XVECLEN (id
->def
, id
->vec_idx
); i
++)
1281 value
= XVECEXP (id
->def
, id
->vec_idx
, i
);
1282 switch (GET_CODE (value
))
1285 if (GET_CODE (XEXP (value
, 0)) != ATTR
)
1286 fatal ("Bad attribute set in pattern %d", id
->insn_index
);
1289 case SET_ATTR_ALTERNATIVE
:
1290 value
= convert_set_attr_alternative (value
,
1291 id
->num_alternatives
,
1297 value
= convert_set_attr (value
, id
->num_alternatives
,
1298 id
->insn_code
, id
->insn_index
);
1302 fatal ("Invalid attribute code `%s' for pattern %d",
1303 GET_RTX_NAME (GET_CODE (value
)), id
->insn_index
);
1306 if ((attr
= find_attr (XSTR (XEXP (value
, 0), 0), 0)) == NULL
)
1307 fatal ("Unknown attribute `%s' for pattern number %d",
1308 XSTR (XEXP (value
, 0), 0), id
->insn_index
);
1310 XVECEXP (id
->def
, id
->vec_idx
, i
) = value
;
1311 XEXP (value
, 1) = check_attr_value (XEXP (value
, 1), attr
);
1317 /* Given a constant SYMBOL_REF expression, convert to a COND that
1318 explicitly tests each enumerated value. */
1321 convert_const_symbol_ref (exp
, attr
)
1323 struct attr_desc
*attr
;
1326 struct attr_value
*av
;
1330 for (av
= attr
->first_value
; av
; av
= av
->next
)
1333 /* Make a COND with all tests but the last, and in the original order.
1334 Select the last value via the default. Note that the attr values
1335 are constructed in reverse order. */
1337 condexp
= rtx_alloc (COND
);
1338 XVEC (condexp
, 0) = rtvec_alloc ((num_alt
- 1) * 2);
1339 av
= attr
->first_value
;
1340 XEXP (condexp
, 1) = av
->value
;
1342 for (i
= num_alt
- 2; av
= av
->next
, i
>= 0; i
--)
1347 string
= p
= (char *) oballoc (2
1348 + strlen (attr
->name
)
1349 + strlen (XSTR (av
->value
, 0)));
1350 strcpy (p
, attr
->name
);
1352 strcat (p
, XSTR (av
->value
, 0));
1353 for (; *p
!= '\0'; p
++)
1354 if (*p
>= 'a' && *p
<= 'z')
1357 value
= attr_rtx (SYMBOL_REF
, string
);
1358 RTX_UNCHANGING_P (value
) = 1;
1360 XVECEXP (condexp
, 0, 2 * i
) = attr_rtx (EQ
, exp
, value
);
1362 XVECEXP (condexp
, 0, 2 * i
+ 1) = av
->value
;
1369 /* Given a valid expression for an attribute value, remove any IF_THEN_ELSE
1370 expressions by converting them into a COND. This removes cases from this
1371 program. Also, replace an attribute value of "*" with the default attribute
1375 make_canonical (attr
, exp
)
1376 struct attr_desc
*attr
;
1382 switch (GET_CODE (exp
))
1385 exp
= make_numeric_value (INTVAL (exp
));
1389 if (! strcmp (XSTR (exp
, 0), "*"))
1391 if (attr
== 0 || attr
->default_val
== 0)
1392 fatal ("(attr_value \"*\") used in invalid context.");
1393 exp
= attr
->default_val
->value
;
1399 if (!attr
->is_const
|| RTX_UNCHANGING_P (exp
))
1401 /* The SYMBOL_REF is constant for a given run, so mark it as unchanging.
1402 This makes the COND something that won't be considered an arbitrary
1403 expression by walk_attr_value. */
1404 RTX_UNCHANGING_P (exp
) = 1;
1406 /* ??? Why do we do this? With attribute values { A B C D E }, this
1407 tends to generate (!(x==A) && !(x==B) && !(x==C) && !(x==D)) rather
1409 exp
= convert_const_symbol_ref (exp
, attr
);
1410 RTX_UNCHANGING_P (exp
) = 1;
1411 exp
= check_attr_value (exp
, attr
);
1412 /* Goto COND case since this is now a COND. Note that while the
1413 new expression is rescanned, all symbol_ref notes are marked as
1417 exp
= check_attr_value (exp
, attr
);
1422 newexp
= rtx_alloc (COND
);
1423 XVEC (newexp
, 0) = rtvec_alloc (2);
1424 XVECEXP (newexp
, 0, 0) = XEXP (exp
, 0);
1425 XVECEXP (newexp
, 0, 1) = XEXP (exp
, 1);
1427 XEXP (newexp
, 1) = XEXP (exp
, 2);
1430 /* Fall through to COND case since this is now a COND. */
1437 /* First, check for degenerate COND. */
1438 if (XVECLEN (exp
, 0) == 0)
1439 return make_canonical (attr
, XEXP (exp
, 1));
1440 defval
= XEXP (exp
, 1) = make_canonical (attr
, XEXP (exp
, 1));
1442 for (i
= 0; i
< XVECLEN (exp
, 0); i
+= 2)
1444 XVECEXP (exp
, 0, i
) = copy_boolean (XVECEXP (exp
, 0, i
));
1445 XVECEXP (exp
, 0, i
+ 1)
1446 = make_canonical (attr
, XVECEXP (exp
, 0, i
+ 1));
1447 if (! rtx_equal_p (XVECEXP (exp
, 0, i
+ 1), defval
))
1466 if (GET_CODE (exp
) == AND
|| GET_CODE (exp
) == IOR
)
1467 return attr_rtx (GET_CODE (exp
), copy_boolean (XEXP (exp
, 0)),
1468 copy_boolean (XEXP (exp
, 1)));
1472 /* Given a value and an attribute description, return a `struct attr_value *'
1473 that represents that value. This is either an existing structure, if the
1474 value has been previously encountered, or a newly-created structure.
1476 `insn_code' is the code of an insn whose attribute has the specified
1477 value (-2 if not processing an insn). We ensure that all insns for
1478 a given value have the same number of alternatives if the value checks
1481 static struct attr_value
*
1482 get_attr_value (value
, attr
, insn_code
)
1484 struct attr_desc
*attr
;
1487 struct attr_value
*av
;
1490 value
= make_canonical (attr
, value
);
1491 if (compares_alternatives_p (value
))
1493 if (insn_code
< 0 || insn_alternatives
== NULL
)
1494 fatal ("(eq_attr \"alternatives\" ...) used in non-insn context");
1496 num_alt
= insn_alternatives
[insn_code
];
1499 for (av
= attr
->first_value
; av
; av
= av
->next
)
1500 if (rtx_equal_p (value
, av
->value
)
1501 && (num_alt
== 0 || av
->first_insn
== NULL
1502 || insn_alternatives
[av
->first_insn
->insn_code
]))
1505 av
= (struct attr_value
*) oballoc (sizeof (struct attr_value
));
1507 av
->next
= attr
->first_value
;
1508 attr
->first_value
= av
;
1509 av
->first_insn
= NULL
;
1511 av
->has_asm_insn
= 0;
1516 /* After all DEFINE_DELAYs have been read in, create internal attributes
1517 to generate the required routines.
1519 First, we compute the number of delay slots for each insn (as a COND of
1520 each of the test expressions in DEFINE_DELAYs). Then, if more than one
1521 delay type is specified, we compute a similar function giving the
1522 DEFINE_DELAY ordinal for each insn.
1524 Finally, for each [DEFINE_DELAY, slot #] pair, we compute an attribute that
1525 tells whether a given insn can be in that delay slot.
1527 Normal attribute filling and optimization expands these to contain the
1528 information needed to handle delay slots. */
1533 struct delay_desc
*delay
;
1539 /* First, generate data for `num_delay_slots' function. */
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)
1549 = make_numeric_value (XVECLEN (delay
->def
, 1) / 3);
1552 make_internal_attr ("*num_delay_slots", condexp
, 0);
1554 /* If more than one delay type, do the same for computing the delay type. */
1557 condexp
= rtx_alloc (COND
);
1558 XVEC (condexp
, 0) = rtvec_alloc (num_delays
* 2);
1559 XEXP (condexp
, 1) = make_numeric_value (0);
1561 for (i
= 0, delay
= delays
; delay
; i
+= 2, delay
= delay
->next
)
1563 XVECEXP (condexp
, 0, i
) = XEXP (delay
->def
, 0);
1564 XVECEXP (condexp
, 0, i
+ 1) = make_numeric_value (delay
->num
);
1567 make_internal_attr ("*delay_type", condexp
, 1);
1570 /* For each delay possibility and delay slot, compute an eligibility
1571 attribute for non-annulled insns and for each type of annulled (annul
1572 if true and annul if false). */
1573 for (delay
= delays
; delay
; delay
= delay
->next
)
1575 for (i
= 0; i
< XVECLEN (delay
->def
, 1); i
+= 3)
1577 condexp
= XVECEXP (delay
->def
, 1, i
);
1578 if (condexp
== 0) condexp
= false_rtx
;
1579 newexp
= attr_rtx (IF_THEN_ELSE
, condexp
,
1580 make_numeric_value (1), make_numeric_value (0));
1582 p
= attr_printf (sizeof ("*delay__") + MAX_DIGITS
*2, "*delay_%d_%d",
1584 make_internal_attr (p
, newexp
, 1);
1586 if (have_annul_true
)
1588 condexp
= XVECEXP (delay
->def
, 1, i
+ 1);
1589 if (condexp
== 0) condexp
= false_rtx
;
1590 newexp
= attr_rtx (IF_THEN_ELSE
, condexp
,
1591 make_numeric_value (1),
1592 make_numeric_value (0));
1593 p
= attr_printf (sizeof ("*annul_true__") + MAX_DIGITS
*2,
1594 "*annul_true_%d_%d", delay
->num
, i
/ 3);
1595 make_internal_attr (p
, newexp
, 1);
1598 if (have_annul_false
)
1600 condexp
= XVECEXP (delay
->def
, 1, i
+ 2);
1601 if (condexp
== 0) condexp
= false_rtx
;
1602 newexp
= attr_rtx (IF_THEN_ELSE
, condexp
,
1603 make_numeric_value (1),
1604 make_numeric_value (0));
1605 p
= attr_printf (sizeof ("*annul_false__") + MAX_DIGITS
*2,
1606 "*annul_false_%d_%d", delay
->num
, i
/ 3);
1607 make_internal_attr (p
, newexp
, 1);
1613 /* This function is given a left and right side expression and an operator.
1614 Each side is a conditional expression, each alternative of which has a
1615 numerical value. The function returns another conditional expression
1616 which, for every possible set of condition values, returns a value that is
1617 the operator applied to the values of the two sides.
1619 Since this is called early, it must also support IF_THEN_ELSE. */
1622 operate_exp (op
, left
, right
)
1626 int left_value
, right_value
;
1630 /* If left is a string, apply operator to it and the right side. */
1631 if (GET_CODE (left
) == CONST_STRING
)
1633 /* If right is also a string, just perform the operation. */
1634 if (GET_CODE (right
) == CONST_STRING
)
1636 left_value
= atoi (XSTR (left
, 0));
1637 right_value
= atoi (XSTR (right
, 0));
1641 i
= left_value
+ right_value
;
1645 i
= left_value
- right_value
;
1648 case POS_MINUS_OP
: /* The positive part of LEFT - RIGHT. */
1649 if (left_value
> right_value
)
1650 i
= left_value
- right_value
;
1657 i
= left_value
| right_value
;
1661 i
= left_value
== right_value
;
1665 i
= (left_value
<< (HOST_BITS_PER_INT
/ 2)) | right_value
;
1669 if (left_value
> right_value
)
1676 if (left_value
< right_value
)
1686 if (i
== left_value
)
1688 if (i
== right_value
)
1690 return make_numeric_value (i
);
1692 else if (GET_CODE (right
) == IF_THEN_ELSE
)
1694 /* Apply recursively to all values within. */
1695 rtx newleft
= operate_exp (op
, left
, XEXP (right
, 1));
1696 rtx newright
= operate_exp (op
, left
, XEXP (right
, 2));
1697 if (rtx_equal_p (newleft
, newright
))
1699 return attr_rtx (IF_THEN_ELSE
, XEXP (right
, 0), newleft
, newright
);
1701 else if (GET_CODE (right
) == COND
)
1706 newexp
= rtx_alloc (COND
);
1707 XVEC (newexp
, 0) = rtvec_alloc (XVECLEN (right
, 0));
1708 defval
= XEXP (newexp
, 1) = operate_exp (op
, left
, XEXP (right
, 1));
1710 for (i
= 0; i
< XVECLEN (right
, 0); i
+= 2)
1712 XVECEXP (newexp
, 0, i
) = XVECEXP (right
, 0, i
);
1713 XVECEXP (newexp
, 0, i
+ 1)
1714 = operate_exp (op
, left
, XVECEXP (right
, 0, i
+ 1));
1715 if (! rtx_equal_p (XVECEXP (newexp
, 0, i
+ 1),
1720 /* If the resulting cond is trivial (all alternatives
1721 give the same value), optimize it away. */
1724 obstack_free (rtl_obstack
, newexp
);
1725 return operate_exp (op
, left
, XEXP (right
, 1));
1728 /* If the result is the same as the RIGHT operand,
1730 if (rtx_equal_p (newexp
, right
))
1732 obstack_free (rtl_obstack
, newexp
);
1739 fatal ("Badly formed attribute value");
1742 /* A hack to prevent expand_units from completely blowing up: ORX_OP does
1743 not associate through IF_THEN_ELSE. */
1744 else if (op
== ORX_OP
&& GET_CODE (right
) == IF_THEN_ELSE
)
1746 return attr_rtx (IOR
, left
, right
);
1749 /* Otherwise, do recursion the other way. */
1750 else if (GET_CODE (left
) == IF_THEN_ELSE
)
1752 rtx newleft
= operate_exp (op
, XEXP (left
, 1), right
);
1753 rtx newright
= operate_exp (op
, XEXP (left
, 2), right
);
1754 if (rtx_equal_p (newleft
, newright
))
1756 return attr_rtx (IF_THEN_ELSE
, XEXP (left
, 0), newleft
, newright
);
1758 else if (GET_CODE (left
) == COND
)
1763 newexp
= rtx_alloc (COND
);
1764 XVEC (newexp
, 0) = rtvec_alloc (XVECLEN (left
, 0));
1765 defval
= XEXP (newexp
, 1) = operate_exp (op
, XEXP (left
, 1), right
);
1767 for (i
= 0; i
< XVECLEN (left
, 0); i
+= 2)
1769 XVECEXP (newexp
, 0, i
) = XVECEXP (left
, 0, i
);
1770 XVECEXP (newexp
, 0, i
+ 1)
1771 = operate_exp (op
, XVECEXP (left
, 0, i
+ 1), right
);
1772 if (! rtx_equal_p (XVECEXP (newexp
, 0, i
+ 1),
1777 /* If the cond is trivial (all alternatives give the same value),
1778 optimize it away. */
1781 obstack_free (rtl_obstack
, newexp
);
1782 return operate_exp (op
, XEXP (left
, 1), right
);
1785 /* If the result is the same as the LEFT operand,
1787 if (rtx_equal_p (newexp
, left
))
1789 obstack_free (rtl_obstack
, newexp
);
1797 fatal ("Badly formed attribute value.");
1802 /* Once all attributes and DEFINE_FUNCTION_UNITs have been read, we
1803 construct a number of attributes.
1805 The first produces a function `function_units_used' which is given an
1806 insn and produces an encoding showing which function units are required
1807 for the execution of that insn. If the value is non-negative, the insn
1808 uses that unit; otherwise, the value is a one's compliment mask of units
1811 The second produces a function `result_ready_cost' which is used to
1812 determine the time that the result of an insn will be ready and hence
1813 a worst-case schedule.
1815 Both of these produce quite complex expressions which are then set as the
1816 default value of internal attributes. Normal attribute simplification
1817 should produce reasonable expressions.
1819 For each unit, a `<name>_unit_ready_cost' function will take an
1820 insn and give the delay until that unit will be ready with the result
1821 and a `<name>_unit_conflict_cost' function is given an insn already
1822 executing on the unit and a candidate to execute and will give the
1823 cost from the time the executing insn started until the candidate
1824 can start (ignore limitations on the number of simultaneous insns).
1826 For each unit, a `<name>_unit_blockage' function is given an insn
1827 already executing on the unit and a candidate to execute and will
1828 give the delay incurred due to function unit conflicts. The range of
1829 blockage cost values for a given executing insn is given by the
1830 `<name>_unit_blockage_range' function. These values are encoded in
1831 an int where the upper half gives the minimum value and the lower
1832 half gives the maximum value. */
1837 struct function_unit
*unit
, **unit_num
;
1838 struct function_unit_op
*op
, **op_array
, ***unit_ops
;
1843 int i
, j
, u
, num
, nvalues
;
1845 /* Rebuild the condition for the unit to share the RTL expressions.
1846 Sharing is required by simplify_by_exploding. Build the issue delay
1847 expressions. Validate the expressions we were given for the conditions
1848 and conflict vector. Then make attributes for use in the conflict
1851 for (unit
= units
; unit
; unit
= unit
->next
)
1853 unit
->condexp
= check_attr_test (unit
->condexp
, 0);
1855 for (op
= unit
->ops
; op
; op
= op
->next
)
1857 rtx issue_delay
= make_numeric_value (op
->issue_delay
);
1858 rtx issue_exp
= issue_delay
;
1860 /* Build, validate, and simplify the issue delay expression. */
1861 if (op
->conflict_exp
!= true_rtx
)
1862 issue_exp
= attr_rtx (IF_THEN_ELSE
, op
->conflict_exp
,
1863 issue_exp
, make_numeric_value (0));
1864 issue_exp
= check_attr_value (make_canonical (NULL_ATTR
,
1867 issue_exp
= simplify_knowing (issue_exp
, unit
->condexp
);
1868 op
->issue_exp
= issue_exp
;
1870 /* Make an attribute for use in the conflict function if needed. */
1871 unit
->needs_conflict_function
= (unit
->issue_delay
.min
1872 != unit
->issue_delay
.max
);
1873 if (unit
->needs_conflict_function
)
1875 str
= attr_printf (strlen (unit
->name
) + sizeof ("*_cost_") + MAX_DIGITS
,
1876 "*%s_cost_%d", unit
->name
, op
->num
);
1877 make_internal_attr (str
, issue_exp
, 1);
1880 /* Validate the condition. */
1881 op
->condexp
= check_attr_test (op
->condexp
, 0);
1885 /* Compute the mask of function units used. Initially, the unitsmask is
1886 zero. Set up a conditional to compute each unit's contribution. */
1887 unitsmask
= make_numeric_value (0);
1888 newexp
= rtx_alloc (IF_THEN_ELSE
);
1889 XEXP (newexp
, 2) = make_numeric_value (0);
1891 /* If we have just a few units, we may be all right expanding the whole
1892 thing. But the expansion is 2**N in space on the number of opclasses,
1893 so we can't do this for very long -- Alpha and MIPS in particular have
1894 problems with this. So in that situation, we fall back on an alternate
1895 implementation method. */
1896 #define NUM_UNITOP_CUTOFF 20
1898 if (num_unit_opclasses
< NUM_UNITOP_CUTOFF
)
1900 /* Merge each function unit into the unit mask attributes. */
1901 for (unit
= units
; unit
; unit
= unit
->next
)
1903 XEXP (newexp
, 0) = unit
->condexp
;
1904 XEXP (newexp
, 1) = make_numeric_value (1 << unit
->num
);
1905 unitsmask
= operate_exp (OR_OP
, unitsmask
, newexp
);
1910 /* Merge each function unit into the unit mask attributes. */
1911 for (unit
= units
; unit
; unit
= unit
->next
)
1913 XEXP (newexp
, 0) = unit
->condexp
;
1914 XEXP (newexp
, 1) = make_numeric_value (1 << unit
->num
);
1915 unitsmask
= operate_exp (ORX_OP
, unitsmask
, attr_copy_rtx (newexp
));
1919 /* Simplify the unit mask expression, encode it, and make an attribute
1920 for the function_units_used function. */
1921 unitsmask
= simplify_by_exploding (unitsmask
);
1923 if (num_unit_opclasses
< NUM_UNITOP_CUTOFF
)
1924 unitsmask
= encode_units_mask (unitsmask
);
1927 /* We can no longer encode unitsmask at compile time, so emit code to
1928 calculate it at runtime. Rather, put a marker for where we'd do
1929 the code, and actually output it in write_attr_get(). */
1930 unitsmask
= attr_rtx (FFS
, unitsmask
);
1933 make_internal_attr ("*function_units_used", unitsmask
, 2);
1935 /* Create an array of ops for each unit. Add an extra unit for the
1936 result_ready_cost function that has the ops of all other units. */
1937 unit_ops
= (struct function_unit_op
***)
1938 alloca ((num_units
+ 1) * sizeof (struct function_unit_op
**));
1939 unit_num
= (struct function_unit
**)
1940 alloca ((num_units
+ 1) * sizeof (struct function_unit
*));
1942 unit_num
[num_units
] = unit
= (struct function_unit
*)
1943 alloca (sizeof (struct function_unit
));
1944 unit
->num
= num_units
;
1945 unit
->num_opclasses
= 0;
1947 for (unit
= units
; unit
; unit
= unit
->next
)
1949 unit_num
[num_units
]->num_opclasses
+= unit
->num_opclasses
;
1950 unit_num
[unit
->num
] = unit
;
1951 unit_ops
[unit
->num
] = op_array
= (struct function_unit_op
**)
1952 alloca (unit
->num_opclasses
* sizeof (struct function_unit_op
*));
1954 for (op
= unit
->ops
; op
; op
= op
->next
)
1955 op_array
[op
->num
] = op
;
1958 /* Compose the array of ops for the extra unit. */
1959 unit_ops
[num_units
] = op_array
= (struct function_unit_op
**)
1960 alloca (unit_num
[num_units
]->num_opclasses
1961 * sizeof (struct function_unit_op
*));
1963 for (unit
= units
, i
= 0; unit
; i
+= unit
->num_opclasses
, unit
= unit
->next
)
1964 bcopy ((char *) unit_ops
[unit
->num
], (char *) &op_array
[i
],
1965 unit
->num_opclasses
* sizeof (struct function_unit_op
*));
1967 /* Compute the ready cost function for each unit by computing the
1968 condition for each non-default value. */
1969 for (u
= 0; u
<= num_units
; u
++)
1975 op_array
= unit_ops
[unit
->num
];
1976 num
= unit
->num_opclasses
;
1978 /* Sort the array of ops into increasing ready cost order. */
1979 for (i
= 0; i
< num
; i
++)
1980 for (j
= num
- 1; j
> i
; j
--)
1981 if (op_array
[j
-1]->ready
< op_array
[j
]->ready
)
1984 op_array
[j
] = op_array
[j
-1];
1988 /* Determine how many distinct non-default ready cost values there
1989 are. We use a default ready cost value of 1. */
1990 nvalues
= 0; value
= 1;
1991 for (i
= num
- 1; i
>= 0; i
--)
1992 if (op_array
[i
]->ready
> value
)
1994 value
= op_array
[i
]->ready
;
1999 readycost
= make_numeric_value (1);
2002 /* Construct the ready cost expression as a COND of each value from
2003 the largest to the smallest. */
2004 readycost
= rtx_alloc (COND
);
2005 XVEC (readycost
, 0) = rtvec_alloc (nvalues
* 2);
2006 XEXP (readycost
, 1) = make_numeric_value (1);
2008 nvalues
= 0; orexp
= false_rtx
; value
= op_array
[0]->ready
;
2009 for (i
= 0; i
< num
; i
++)
2014 else if (op
->ready
== value
)
2015 orexp
= insert_right_side (IOR
, orexp
, op
->condexp
, -2, -2);
2018 XVECEXP (readycost
, 0, nvalues
* 2) = orexp
;
2019 XVECEXP (readycost
, 0, nvalues
* 2 + 1)
2020 = make_numeric_value (value
);
2023 orexp
= op
->condexp
;
2026 XVECEXP (readycost
, 0, nvalues
* 2) = orexp
;
2027 XVECEXP (readycost
, 0, nvalues
* 2 + 1) = make_numeric_value (value
);
2032 rtx max_blockage
= 0, min_blockage
= 0;
2034 /* Simplify the readycost expression by only considering insns
2035 that use the unit. */
2036 readycost
= simplify_knowing (readycost
, unit
->condexp
);
2038 /* Determine the blockage cost the executing insn (E) given
2039 the candidate insn (C). This is the maximum of the issue
2040 delay, the pipeline delay, and the simultaneity constraint.
2041 Each function_unit_op represents the characteristics of the
2042 candidate insn, so in the expressions below, C is a known
2043 term and E is an unknown term.
2045 We compute the blockage cost for each E for every possible C.
2046 Thus OP represents E, and READYCOST is a list of values for
2049 The issue delay function for C is op->issue_exp and is used to
2050 write the `<name>_unit_conflict_cost' function. Symbolicly
2051 this is "ISSUE-DELAY (E,C)".
2053 The pipeline delay results form the FIFO constraint on the
2054 function unit and is "READY-COST (E) + 1 - READY-COST (C)".
2056 The simultaneity constraint is based on how long it takes to
2057 fill the unit given the minimum issue delay. FILL-TIME is the
2058 constant "MIN (ISSUE-DELAY (*,*)) * (SIMULTANEITY - 1)", and
2059 the simultaneity constraint is "READY-COST (E) - FILL-TIME"
2060 if SIMULTANEITY is non-zero and zero otherwise.
2062 Thus, BLOCKAGE (E,C) when SIMULTANEITY is zero is
2064 MAX (ISSUE-DELAY (E,C),
2065 READY-COST (E) - (READY-COST (C) - 1))
2069 MAX (ISSUE-DELAY (E,C),
2070 READY-COST (E) - (READY-COST (C) - 1),
2071 READY-COST (E) - FILL-TIME)
2073 The `<name>_unit_blockage' function is computed by determining
2074 this value for each candidate insn. As these values are
2075 computed, we also compute the upper and lower bounds for
2076 BLOCKAGE (E,*). These are combined to form the function
2077 `<name>_unit_blockage_range'. Finally, the maximum blockage
2078 cost, MAX (BLOCKAGE (*,*)), is computed. */
2080 for (op
= unit
->ops
; op
; op
= op
->next
)
2083 rtx blockage
= op
->issue_exp
;
2085 rtx blockage
= operate_exp (POS_MINUS_OP
, readycost
,
2086 make_numeric_value (1));
2088 if (unit
->simultaneity
!= 0)
2090 rtx filltime
= make_numeric_value ((unit
->simultaneity
- 1)
2091 * unit
->issue_delay
.min
);
2092 blockage
= operate_exp (MIN_OP
, blockage
, filltime
);
2095 blockage
= operate_exp (POS_MINUS_OP
,
2096 make_numeric_value (op
->ready
),
2099 blockage
= operate_exp (MAX_OP
, blockage
, op
->issue_exp
);
2101 blockage
= simplify_knowing (blockage
, unit
->condexp
);
2103 /* Add this op's contribution to MAX (BLOCKAGE (E,*)) and
2104 MIN (BLOCKAGE (E,*)). */
2105 if (max_blockage
== 0)
2106 max_blockage
= min_blockage
= blockage
;
2110 = simplify_knowing (operate_exp (MAX_OP
, max_blockage
,
2114 = simplify_knowing (operate_exp (MIN_OP
, min_blockage
,
2119 /* Make an attribute for use in the blockage function. */
2120 str
= attr_printf (strlen (unit
->name
) + sizeof ("*_block_") + MAX_DIGITS
,
2121 "*%s_block_%d", unit
->name
, op
->num
);
2122 make_internal_attr (str
, blockage
, 1);
2125 /* Record MAX (BLOCKAGE (*,*)). */
2126 unit
->max_blockage
= max_attr_value (max_blockage
);
2128 /* See if the upper and lower bounds of BLOCKAGE (E,*) are the
2129 same. If so, the blockage function carries no additional
2130 information and is not written. */
2131 newexp
= operate_exp (EQ_OP
, max_blockage
, min_blockage
);
2132 newexp
= simplify_knowing (newexp
, unit
->condexp
);
2133 unit
->needs_blockage_function
2134 = (GET_CODE (newexp
) != CONST_STRING
2135 || atoi (XSTR (newexp
, 0)) != 1);
2137 /* If the all values of BLOCKAGE (E,C) have the same value,
2138 neither blockage function is written. */
2139 unit
->needs_range_function
2140 = (unit
->needs_blockage_function
2141 || GET_CODE (max_blockage
) != CONST_STRING
);
2143 if (unit
->needs_range_function
)
2145 /* Compute the blockage range function and make an attribute
2146 for writing it's value. */
2147 newexp
= operate_exp (RANGE_OP
, min_blockage
, max_blockage
);
2148 newexp
= simplify_knowing (newexp
, unit
->condexp
);
2150 str
= attr_printf (strlen (unit
->name
) + sizeof ("*_unit_blockage_range"),
2151 "*%s_unit_blockage_range", unit
->name
);
2152 make_internal_attr (str
, newexp
, 4);
2155 str
= attr_printf (strlen (unit
->name
) + sizeof ("*_unit_ready_cost"),
2156 "*%s_unit_ready_cost", unit
->name
);
2159 str
= "*result_ready_cost";
2161 /* Make an attribute for the ready_cost function. Simplifying
2162 further with simplify_by_exploding doesn't win. */
2163 make_internal_attr (str
, readycost
, 0);
2166 /* For each unit that requires a conflict cost function, make an attribute
2167 that maps insns to the operation number. */
2168 for (unit
= units
; unit
; unit
= unit
->next
)
2172 if (! unit
->needs_conflict_function
2173 && ! unit
->needs_blockage_function
)
2176 caseexp
= rtx_alloc (COND
);
2177 XVEC (caseexp
, 0) = rtvec_alloc ((unit
->num_opclasses
- 1) * 2);
2179 for (op
= unit
->ops
; op
; op
= op
->next
)
2181 /* Make our adjustment to the COND being computed. If we are the
2182 last operation class, place our values into the default of the
2184 if (op
->num
== unit
->num_opclasses
- 1)
2186 XEXP (caseexp
, 1) = make_numeric_value (op
->num
);
2190 XVECEXP (caseexp
, 0, op
->num
* 2) = op
->condexp
;
2191 XVECEXP (caseexp
, 0, op
->num
* 2 + 1)
2192 = make_numeric_value (op
->num
);
2196 /* Simplifying caseexp with simplify_by_exploding doesn't win. */
2197 str
= attr_printf (strlen (unit
->name
) + sizeof ("*_cases"),
2198 "*%s_cases", unit
->name
);
2199 make_internal_attr (str
, caseexp
, 1);
2203 /* Simplify EXP given KNOWN_TRUE. */
2206 simplify_knowing (exp
, known_true
)
2207 rtx exp
, known_true
;
2209 if (GET_CODE (exp
) != CONST_STRING
)
2211 exp
= attr_rtx (IF_THEN_ELSE
, known_true
, exp
,
2212 make_numeric_value (max_attr_value (exp
)));
2213 exp
= simplify_by_exploding (exp
);
2218 /* Translate the CONST_STRING expressions in X to change the encoding of
2219 value. On input, the value is a bitmask with a one bit for each unit
2220 used; on output, the value is the unit number (zero based) if one
2221 and only one unit is used or the one's compliment of the bitmask. */
2224 encode_units_mask (x
)
2229 register enum rtx_code code
;
2232 code
= GET_CODE (x
);
2237 i
= atoi (XSTR (x
, 0));
2239 abort (); /* The sign bit encodes a one's compliment mask. */
2240 else if (i
!= 0 && i
== (i
& -i
))
2241 /* Only one bit is set, so yield that unit number. */
2242 for (j
= 0; (i
>>= 1) != 0; j
++)
2246 return attr_rtx (CONST_STRING
, attr_printf (MAX_DIGITS
, "%d", j
));
2263 /* Compare the elements. If any pair of corresponding elements
2264 fail to match, return 0 for the whole things. */
2266 fmt
= GET_RTX_FORMAT (code
);
2267 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
2273 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
2274 XVECEXP (x
, i
, j
) = encode_units_mask (XVECEXP (x
, i
, j
));
2278 XEXP (x
, i
) = encode_units_mask (XEXP (x
, i
));
2285 /* Once all attributes and insns have been read and checked, we construct for
2286 each attribute value a list of all the insns that have that value for
2291 struct attr_desc
*attr
;
2293 struct attr_value
*av
;
2294 struct insn_ent
*ie
;
2295 struct insn_def
*id
;
2299 /* Don't fill constant attributes. The value is independent of
2300 any particular insn. */
2304 for (id
= defs
; id
; id
= id
->next
)
2306 /* If no value is specified for this insn for this attribute, use the
2309 if (XVEC (id
->def
, id
->vec_idx
))
2310 for (i
= 0; i
< XVECLEN (id
->def
, id
->vec_idx
); i
++)
2311 if (! strcmp (XSTR (XEXP (XVECEXP (id
->def
, id
->vec_idx
, i
), 0), 0),
2313 value
= XEXP (XVECEXP (id
->def
, id
->vec_idx
, i
), 1);
2316 av
= attr
->default_val
;
2318 av
= get_attr_value (value
, attr
, id
->insn_code
);
2320 ie
= (struct insn_ent
*) oballoc (sizeof (struct insn_ent
));
2321 ie
->insn_code
= id
->insn_code
;
2322 ie
->insn_index
= id
->insn_code
;
2323 insert_insn_ent (av
, ie
);
2327 /* Given an expression EXP, see if it is a COND or IF_THEN_ELSE that has a
2328 test that checks relative positions of insns (uses MATCH_DUP or PC).
2329 If so, replace it with what is obtained by passing the expression to
2330 ADDRESS_FN. If not but it is a COND or IF_THEN_ELSE, call this routine
2331 recursively on each value (including the default value). Otherwise,
2332 return the value returned by NO_ADDRESS_FN applied to EXP. */
2335 substitute_address (exp
, no_address_fn
, address_fn
)
2337 rtx (*no_address_fn
) ();
2338 rtx (*address_fn
) ();
2343 if (GET_CODE (exp
) == COND
)
2345 /* See if any tests use addresses. */
2347 for (i
= 0; i
< XVECLEN (exp
, 0); i
+= 2)
2348 walk_attr_value (XVECEXP (exp
, 0, i
));
2351 return (*address_fn
) (exp
);
2353 /* Make a new copy of this COND, replacing each element. */
2354 newexp
= rtx_alloc (COND
);
2355 XVEC (newexp
, 0) = rtvec_alloc (XVECLEN (exp
, 0));
2356 for (i
= 0; i
< XVECLEN (exp
, 0); i
+= 2)
2358 XVECEXP (newexp
, 0, i
) = XVECEXP (exp
, 0, i
);
2359 XVECEXP (newexp
, 0, i
+ 1)
2360 = substitute_address (XVECEXP (exp
, 0, i
+ 1),
2361 no_address_fn
, address_fn
);
2364 XEXP (newexp
, 1) = substitute_address (XEXP (exp
, 1),
2365 no_address_fn
, address_fn
);
2370 else if (GET_CODE (exp
) == IF_THEN_ELSE
)
2373 walk_attr_value (XEXP (exp
, 0));
2375 return (*address_fn
) (exp
);
2377 return attr_rtx (IF_THEN_ELSE
,
2378 substitute_address (XEXP (exp
, 0),
2379 no_address_fn
, address_fn
),
2380 substitute_address (XEXP (exp
, 1),
2381 no_address_fn
, address_fn
),
2382 substitute_address (XEXP (exp
, 2),
2383 no_address_fn
, address_fn
));
2386 return (*no_address_fn
) (exp
);
2389 /* Make new attributes from the `length' attribute. The following are made,
2390 each corresponding to a function called from `shorten_branches' or
2393 *insn_default_length This is the length of the insn to be returned
2394 by `get_attr_length' before `shorten_branches'
2395 has been called. In each case where the length
2396 depends on relative addresses, the largest
2397 possible is used. This routine is also used
2398 to compute the initial size of the insn.
2400 *insn_variable_length_p This returns 1 if the insn's length depends
2401 on relative addresses, zero otherwise.
2403 *insn_current_length This is only called when it is known that the
2404 insn has a variable length and returns the
2405 current length, based on relative addresses.
2409 make_length_attrs ()
2411 static char *new_names
[] = {"*insn_default_length",
2412 "*insn_variable_length_p",
2413 "*insn_current_length"};
2414 static rtx (*no_address_fn
[]) PROTO((rtx
)) = {identity_fn
, zero_fn
, zero_fn
};
2415 static rtx (*address_fn
[]) PROTO((rtx
)) = {max_fn
, one_fn
, identity_fn
};
2417 struct attr_desc
*length_attr
, *new_attr
;
2418 struct attr_value
*av
, *new_av
;
2419 struct insn_ent
*ie
, *new_ie
;
2421 /* See if length attribute is defined. If so, it must be numeric. Make
2422 it special so we don't output anything for it. */
2423 length_attr
= find_attr ("length", 0);
2424 if (length_attr
== 0)
2427 if (! length_attr
->is_numeric
)
2428 fatal ("length attribute must be numeric.");
2430 length_attr
->is_const
= 0;
2431 length_attr
->is_special
= 1;
2433 /* Make each new attribute, in turn. */
2434 for (i
= 0; i
< sizeof new_names
/ sizeof new_names
[0]; i
++)
2436 make_internal_attr (new_names
[i
],
2437 substitute_address (length_attr
->default_val
->value
,
2438 no_address_fn
[i
], address_fn
[i
]),
2440 new_attr
= find_attr (new_names
[i
], 0);
2441 for (av
= length_attr
->first_value
; av
; av
= av
->next
)
2442 for (ie
= av
->first_insn
; ie
; ie
= ie
->next
)
2444 new_av
= get_attr_value (substitute_address (av
->value
,
2447 new_attr
, ie
->insn_code
);
2448 new_ie
= (struct insn_ent
*) oballoc (sizeof (struct insn_ent
));
2449 new_ie
->insn_code
= ie
->insn_code
;
2450 new_ie
->insn_index
= ie
->insn_index
;
2451 insert_insn_ent (new_av
, new_ie
);
2456 /* Utility functions called from above routine. */
2469 return make_numeric_value (0);
2476 return make_numeric_value (1);
2483 return make_numeric_value (max_attr_value (exp
));
2487 write_length_unit_log ()
2489 struct attr_desc
*length_attr
= find_attr ("length", 0);
2490 struct attr_value
*av
;
2491 struct insn_ent
*ie
;
2492 unsigned int length_unit_log
, length_or
;
2494 if (length_attr
== 0)
2496 length_or
= or_attr_value (length_attr
->default_val
->value
);
2497 for (av
= length_attr
->first_value
; av
; av
= av
->next
)
2498 for (ie
= av
->first_insn
; ie
; ie
= ie
->next
)
2499 length_or
|= or_attr_value (av
->value
);
2500 length_or
= ~length_or
;
2501 for (length_unit_log
= 0; length_or
& 1; length_or
>>= 1)
2503 printf ("int length_unit_log = %u;\n", length_unit_log
);
2506 /* Take a COND expression and see if any of the conditions in it can be
2507 simplified. If any are known true or known false for the particular insn
2508 code, the COND can be further simplified.
2510 Also call ourselves on any COND operations that are values of this COND.
2512 We do not modify EXP; rather, we make and return a new rtx. */
2515 simplify_cond (exp
, insn_code
, insn_index
)
2517 int insn_code
, insn_index
;
2520 /* We store the desired contents here,
2521 then build a new expression if they don't match EXP. */
2522 rtx defval
= XEXP (exp
, 1);
2523 rtx new_defval
= XEXP (exp
, 1);
2524 int len
= XVECLEN (exp
, 0);
2525 rtunion
*tests
= (rtunion
*) alloca (len
* sizeof (rtunion
));
2529 /* This lets us free all storage allocated below, if appropriate. */
2530 first_spacer
= (char *) obstack_finish (rtl_obstack
);
2532 bcopy ((char *) XVEC (exp
, 0)->elem
, (char *) tests
, len
* sizeof (rtunion
));
2534 /* See if default value needs simplification. */
2535 if (GET_CODE (defval
) == COND
)
2536 new_defval
= simplify_cond (defval
, insn_code
, insn_index
);
2538 /* Simplify the subexpressions, and see what tests we can get rid of. */
2540 for (i
= 0; i
< len
; i
+= 2)
2542 rtx newtest
, newval
;
2544 /* Simplify this test. */
2545 newtest
= SIMPLIFY_TEST_EXP (tests
[i
].rtx
, insn_code
, insn_index
);
2546 tests
[i
].rtx
= newtest
;
2548 newval
= tests
[i
+ 1].rtx
;
2549 /* See if this value may need simplification. */
2550 if (GET_CODE (newval
) == COND
)
2551 newval
= simplify_cond (newval
, insn_code
, insn_index
);
2553 /* Look for ways to delete or combine this test. */
2554 if (newtest
== true_rtx
)
2556 /* If test is true, make this value the default
2557 and discard this + any following tests. */
2559 defval
= tests
[i
+ 1].rtx
;
2560 new_defval
= newval
;
2563 else if (newtest
== false_rtx
)
2565 /* If test is false, discard it and its value. */
2566 for (j
= i
; j
< len
- 2; j
++)
2567 tests
[j
].rtx
= tests
[j
+ 2].rtx
;
2571 else if (i
> 0 && attr_equal_p (newval
, tests
[i
- 1].rtx
))
2573 /* If this value and the value for the prev test are the same,
2577 = insert_right_side (IOR
, tests
[i
- 2].rtx
, newtest
,
2578 insn_code
, insn_index
);
2580 /* Delete this test/value. */
2581 for (j
= i
; j
< len
- 2; j
++)
2582 tests
[j
].rtx
= tests
[j
+ 2].rtx
;
2587 tests
[i
+ 1].rtx
= newval
;
2590 /* If the last test in a COND has the same value
2591 as the default value, that test isn't needed. */
2593 while (len
> 0 && attr_equal_p (tests
[len
- 1].rtx
, new_defval
))
2596 /* See if we changed anything. */
2597 if (len
!= XVECLEN (exp
, 0) || new_defval
!= XEXP (exp
, 1))
2600 for (i
= 0; i
< len
; i
++)
2601 if (! attr_equal_p (tests
[i
].rtx
, XVECEXP (exp
, 0, i
)))
2609 obstack_free (rtl_obstack
, first_spacer
);
2610 if (GET_CODE (defval
) == COND
)
2611 return simplify_cond (defval
, insn_code
, insn_index
);
2616 obstack_free (rtl_obstack
, first_spacer
);
2621 rtx newexp
= rtx_alloc (COND
);
2623 XVEC (newexp
, 0) = rtvec_alloc (len
);
2624 bcopy ((char *) tests
, (char *) XVEC (newexp
, 0)->elem
,
2625 len
* sizeof (rtunion
));
2626 XEXP (newexp
, 1) = new_defval
;
2631 /* Remove an insn entry from an attribute value. */
2634 remove_insn_ent (av
, ie
)
2635 struct attr_value
*av
;
2636 struct insn_ent
*ie
;
2638 struct insn_ent
*previe
;
2640 if (av
->first_insn
== ie
)
2641 av
->first_insn
= ie
->next
;
2644 for (previe
= av
->first_insn
; previe
->next
!= ie
; previe
= previe
->next
)
2646 previe
->next
= ie
->next
;
2650 if (ie
->insn_code
== -1)
2651 av
->has_asm_insn
= 0;
2656 /* Insert an insn entry in an attribute value list. */
2659 insert_insn_ent (av
, ie
)
2660 struct attr_value
*av
;
2661 struct insn_ent
*ie
;
2663 ie
->next
= av
->first_insn
;
2664 av
->first_insn
= ie
;
2666 if (ie
->insn_code
== -1)
2667 av
->has_asm_insn
= 1;
2672 /* This is a utility routine to take an expression that is a tree of either
2673 AND or IOR expressions and insert a new term. The new term will be
2674 inserted at the right side of the first node whose code does not match
2675 the root. A new node will be created with the root's code. Its left
2676 side will be the old right side and its right side will be the new
2679 If the `term' is itself a tree, all its leaves will be inserted. */
2682 insert_right_side (code
, exp
, term
, insn_code
, insn_index
)
2686 int insn_code
, insn_index
;
2690 /* Avoid consing in some special cases. */
2691 if (code
== AND
&& term
== true_rtx
)
2693 if (code
== AND
&& term
== false_rtx
)
2695 if (code
== AND
&& exp
== true_rtx
)
2697 if (code
== AND
&& exp
== false_rtx
)
2699 if (code
== IOR
&& term
== true_rtx
)
2701 if (code
== IOR
&& term
== false_rtx
)
2703 if (code
== IOR
&& exp
== true_rtx
)
2705 if (code
== IOR
&& exp
== false_rtx
)
2707 if (attr_equal_p (exp
, term
))
2710 if (GET_CODE (term
) == code
)
2712 exp
= insert_right_side (code
, exp
, XEXP (term
, 0),
2713 insn_code
, insn_index
);
2714 exp
= insert_right_side (code
, exp
, XEXP (term
, 1),
2715 insn_code
, insn_index
);
2720 if (GET_CODE (exp
) == code
)
2722 rtx
new = insert_right_side (code
, XEXP (exp
, 1),
2723 term
, insn_code
, insn_index
);
2724 if (new != XEXP (exp
, 1))
2725 /* Make a copy of this expression and call recursively. */
2726 newexp
= attr_rtx (code
, XEXP (exp
, 0), new);
2732 /* Insert the new term. */
2733 newexp
= attr_rtx (code
, exp
, term
);
2736 return SIMPLIFY_TEST_EXP (newexp
, insn_code
, insn_index
);
2739 /* If we have an expression which AND's a bunch of
2740 (not (eq_attrq "alternative" "n"))
2741 terms, we may have covered all or all but one of the possible alternatives.
2742 If so, we can optimize. Similarly for IOR's of EQ_ATTR.
2744 This routine is passed an expression and either AND or IOR. It returns a
2745 bitmask indicating which alternatives are mentioned within EXP. */
2748 compute_alternative_mask (exp
, code
)
2753 if (GET_CODE (exp
) == code
)
2754 return compute_alternative_mask (XEXP (exp
, 0), code
)
2755 | compute_alternative_mask (XEXP (exp
, 1), code
);
2757 else if (code
== AND
&& GET_CODE (exp
) == NOT
2758 && GET_CODE (XEXP (exp
, 0)) == EQ_ATTR
2759 && XSTR (XEXP (exp
, 0), 0) == alternative_name
)
2760 string
= XSTR (XEXP (exp
, 0), 1);
2762 else if (code
== IOR
&& GET_CODE (exp
) == EQ_ATTR
2763 && XSTR (exp
, 0) == alternative_name
)
2764 string
= XSTR (exp
, 1);
2770 return 1 << (string
[0] - '0');
2771 return 1 << atoi (string
);
2774 /* Given I, a single-bit mask, return RTX to compare the `alternative'
2775 attribute with the value represented by that bit. */
2778 make_alternative_compare (mask
)
2785 for (i
= 0; (mask
& (1 << i
)) == 0; i
++)
2788 newexp
= attr_rtx (EQ_ATTR
, alternative_name
, attr_numeral (i
));
2789 RTX_UNCHANGING_P (newexp
) = 1;
2794 /* If we are processing an (eq_attr "attr" "value") test, we find the value
2795 of "attr" for this insn code. From that value, we can compute a test
2796 showing when the EQ_ATTR will be true. This routine performs that
2797 computation. If a test condition involves an address, we leave the EQ_ATTR
2798 intact because addresses are only valid for the `length' attribute.
2800 EXP is the EQ_ATTR expression and VALUE is the value of that attribute
2801 for the insn corresponding to INSN_CODE and INSN_INDEX. */
2804 evaluate_eq_attr (exp
, value
, insn_code
, insn_index
)
2807 int insn_code
, insn_index
;
2814 if (GET_CODE (value
) == CONST_STRING
)
2816 if (! strcmp (XSTR (value
, 0), XSTR (exp
, 1)))
2821 else if (GET_CODE (value
) == SYMBOL_REF
)
2825 if (GET_CODE (exp
) != EQ_ATTR
)
2828 string
= (char *) alloca (2 + strlen (XSTR (exp
, 0))
2829 + strlen (XSTR (exp
, 1)));
2830 strcpy (string
, XSTR (exp
, 0));
2831 strcat (string
, "_");
2832 strcat (string
, XSTR (exp
, 1));
2833 for (p
= string
; *p
; p
++)
2834 if (*p
>= 'a' && *p
<= 'z')
2837 newexp
= attr_rtx (EQ
, value
,
2838 attr_rtx (SYMBOL_REF
,
2839 attr_string(string
, strlen(string
))));
2841 else if (GET_CODE (value
) == COND
)
2843 /* We construct an IOR of all the cases for which the requested attribute
2844 value is present. Since we start with FALSE, if it is not present,
2845 FALSE will be returned.
2847 Each case is the AND of the NOT's of the previous conditions with the
2848 current condition; in the default case the current condition is TRUE.
2850 For each possible COND value, call ourselves recursively.
2852 The extra TRUE and FALSE expressions will be eliminated by another
2853 call to the simplification routine. */
2858 if (current_alternative_string
)
2859 clear_struct_flag (value
);
2861 for (i
= 0; i
< XVECLEN (value
, 0); i
+= 2)
2863 rtx
this = SIMPLIFY_TEST_EXP (XVECEXP (value
, 0, i
),
2864 insn_code
, insn_index
);
2866 SIMPLIFY_ALTERNATIVE (this);
2868 right
= insert_right_side (AND
, andexp
, this,
2869 insn_code
, insn_index
);
2870 right
= insert_right_side (AND
, right
,
2871 evaluate_eq_attr (exp
,
2874 insn_code
, insn_index
),
2875 insn_code
, insn_index
);
2876 orexp
= insert_right_side (IOR
, orexp
, right
,
2877 insn_code
, insn_index
);
2879 /* Add this condition into the AND expression. */
2880 newexp
= attr_rtx (NOT
, this);
2881 andexp
= insert_right_side (AND
, andexp
, newexp
,
2882 insn_code
, insn_index
);
2885 /* Handle the default case. */
2886 right
= insert_right_side (AND
, andexp
,
2887 evaluate_eq_attr (exp
, XEXP (value
, 1),
2888 insn_code
, insn_index
),
2889 insn_code
, insn_index
);
2890 newexp
= insert_right_side (IOR
, orexp
, right
, insn_code
, insn_index
);
2895 /* If uses an address, must return original expression. But set the
2896 RTX_UNCHANGING_P bit so we don't try to simplify it again. */
2899 walk_attr_value (newexp
);
2903 /* This had `&& current_alternative_string', which seems to be wrong. */
2904 if (! RTX_UNCHANGING_P (exp
))
2905 return copy_rtx_unchanging (exp
);
2912 /* This routine is called when an AND of a term with a tree of AND's is
2913 encountered. If the term or its complement is present in the tree, it
2914 can be replaced with TRUE or FALSE, respectively.
2916 Note that (eq_attr "att" "v1") and (eq_attr "att" "v2") cannot both
2917 be true and hence are complementary.
2919 There is one special case: If we see
2920 (and (not (eq_attr "att" "v1"))
2921 (eq_attr "att" "v2"))
2922 this can be replaced by (eq_attr "att" "v2"). To do this we need to
2923 replace the term, not anything in the AND tree. So we pass a pointer to
2927 simplify_and_tree (exp
, pterm
, insn_code
, insn_index
)
2930 int insn_code
, insn_index
;
2935 int left_eliminates_term
, right_eliminates_term
;
2937 if (GET_CODE (exp
) == AND
)
2939 left
= simplify_and_tree (XEXP (exp
, 0), pterm
, insn_code
, insn_index
);
2940 right
= simplify_and_tree (XEXP (exp
, 1), pterm
, insn_code
, insn_index
);
2941 if (left
!= XEXP (exp
, 0) || right
!= XEXP (exp
, 1))
2943 newexp
= attr_rtx (GET_CODE (exp
), left
, right
);
2945 exp
= SIMPLIFY_TEST_EXP (newexp
, insn_code
, insn_index
);
2949 else if (GET_CODE (exp
) == IOR
)
2951 /* For the IOR case, we do the same as above, except that we can
2952 only eliminate `term' if both sides of the IOR would do so. */
2954 left
= simplify_and_tree (XEXP (exp
, 0), &temp
, insn_code
, insn_index
);
2955 left_eliminates_term
= (temp
== true_rtx
);
2958 right
= simplify_and_tree (XEXP (exp
, 1), &temp
, insn_code
, insn_index
);
2959 right_eliminates_term
= (temp
== true_rtx
);
2961 if (left_eliminates_term
&& right_eliminates_term
)
2964 if (left
!= XEXP (exp
, 0) || right
!= XEXP (exp
, 1))
2966 newexp
= attr_rtx (GET_CODE (exp
), left
, right
);
2968 exp
= SIMPLIFY_TEST_EXP (newexp
, insn_code
, insn_index
);
2972 /* Check for simplifications. Do some extra checking here since this
2973 routine is called so many times. */
2978 else if (GET_CODE (exp
) == NOT
&& XEXP (exp
, 0) == *pterm
)
2981 else if (GET_CODE (*pterm
) == NOT
&& exp
== XEXP (*pterm
, 0))
2984 else if (GET_CODE (exp
) == EQ_ATTR
&& GET_CODE (*pterm
) == EQ_ATTR
)
2986 if (XSTR (exp
, 0) != XSTR (*pterm
, 0))
2989 if (! strcmp (XSTR (exp
, 1), XSTR (*pterm
, 1)))
2995 else if (GET_CODE (*pterm
) == EQ_ATTR
&& GET_CODE (exp
) == NOT
2996 && GET_CODE (XEXP (exp
, 0)) == EQ_ATTR
)
2998 if (XSTR (*pterm
, 0) != XSTR (XEXP (exp
, 0), 0))
3001 if (! strcmp (XSTR (*pterm
, 1), XSTR (XEXP (exp
, 0), 1)))
3007 else if (GET_CODE (exp
) == EQ_ATTR
&& GET_CODE (*pterm
) == NOT
3008 && GET_CODE (XEXP (*pterm
, 0)) == EQ_ATTR
)
3010 if (XSTR (exp
, 0) != XSTR (XEXP (*pterm
, 0), 0))
3013 if (! strcmp (XSTR (exp
, 1), XSTR (XEXP (*pterm
, 0), 1)))
3019 else if (GET_CODE (exp
) == NOT
&& GET_CODE (*pterm
) == NOT
)
3021 if (attr_equal_p (XEXP (exp
, 0), XEXP (*pterm
, 0)))
3025 else if (GET_CODE (exp
) == NOT
)
3027 if (attr_equal_p (XEXP (exp
, 0), *pterm
))
3031 else if (GET_CODE (*pterm
) == NOT
)
3033 if (attr_equal_p (XEXP (*pterm
, 0), exp
))
3037 else if (attr_equal_p (exp
, *pterm
))
3043 /* Similar to `simplify_and_tree', but for IOR trees. */
3046 simplify_or_tree (exp
, pterm
, insn_code
, insn_index
)
3049 int insn_code
, insn_index
;
3054 int left_eliminates_term
, right_eliminates_term
;
3056 if (GET_CODE (exp
) == IOR
)
3058 left
= simplify_or_tree (XEXP (exp
, 0), pterm
, insn_code
, insn_index
);
3059 right
= simplify_or_tree (XEXP (exp
, 1), pterm
, insn_code
, insn_index
);
3060 if (left
!= XEXP (exp
, 0) || right
!= XEXP (exp
, 1))
3062 newexp
= attr_rtx (GET_CODE (exp
), left
, right
);
3064 exp
= SIMPLIFY_TEST_EXP (newexp
, insn_code
, insn_index
);
3068 else if (GET_CODE (exp
) == AND
)
3070 /* For the AND case, we do the same as above, except that we can
3071 only eliminate `term' if both sides of the AND would do so. */
3073 left
= simplify_or_tree (XEXP (exp
, 0), &temp
, insn_code
, insn_index
);
3074 left_eliminates_term
= (temp
== false_rtx
);
3077 right
= simplify_or_tree (XEXP (exp
, 1), &temp
, insn_code
, insn_index
);
3078 right_eliminates_term
= (temp
== false_rtx
);
3080 if (left_eliminates_term
&& right_eliminates_term
)
3083 if (left
!= XEXP (exp
, 0) || right
!= XEXP (exp
, 1))
3085 newexp
= attr_rtx (GET_CODE (exp
), left
, right
);
3087 exp
= SIMPLIFY_TEST_EXP (newexp
, insn_code
, insn_index
);
3091 if (attr_equal_p (exp
, *pterm
))
3094 else if (GET_CODE (exp
) == NOT
&& attr_equal_p (XEXP (exp
, 0), *pterm
))
3097 else if (GET_CODE (*pterm
) == NOT
&& attr_equal_p (XEXP (*pterm
, 0), exp
))
3100 else if (GET_CODE (*pterm
) == EQ_ATTR
&& GET_CODE (exp
) == NOT
3101 && GET_CODE (XEXP (exp
, 0)) == EQ_ATTR
3102 && XSTR (*pterm
, 0) == XSTR (XEXP (exp
, 0), 0))
3105 else if (GET_CODE (exp
) == EQ_ATTR
&& GET_CODE (*pterm
) == NOT
3106 && GET_CODE (XEXP (*pterm
, 0)) == EQ_ATTR
3107 && XSTR (exp
, 0) == XSTR (XEXP (*pterm
, 0), 0))
3113 /* Given an expression, see if it can be simplified for a particular insn
3114 code based on the values of other attributes being tested. This can
3115 eliminate nested get_attr_... calls.
3117 Note that if an endless recursion is specified in the patterns, the
3118 optimization will loop. However, it will do so in precisely the cases where
3119 an infinite recursion loop could occur during compilation. It's better that
3123 simplify_test_exp (exp
, insn_code
, insn_index
)
3125 int insn_code
, insn_index
;
3128 struct attr_desc
*attr
;
3129 struct attr_value
*av
;
3130 struct insn_ent
*ie
;
3133 char *spacer
= (char *) obstack_finish (rtl_obstack
);
3135 /* Don't re-simplify something we already simplified. */
3136 if (RTX_UNCHANGING_P (exp
) || MEM_IN_STRUCT_P (exp
))
3139 switch (GET_CODE (exp
))
3142 left
= SIMPLIFY_TEST_EXP (XEXP (exp
, 0), insn_code
, insn_index
);
3143 SIMPLIFY_ALTERNATIVE (left
);
3144 if (left
== false_rtx
)
3146 obstack_free (rtl_obstack
, spacer
);
3149 right
= SIMPLIFY_TEST_EXP (XEXP (exp
, 1), insn_code
, insn_index
);
3150 SIMPLIFY_ALTERNATIVE (right
);
3151 if (left
== false_rtx
)
3153 obstack_free (rtl_obstack
, spacer
);
3157 /* If either side is an IOR and we have (eq_attr "alternative" ..")
3158 present on both sides, apply the distributive law since this will
3159 yield simplifications. */
3160 if ((GET_CODE (left
) == IOR
|| GET_CODE (right
) == IOR
)
3161 && compute_alternative_mask (left
, IOR
)
3162 && compute_alternative_mask (right
, IOR
))
3164 if (GET_CODE (left
) == IOR
)
3171 newexp
= attr_rtx (IOR
,
3172 attr_rtx (AND
, left
, XEXP (right
, 0)),
3173 attr_rtx (AND
, left
, XEXP (right
, 1)));
3175 return SIMPLIFY_TEST_EXP (newexp
, insn_code
, insn_index
);
3178 /* Try with the term on both sides. */
3179 right
= simplify_and_tree (right
, &left
, insn_code
, insn_index
);
3180 if (left
== XEXP (exp
, 0) && right
== XEXP (exp
, 1))
3181 left
= simplify_and_tree (left
, &right
, insn_code
, insn_index
);
3183 if (left
== false_rtx
|| right
== false_rtx
)
3185 obstack_free (rtl_obstack
, spacer
);
3188 else if (left
== true_rtx
)
3192 else if (right
== true_rtx
)
3196 /* See if all or all but one of the insn's alternatives are specified
3197 in this tree. Optimize if so. */
3199 else if (insn_code
>= 0
3200 && (GET_CODE (left
) == AND
3201 || (GET_CODE (left
) == NOT
3202 && GET_CODE (XEXP (left
, 0)) == EQ_ATTR
3203 && XSTR (XEXP (left
, 0), 0) == alternative_name
)
3204 || GET_CODE (right
) == AND
3205 || (GET_CODE (right
) == NOT
3206 && GET_CODE (XEXP (right
, 0)) == EQ_ATTR
3207 && XSTR (XEXP (right
, 0), 0) == alternative_name
)))
3209 i
= compute_alternative_mask (exp
, AND
);
3210 if (i
& ~insn_alternatives
[insn_code
])
3211 fatal ("Invalid alternative specified for pattern number %d",
3214 /* If all alternatives are excluded, this is false. */
3215 i
^= insn_alternatives
[insn_code
];
3218 else if ((i
& (i
- 1)) == 0 && insn_alternatives
[insn_code
] > 1)
3220 /* If just one excluded, AND a comparison with that one to the
3221 front of the tree. The others will be eliminated by
3222 optimization. We do not want to do this if the insn has one
3223 alternative and we have tested none of them! */
3224 left
= make_alternative_compare (i
);
3225 right
= simplify_and_tree (exp
, &left
, insn_code
, insn_index
);
3226 newexp
= attr_rtx (AND
, left
, right
);
3228 return SIMPLIFY_TEST_EXP (newexp
, insn_code
, insn_index
);
3232 if (left
!= XEXP (exp
, 0) || right
!= XEXP (exp
, 1))
3234 newexp
= attr_rtx (AND
, left
, right
);
3235 return SIMPLIFY_TEST_EXP (newexp
, insn_code
, insn_index
);
3240 left
= SIMPLIFY_TEST_EXP (XEXP (exp
, 0), insn_code
, insn_index
);
3241 SIMPLIFY_ALTERNATIVE (left
);
3242 if (left
== true_rtx
)
3244 obstack_free (rtl_obstack
, spacer
);
3247 right
= SIMPLIFY_TEST_EXP (XEXP (exp
, 1), insn_code
, insn_index
);
3248 SIMPLIFY_ALTERNATIVE (right
);
3249 if (right
== true_rtx
)
3251 obstack_free (rtl_obstack
, spacer
);
3255 right
= simplify_or_tree (right
, &left
, insn_code
, insn_index
);
3256 if (left
== XEXP (exp
, 0) && right
== XEXP (exp
, 1))
3257 left
= simplify_or_tree (left
, &right
, insn_code
, insn_index
);
3259 if (right
== true_rtx
|| left
== true_rtx
)
3261 obstack_free (rtl_obstack
, spacer
);
3264 else if (left
== false_rtx
)
3268 else if (right
== false_rtx
)
3273 /* Test for simple cases where the distributive law is useful. I.e.,
3274 convert (ior (and (x) (y))
3280 else if (GET_CODE (left
) == AND
&& GET_CODE (right
) == AND
3281 && attr_equal_p (XEXP (left
, 0), XEXP (right
, 0)))
3283 newexp
= attr_rtx (IOR
, XEXP (left
, 1), XEXP (right
, 1));
3285 left
= XEXP (left
, 0);
3287 newexp
= attr_rtx (AND
, left
, right
);
3288 return SIMPLIFY_TEST_EXP (newexp
, insn_code
, insn_index
);
3291 /* See if all or all but one of the insn's alternatives are specified
3292 in this tree. Optimize if so. */
3294 else if (insn_code
>= 0
3295 && (GET_CODE (left
) == IOR
3296 || (GET_CODE (left
) == EQ_ATTR
3297 && XSTR (left
, 0) == alternative_name
)
3298 || GET_CODE (right
) == IOR
3299 || (GET_CODE (right
) == EQ_ATTR
3300 && XSTR (right
, 0) == alternative_name
)))
3302 i
= compute_alternative_mask (exp
, IOR
);
3303 if (i
& ~insn_alternatives
[insn_code
])
3304 fatal ("Invalid alternative specified for pattern number %d",
3307 /* If all alternatives are included, this is true. */
3308 i
^= insn_alternatives
[insn_code
];
3311 else if ((i
& (i
- 1)) == 0 && insn_alternatives
[insn_code
] > 1)
3313 /* If just one excluded, IOR a comparison with that one to the
3314 front of the tree. The others will be eliminated by
3315 optimization. We do not want to do this if the insn has one
3316 alternative and we have tested none of them! */
3317 left
= make_alternative_compare (i
);
3318 right
= simplify_and_tree (exp
, &left
, insn_code
, insn_index
);
3319 newexp
= attr_rtx (IOR
, attr_rtx (NOT
, left
), right
);
3321 return SIMPLIFY_TEST_EXP (newexp
, insn_code
, insn_index
);
3325 if (left
!= XEXP (exp
, 0) || right
!= XEXP (exp
, 1))
3327 newexp
= attr_rtx (IOR
, left
, right
);
3328 return SIMPLIFY_TEST_EXP (newexp
, insn_code
, insn_index
);
3333 if (GET_CODE (XEXP (exp
, 0)) == NOT
)
3335 left
= SIMPLIFY_TEST_EXP (XEXP (XEXP (exp
, 0), 0),
3336 insn_code
, insn_index
);
3337 SIMPLIFY_ALTERNATIVE (left
);
3341 left
= SIMPLIFY_TEST_EXP (XEXP (exp
, 0), insn_code
, insn_index
);
3342 SIMPLIFY_ALTERNATIVE (left
);
3343 if (GET_CODE (left
) == NOT
)
3344 return XEXP (left
, 0);
3346 if (left
== false_rtx
)
3348 obstack_free (rtl_obstack
, spacer
);
3351 else if (left
== true_rtx
)
3353 obstack_free (rtl_obstack
, spacer
);
3357 /* Try to apply De`Morgan's laws. */
3358 else if (GET_CODE (left
) == IOR
)
3360 newexp
= attr_rtx (AND
,
3361 attr_rtx (NOT
, XEXP (left
, 0)),
3362 attr_rtx (NOT
, XEXP (left
, 1)));
3364 newexp
= SIMPLIFY_TEST_EXP (newexp
, insn_code
, insn_index
);
3366 else if (GET_CODE (left
) == AND
)
3368 newexp
= attr_rtx (IOR
,
3369 attr_rtx (NOT
, XEXP (left
, 0)),
3370 attr_rtx (NOT
, XEXP (left
, 1)));
3372 newexp
= SIMPLIFY_TEST_EXP (newexp
, insn_code
, insn_index
);
3374 else if (left
!= XEXP (exp
, 0))
3376 newexp
= attr_rtx (NOT
, left
);
3381 if (current_alternative_string
&& XSTR (exp
, 0) == alternative_name
)
3382 return (XSTR (exp
, 1) == current_alternative_string
3383 ? true_rtx
: false_rtx
);
3385 /* Look at the value for this insn code in the specified attribute.
3386 We normally can replace this comparison with the condition that
3387 would give this insn the values being tested for. */
3388 if (XSTR (exp
, 0) != alternative_name
3389 && (attr
= find_attr (XSTR (exp
, 0), 0)) != NULL
)
3390 for (av
= attr
->first_value
; av
; av
= av
->next
)
3391 for (ie
= av
->first_insn
; ie
; ie
= ie
->next
)
3392 if (ie
->insn_code
== insn_code
)
3393 return evaluate_eq_attr (exp
, av
->value
, insn_code
, insn_index
);
3400 /* We have already simplified this expression. Simplifying it again
3401 won't buy anything unless we weren't given a valid insn code
3402 to process (i.e., we are canonicalizing something.). */
3403 if (insn_code
!= -2 /* Seems wrong: && current_alternative_string. */
3404 && ! RTX_UNCHANGING_P (newexp
))
3405 return copy_rtx_unchanging (newexp
);
3410 /* Optimize the attribute lists by seeing if we can determine conditional
3411 values from the known values of other attributes. This will save subroutine
3412 calls during the compilation. */
3417 struct attr_desc
*attr
;
3418 struct attr_value
*av
;
3419 struct insn_ent
*ie
;
3421 int something_changed
= 1;
3423 struct attr_value_list
{ struct attr_value
*av
;
3424 struct insn_ent
*ie
;
3425 struct attr_desc
* attr
;
3426 struct attr_value_list
*next
; };
3427 struct attr_value_list
**insn_code_values
;
3428 struct attr_value_list
*ivbuf
;
3429 struct attr_value_list
*iv
;
3431 /* For each insn code, make a list of all the insn_ent's for it,
3432 for all values for all attributes. */
3434 if (num_insn_ents
== 0)
3437 /* Make 2 extra elements, for "code" values -2 and -1. */
3439 = (struct attr_value_list
**) alloca ((insn_code_number
+ 2)
3440 * sizeof (struct attr_value_list
*));
3441 bzero ((char *) insn_code_values
,
3442 (insn_code_number
+ 2) * sizeof (struct attr_value_list
*));
3444 /* Offset the table address so we can index by -2 or -1. */
3445 insn_code_values
+= 2;
3447 /* Allocate the attr_value_list structures using xmalloc rather than
3448 alloca, because using alloca can overflow the maximum permitted
3449 stack limit on SPARC Lynx. */
3450 iv
= ivbuf
= ((struct attr_value_list
*)
3451 xmalloc (num_insn_ents
* sizeof (struct attr_value_list
)));
3453 for (i
= 0; i
< MAX_ATTRS_INDEX
; i
++)
3454 for (attr
= attrs
[i
]; attr
; attr
= attr
->next
)
3455 for (av
= attr
->first_value
; av
; av
= av
->next
)
3456 for (ie
= av
->first_insn
; ie
; ie
= ie
->next
)
3461 iv
->next
= insn_code_values
[ie
->insn_code
];
3462 insn_code_values
[ie
->insn_code
] = iv
;
3466 /* Sanity check on num_insn_ents. */
3467 if (iv
!= ivbuf
+ num_insn_ents
)
3470 /* Process one insn code at a time. */
3471 for (i
= -2; i
< insn_code_number
; i
++)
3473 /* Clear the MEM_IN_STRUCT_P flag everywhere relevant.
3474 We use it to mean "already simplified for this insn". */
3475 for (iv
= insn_code_values
[i
]; iv
; iv
= iv
->next
)
3476 clear_struct_flag (iv
->av
->value
);
3478 /* Loop until nothing changes for one iteration. */
3479 something_changed
= 1;
3480 while (something_changed
)
3482 something_changed
= 0;
3483 for (iv
= insn_code_values
[i
]; iv
; iv
= iv
->next
)
3485 struct obstack
*old
= rtl_obstack
;
3486 char *spacer
= (char *) obstack_finish (temp_obstack
);
3491 if (GET_CODE (av
->value
) != COND
)
3494 rtl_obstack
= temp_obstack
;
3495 #if 0 /* This was intended as a speed up, but it was slower. */
3496 if (insn_n_alternatives
[ie
->insn_code
] > 6
3497 && count_sub_rtxs (av
->value
, 200) >= 200)
3498 newexp
= simplify_by_alternatives (av
->value
, ie
->insn_code
,
3502 newexp
= simplify_cond (av
->value
, ie
->insn_code
,
3506 if (newexp
!= av
->value
)
3508 newexp
= attr_copy_rtx (newexp
);
3509 remove_insn_ent (av
, ie
);
3510 av
= get_attr_value (newexp
, attr
, ie
->insn_code
);
3512 insert_insn_ent (av
, ie
);
3513 something_changed
= 1;
3515 obstack_free (temp_obstack
, spacer
);
3525 simplify_by_alternatives (exp
, insn_code
, insn_index
)
3527 int insn_code
, insn_index
;
3530 int len
= insn_n_alternatives
[insn_code
];
3531 rtx newexp
= rtx_alloc (COND
);
3535 XVEC (newexp
, 0) = rtvec_alloc (len
* 2);
3537 /* It will not matter what value we use as the default value
3538 of the new COND, since that default will never be used.
3539 Choose something of the right type. */
3540 for (ultimate
= exp
; GET_CODE (ultimate
) == COND
;)
3541 ultimate
= XEXP (ultimate
, 1);
3542 XEXP (newexp
, 1) = ultimate
;
3544 for (i
= 0; i
< insn_n_alternatives
[insn_code
]; i
++)
3546 current_alternative_string
= attr_numeral (i
);
3547 XVECEXP (newexp
, 0, i
* 2) = make_alternative_compare (1 << i
);
3548 XVECEXP (newexp
, 0, i
* 2 + 1)
3549 = simplify_cond (exp
, insn_code
, insn_index
);
3552 current_alternative_string
= 0;
3553 return simplify_cond (newexp
, insn_code
, insn_index
);
3557 /* If EXP is a suitable expression, reorganize it by constructing an
3558 equivalent expression that is a COND with the tests being all combinations
3559 of attribute values and the values being simple constants. */
3562 simplify_by_exploding (exp
)
3565 rtx list
= 0, link
, condexp
, defval
= NULL_RTX
;
3566 struct dimension
*space
;
3567 rtx
*condtest
, *condval
;
3568 int i
, j
, total
, ndim
= 0;
3569 int most_tests
, num_marks
, new_marks
;
3571 /* Locate all the EQ_ATTR expressions. */
3572 if (! find_and_mark_used_attributes (exp
, &list
, &ndim
) || ndim
== 0)
3574 unmark_used_attributes (list
, 0, 0);
3578 /* Create an attribute space from the list of used attributes. For each
3579 dimension in the attribute space, record the attribute, list of values
3580 used, and number of values used. Add members to the list of values to
3581 cover the domain of the attribute. This makes the expanded COND form
3582 order independent. */
3584 space
= (struct dimension
*) alloca (ndim
* sizeof (struct dimension
));
3587 for (ndim
= 0; list
; ndim
++)
3589 /* Pull the first attribute value from the list and record that
3590 attribute as another dimension in the attribute space. */
3591 char *name
= XSTR (XEXP (list
, 0), 0);
3594 if ((space
[ndim
].attr
= find_attr (name
, 0)) == 0
3595 || space
[ndim
].attr
->is_numeric
)
3597 unmark_used_attributes (list
, space
, ndim
);
3601 /* Add all remaining attribute values that refer to this attribute. */
3602 space
[ndim
].num_values
= 0;
3603 space
[ndim
].values
= 0;
3605 for (link
= list
; link
; link
= *prev
)
3606 if (! strcmp (XSTR (XEXP (link
, 0), 0), name
))
3608 space
[ndim
].num_values
++;
3609 *prev
= XEXP (link
, 1);
3610 XEXP (link
, 1) = space
[ndim
].values
;
3611 space
[ndim
].values
= link
;
3614 prev
= &XEXP (link
, 1);
3616 /* Add sufficient members to the list of values to make the list
3617 mutually exclusive and record the total size of the attribute
3619 total
*= add_values_to_cover (&space
[ndim
]);
3622 /* Sort the attribute space so that the attributes go from non-constant
3623 to constant and from most values to least values. */
3624 for (i
= 0; i
< ndim
; i
++)
3625 for (j
= ndim
- 1; j
> i
; j
--)
3626 if ((space
[j
-1].attr
->is_const
&& !space
[j
].attr
->is_const
)
3627 || space
[j
-1].num_values
< space
[j
].num_values
)
3629 struct dimension tmp
;
3631 space
[j
] = space
[j
-1];
3635 /* Establish the initial current value. */
3636 for (i
= 0; i
< ndim
; i
++)
3637 space
[i
].current_value
= space
[i
].values
;
3639 condtest
= (rtx
*) alloca (total
* sizeof (rtx
));
3640 condval
= (rtx
*) alloca (total
* sizeof (rtx
));
3642 /* Expand the tests and values by iterating over all values in the
3646 condtest
[i
] = test_for_current_value (space
, ndim
);
3647 condval
[i
] = simplify_with_current_value (exp
, space
, ndim
);
3648 if (! increment_current_value (space
, ndim
))
3654 /* We are now finished with the original expression. */
3655 unmark_used_attributes (0, space
, ndim
);
3657 /* Find the most used constant value and make that the default. */
3659 for (i
= num_marks
= 0; i
< total
; i
++)
3660 if (GET_CODE (condval
[i
]) == CONST_STRING
3661 && ! MEM_VOLATILE_P (condval
[i
]))
3663 /* Mark the unmarked constant value and count how many are marked. */
3664 MEM_VOLATILE_P (condval
[i
]) = 1;
3665 for (j
= new_marks
= 0; j
< total
; j
++)
3666 if (GET_CODE (condval
[j
]) == CONST_STRING
3667 && MEM_VOLATILE_P (condval
[j
]))
3669 if (new_marks
- num_marks
> most_tests
)
3671 most_tests
= new_marks
- num_marks
;
3672 defval
= condval
[i
];
3674 num_marks
= new_marks
;
3676 /* Clear all the marks. */
3677 for (i
= 0; i
< total
; i
++)
3678 MEM_VOLATILE_P (condval
[i
]) = 0;
3680 /* Give up if nothing is constant. */
3684 /* If all values are the default, use that. */
3685 if (total
== most_tests
)
3688 /* Make a COND with the most common constant value the default. (A more
3689 complex method where tests with the same value were combined didn't
3690 seem to improve things.) */
3691 condexp
= rtx_alloc (COND
);
3692 XVEC (condexp
, 0) = rtvec_alloc ((total
- most_tests
) * 2);
3693 XEXP (condexp
, 1) = defval
;
3694 for (i
= j
= 0; i
< total
; i
++)
3695 if (condval
[i
] != defval
)
3697 XVECEXP (condexp
, 0, 2 * j
) = condtest
[i
];
3698 XVECEXP (condexp
, 0, 2 * j
+ 1) = condval
[i
];
3705 /* Set the MEM_VOLATILE_P flag for all EQ_ATTR expressions in EXP and
3706 verify that EXP can be simplified to a constant term if all the EQ_ATTR
3707 tests have known value. */
3710 find_and_mark_used_attributes (exp
, terms
, nterms
)
3716 switch (GET_CODE (exp
))
3719 if (! MEM_VOLATILE_P (exp
))
3721 rtx link
= rtx_alloc (EXPR_LIST
);
3722 XEXP (link
, 0) = exp
;
3723 XEXP (link
, 1) = *terms
;
3726 MEM_VOLATILE_P (exp
) = 1;
3733 if (! find_and_mark_used_attributes (XEXP (exp
, 2), terms
, nterms
))
3737 if (! find_and_mark_used_attributes (XEXP (exp
, 1), terms
, nterms
))
3740 if (! find_and_mark_used_attributes (XEXP (exp
, 0), terms
, nterms
))
3745 for (i
= 0; i
< XVECLEN (exp
, 0); i
++)
3746 if (! find_and_mark_used_attributes (XVECEXP (exp
, 0, i
), terms
, nterms
))
3748 if (! find_and_mark_used_attributes (XEXP (exp
, 1), terms
, nterms
))
3757 /* Clear the MEM_VOLATILE_P flag in all EQ_ATTR expressions on LIST and
3758 in the values of the NDIM-dimensional attribute space SPACE. */
3761 unmark_used_attributes (list
, space
, ndim
)
3763 struct dimension
*space
;
3769 for (i
= 0; i
< ndim
; i
++)
3770 unmark_used_attributes (space
[i
].values
, 0, 0);
3772 for (link
= list
; link
; link
= XEXP (link
, 1))
3774 exp
= XEXP (link
, 0);
3775 if (GET_CODE (exp
) == EQ_ATTR
)
3776 MEM_VOLATILE_P (exp
) = 0;
3780 /* Update the attribute dimension DIM so that all values of the attribute
3781 are tested. Return the updated number of values. */
3784 add_values_to_cover (dim
)
3785 struct dimension
*dim
;
3787 struct attr_value
*av
;
3788 rtx exp
, link
, *prev
;
3791 for (av
= dim
->attr
->first_value
; av
; av
= av
->next
)
3792 if (GET_CODE (av
->value
) == CONST_STRING
)
3795 if (nalt
< dim
->num_values
)
3797 else if (nalt
== dim
->num_values
)
3799 else if (nalt
* 2 < dim
->num_values
* 3)
3801 /* Most all the values of the attribute are used, so add all the unused
3803 prev
= &dim
->values
;
3804 for (link
= dim
->values
; link
; link
= *prev
)
3805 prev
= &XEXP (link
, 1);
3807 for (av
= dim
->attr
->first_value
; av
; av
= av
->next
)
3808 if (GET_CODE (av
->value
) == CONST_STRING
)
3810 exp
= attr_eq (dim
->attr
->name
, XSTR (av
->value
, 0));
3811 if (MEM_VOLATILE_P (exp
))
3814 link
= rtx_alloc (EXPR_LIST
);
3815 XEXP (link
, 0) = exp
;
3818 prev
= &XEXP (link
, 1);
3820 dim
->num_values
= nalt
;
3824 rtx orexp
= false_rtx
;
3826 /* Very few values are used, so compute a mutually exclusive
3827 expression. (We could do this for numeric values if that becomes
3829 prev
= &dim
->values
;
3830 for (link
= dim
->values
; link
; link
= *prev
)
3832 orexp
= insert_right_side (IOR
, orexp
, XEXP (link
, 0), -2, -2);
3833 prev
= &XEXP (link
, 1);
3835 link
= rtx_alloc (EXPR_LIST
);
3836 XEXP (link
, 0) = attr_rtx (NOT
, orexp
);
3841 return dim
->num_values
;
3844 /* Increment the current value for the NDIM-dimensional attribute space SPACE
3845 and return FALSE if the increment overflowed. */
3848 increment_current_value (space
, ndim
)
3849 struct dimension
*space
;
3854 for (i
= ndim
- 1; i
>= 0; i
--)
3856 if ((space
[i
].current_value
= XEXP (space
[i
].current_value
, 1)) == 0)
3857 space
[i
].current_value
= space
[i
].values
;
3864 /* Construct an expression corresponding to the current value for the
3865 NDIM-dimensional attribute space SPACE. */
3868 test_for_current_value (space
, ndim
)
3869 struct dimension
*space
;
3875 for (i
= 0; i
< ndim
; i
++)
3876 exp
= insert_right_side (AND
, exp
, XEXP (space
[i
].current_value
, 0),
3882 /* Given the current value of the NDIM-dimensional attribute space SPACE,
3883 set the corresponding EQ_ATTR expressions to that value and reduce
3884 the expression EXP as much as possible. On input [and output], all
3885 known EQ_ATTR expressions are set to FALSE. */
3888 simplify_with_current_value (exp
, space
, ndim
)
3890 struct dimension
*space
;
3896 /* Mark each current value as TRUE. */
3897 for (i
= 0; i
< ndim
; i
++)
3899 x
= XEXP (space
[i
].current_value
, 0);
3900 if (GET_CODE (x
) == EQ_ATTR
)
3901 MEM_VOLATILE_P (x
) = 0;
3904 exp
= simplify_with_current_value_aux (exp
);
3906 /* Change each current value back to FALSE. */
3907 for (i
= 0; i
< ndim
; i
++)
3909 x
= XEXP (space
[i
].current_value
, 0);
3910 if (GET_CODE (x
) == EQ_ATTR
)
3911 MEM_VOLATILE_P (x
) = 1;
3917 /* Reduce the expression EXP based on the MEM_VOLATILE_P settings of
3918 all EQ_ATTR expressions. */
3921 simplify_with_current_value_aux (exp
)
3927 switch (GET_CODE (exp
))
3930 if (MEM_VOLATILE_P (exp
))
3939 cond
= simplify_with_current_value_aux (XEXP (exp
, 0));
3940 if (cond
== true_rtx
)
3941 return simplify_with_current_value_aux (XEXP (exp
, 1));
3942 else if (cond
== false_rtx
)
3943 return simplify_with_current_value_aux (XEXP (exp
, 2));
3945 return attr_rtx (IF_THEN_ELSE
, cond
,
3946 simplify_with_current_value_aux (XEXP (exp
, 1)),
3947 simplify_with_current_value_aux (XEXP (exp
, 2)));
3950 cond
= simplify_with_current_value_aux (XEXP (exp
, 1));
3951 if (cond
== true_rtx
)
3953 else if (cond
== false_rtx
)
3954 return simplify_with_current_value_aux (XEXP (exp
, 0));
3956 return attr_rtx (IOR
, cond
,
3957 simplify_with_current_value_aux (XEXP (exp
, 0)));
3960 cond
= simplify_with_current_value_aux (XEXP (exp
, 1));
3961 if (cond
== true_rtx
)
3962 return simplify_with_current_value_aux (XEXP (exp
, 0));
3963 else if (cond
== false_rtx
)
3966 return attr_rtx (AND
, cond
,
3967 simplify_with_current_value_aux (XEXP (exp
, 0)));
3970 cond
= simplify_with_current_value_aux (XEXP (exp
, 0));
3971 if (cond
== true_rtx
)
3973 else if (cond
== false_rtx
)
3976 return attr_rtx (NOT
, cond
);
3979 for (i
= 0; i
< XVECLEN (exp
, 0); i
+= 2)
3981 cond
= simplify_with_current_value_aux (XVECEXP (exp
, 0, i
));
3982 if (cond
== true_rtx
)
3983 return simplify_with_current_value_aux (XVECEXP (exp
, 0, i
+ 1));
3984 else if (cond
== false_rtx
)
3987 abort (); /* With all EQ_ATTR's of known value, a case should
3988 have been selected. */
3990 return simplify_with_current_value_aux (XEXP (exp
, 1));
3997 /* Clear the MEM_IN_STRUCT_P flag in EXP and its subexpressions. */
4000 clear_struct_flag (x
)
4005 register enum rtx_code code
;
4008 MEM_IN_STRUCT_P (x
) = 0;
4009 if (RTX_UNCHANGING_P (x
))
4012 code
= GET_CODE (x
);
4032 /* Compare the elements. If any pair of corresponding elements
4033 fail to match, return 0 for the whole things. */
4035 fmt
= GET_RTX_FORMAT (code
);
4036 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
4042 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
4043 clear_struct_flag (XVECEXP (x
, i
, j
));
4047 clear_struct_flag (XEXP (x
, i
));
4053 /* Return the number of RTX objects making up the expression X.
4054 But if we count more more than MAX objects, stop counting. */
4057 count_sub_rtxs (x
, max
)
4063 register enum rtx_code code
;
4067 code
= GET_CODE (x
);
4087 /* Compare the elements. If any pair of corresponding elements
4088 fail to match, return 0 for the whole things. */
4090 fmt
= GET_RTX_FORMAT (code
);
4091 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
4100 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
4101 total
+= count_sub_rtxs (XVECEXP (x
, i
, j
), max
);
4105 total
+= count_sub_rtxs (XEXP (x
, i
), max
);
4113 /* Create table entries for DEFINE_ATTR. */
4119 struct attr_desc
*attr
;
4120 struct attr_value
*av
;
4124 /* Make a new attribute structure. Check for duplicate by looking at
4125 attr->default_val, since it is initialized by this routine. */
4126 attr
= find_attr (XSTR (exp
, 0), 1);
4127 if (attr
->default_val
)
4128 fatal ("Duplicate definition for `%s' attribute", attr
->name
);
4130 if (*XSTR (exp
, 1) == '\0')
4131 attr
->is_numeric
= 1;
4134 name_ptr
= XSTR (exp
, 1);
4135 while ((p
= next_comma_elt (&name_ptr
)) != NULL
)
4137 av
= (struct attr_value
*) oballoc (sizeof (struct attr_value
));
4138 av
->value
= attr_rtx (CONST_STRING
, p
);
4139 av
->next
= attr
->first_value
;
4140 attr
->first_value
= av
;
4141 av
->first_insn
= NULL
;
4143 av
->has_asm_insn
= 0;
4147 if (GET_CODE (XEXP (exp
, 2)) == CONST
)
4150 if (attr
->is_numeric
)
4151 fatal ("Constant attributes may not take numeric values");
4152 /* Get rid of the CONST node. It is allowed only at top-level. */
4153 XEXP (exp
, 2) = XEXP (XEXP (exp
, 2), 0);
4156 if (! strcmp (attr
->name
, "length") && ! attr
->is_numeric
)
4157 fatal ("`length' attribute must take numeric values");
4159 /* Set up the default value. */
4160 XEXP (exp
, 2) = check_attr_value (XEXP (exp
, 2), attr
);
4161 attr
->default_val
= get_attr_value (XEXP (exp
, 2), attr
, -2);
4164 /* Given a pattern for DEFINE_PEEPHOLE or DEFINE_INSN, return the number of
4165 alternatives in the constraints. Assume all MATCH_OPERANDs have the same
4166 number of alternatives as this should be checked elsewhere. */
4169 count_alternatives (exp
)
4175 if (GET_CODE (exp
) == MATCH_OPERAND
)
4176 return n_comma_elts (XSTR (exp
, 2));
4178 for (i
= 0, fmt
= GET_RTX_FORMAT (GET_CODE (exp
));
4179 i
< GET_RTX_LENGTH (GET_CODE (exp
)); i
++)
4184 n
= count_alternatives (XEXP (exp
, i
));
4191 if (XVEC (exp
, i
) != NULL
)
4192 for (j
= 0; j
< XVECLEN (exp
, i
); j
++)
4194 n
= count_alternatives (XVECEXP (exp
, i
, j
));
4203 /* Returns non-zero if the given expression contains an EQ_ATTR with the
4204 `alternative' attribute. */
4207 compares_alternatives_p (exp
)
4213 if (GET_CODE (exp
) == EQ_ATTR
&& XSTR (exp
, 0) == alternative_name
)
4216 for (i
= 0, fmt
= GET_RTX_FORMAT (GET_CODE (exp
));
4217 i
< GET_RTX_LENGTH (GET_CODE (exp
)); i
++)
4222 if (compares_alternatives_p (XEXP (exp
, i
)))
4227 for (j
= 0; j
< XVECLEN (exp
, i
); j
++)
4228 if (compares_alternatives_p (XVECEXP (exp
, i
, j
)))
4236 /* Returns non-zero is INNER is contained in EXP. */
4239 contained_in_p (inner
, exp
)
4246 if (rtx_equal_p (inner
, exp
))
4249 for (i
= 0, fmt
= GET_RTX_FORMAT (GET_CODE (exp
));
4250 i
< GET_RTX_LENGTH (GET_CODE (exp
)); i
++)
4255 if (contained_in_p (inner
, XEXP (exp
, i
)))
4260 for (j
= 0; j
< XVECLEN (exp
, i
); j
++)
4261 if (contained_in_p (inner
, XVECEXP (exp
, i
, j
)))
4269 /* Process DEFINE_PEEPHOLE, DEFINE_INSN, and DEFINE_ASM_ATTRIBUTES. */
4275 struct insn_def
*id
;
4277 id
= (struct insn_def
*) oballoc (sizeof (struct insn_def
));
4282 switch (GET_CODE (exp
))
4285 id
->insn_code
= insn_code_number
++;
4286 id
->insn_index
= insn_index_number
++;
4287 id
->num_alternatives
= count_alternatives (exp
);
4288 if (id
->num_alternatives
== 0)
4289 id
->num_alternatives
= 1;
4293 case DEFINE_PEEPHOLE
:
4294 id
->insn_code
= insn_code_number
++;
4295 id
->insn_index
= insn_index_number
++;
4296 id
->num_alternatives
= count_alternatives (exp
);
4297 if (id
->num_alternatives
== 0)
4298 id
->num_alternatives
= 1;
4302 case DEFINE_ASM_ATTRIBUTES
:
4304 id
->insn_index
= -1;
4305 id
->num_alternatives
= 1;
4307 got_define_asm_attributes
= 1;
4315 /* Process a DEFINE_DELAY. Validate the vector length, check if annul
4316 true or annul false is specified, and make a `struct delay_desc'. */
4322 struct delay_desc
*delay
;
4325 if (XVECLEN (def
, 1) % 3 != 0)
4326 fatal ("Number of elements in DEFINE_DELAY must be multiple of three.");
4328 for (i
= 0; i
< XVECLEN (def
, 1); i
+= 3)
4330 if (XVECEXP (def
, 1, i
+ 1))
4331 have_annul_true
= 1;
4332 if (XVECEXP (def
, 1, i
+ 2))
4333 have_annul_false
= 1;
4336 delay
= (struct delay_desc
*) oballoc (sizeof (struct delay_desc
));
4338 delay
->num
= ++num_delays
;
4339 delay
->next
= delays
;
4343 /* Process a DEFINE_FUNCTION_UNIT.
4345 This gives information about a function unit contained in the CPU.
4346 We fill in a `struct function_unit_op' and a `struct function_unit'
4347 with information used later by `expand_unit'. */
4353 struct function_unit
*unit
;
4354 struct function_unit_op
*op
;
4355 char *name
= XSTR (def
, 0);
4356 int multiplicity
= XINT (def
, 1);
4357 int simultaneity
= XINT (def
, 2);
4358 rtx condexp
= XEXP (def
, 3);
4359 int ready_cost
= MAX (XINT (def
, 4), 1);
4360 int issue_delay
= MAX (XINT (def
, 5), 1);
4362 /* See if we have already seen this function unit. If so, check that
4363 the multiplicity and simultaneity values are the same. If not, make
4364 a structure for this function unit. */
4365 for (unit
= units
; unit
; unit
= unit
->next
)
4366 if (! strcmp (unit
->name
, name
))
4368 if (unit
->multiplicity
!= multiplicity
4369 || unit
->simultaneity
!= simultaneity
)
4370 fatal ("Differing specifications given for `%s' function unit.",
4377 unit
= (struct function_unit
*) oballoc (sizeof (struct function_unit
));
4379 unit
->multiplicity
= multiplicity
;
4380 unit
->simultaneity
= simultaneity
;
4381 unit
->issue_delay
.min
= unit
->issue_delay
.max
= issue_delay
;
4382 unit
->num
= num_units
++;
4383 unit
->num_opclasses
= 0;
4384 unit
->condexp
= false_rtx
;
4390 /* Make a new operation class structure entry and initialize it. */
4391 op
= (struct function_unit_op
*) oballoc (sizeof (struct function_unit_op
));
4392 op
->condexp
= condexp
;
4393 op
->num
= unit
->num_opclasses
++;
4394 op
->ready
= ready_cost
;
4395 op
->issue_delay
= issue_delay
;
4396 op
->next
= unit
->ops
;
4398 num_unit_opclasses
++;
4400 /* Set our issue expression based on whether or not an optional conflict
4401 vector was specified. */
4404 /* Compute the IOR of all the specified expressions. */
4405 rtx orexp
= false_rtx
;
4408 for (i
= 0; i
< XVECLEN (def
, 6); i
++)
4409 orexp
= insert_right_side (IOR
, orexp
, XVECEXP (def
, 6, i
), -2, -2);
4411 op
->conflict_exp
= orexp
;
4412 extend_range (&unit
->issue_delay
, 1, issue_delay
);
4416 op
->conflict_exp
= true_rtx
;
4417 extend_range (&unit
->issue_delay
, issue_delay
, issue_delay
);
4420 /* Merge our conditional into that of the function unit so we can determine
4421 which insns are used by the function unit. */
4422 unit
->condexp
= insert_right_side (IOR
, unit
->condexp
, op
->condexp
, -2, -2);
4425 /* Given a piece of RTX, print a C expression to test it's truth value.
4427 We use AND and IOR both for logical and bit-wise operations, so
4428 interpret them as logical unless they are inside a comparison expression.
4429 The first bit of FLAGS will be non-zero in that case.
4431 Set the second bit of FLAGS to make references to attribute values use
4432 a cached local variable instead of calling a function. */
4435 write_test_expr (exp
, flags
)
4439 int comparison_operator
= 0;
4441 struct attr_desc
*attr
;
4443 /* In order not to worry about operator precedence, surround our part of
4444 the expression with parentheses. */
4447 code
= GET_CODE (exp
);
4450 /* Binary operators. */
4452 case GE
: case GT
: case GEU
: case GTU
:
4453 case LE
: case LT
: case LEU
: case LTU
:
4454 comparison_operator
= 1;
4456 case PLUS
: case MINUS
: case MULT
: case DIV
: case MOD
:
4457 case AND
: case IOR
: case XOR
:
4458 case ASHIFT
: case LSHIFTRT
: case ASHIFTRT
:
4459 write_test_expr (XEXP (exp
, 0), flags
| comparison_operator
);
4475 printf (" >= (unsigned) ");
4478 printf (" > (unsigned) ");
4487 printf (" <= (unsigned) ");
4490 printf (" < (unsigned) ");
4533 write_test_expr (XEXP (exp
, 1), flags
| comparison_operator
);
4537 /* Special-case (not (eq_attrq "alternative" "x")) */
4538 if (! (flags
& 1) && GET_CODE (XEXP (exp
, 0)) == EQ_ATTR
4539 && XSTR (XEXP (exp
, 0), 0) == alternative_name
)
4541 printf ("which_alternative != %s", XSTR (XEXP (exp
, 0), 1));
4545 /* Otherwise, fall through to normal unary operator. */
4547 /* Unary operators. */
4567 write_test_expr (XEXP (exp
, 0), flags
);
4570 /* Comparison test of an attribute with a value. Most of these will
4571 have been removed by optimization. Handle "alternative"
4572 specially and give error if EQ_ATTR present inside a comparison. */
4575 fatal ("EQ_ATTR not valid inside comparison");
4577 if (XSTR (exp
, 0) == alternative_name
)
4579 printf ("which_alternative == %s", XSTR (exp
, 1));
4583 attr
= find_attr (XSTR (exp
, 0), 0);
4584 if (! attr
) abort ();
4586 /* Now is the time to expand the value of a constant attribute. */
4589 write_test_expr (evaluate_eq_attr (exp
, attr
->default_val
->value
,
4596 printf ("attr_%s", attr
->name
);
4598 printf ("get_attr_%s (insn)", attr
->name
);
4600 write_attr_valueq (attr
, XSTR (exp
, 1));
4604 /* Comparison test of flags for define_delays. */
4607 fatal ("ATTR_FLAG not valid inside comparison");
4608 printf ("(flags & ATTR_FLAG_%s) != 0", XSTR (exp
, 0));
4611 /* See if an operand matches a predicate. */
4613 /* If only a mode is given, just ensure the mode matches the operand.
4614 If neither a mode nor predicate is given, error. */
4615 if (XSTR (exp
, 1) == NULL
|| *XSTR (exp
, 1) == '\0')
4617 if (GET_MODE (exp
) == VOIDmode
)
4618 fatal ("Null MATCH_OPERAND specified as test");
4620 printf ("GET_MODE (operands[%d]) == %smode",
4621 XINT (exp
, 0), GET_MODE_NAME (GET_MODE (exp
)));
4624 printf ("%s (operands[%d], %smode)",
4625 XSTR (exp
, 1), XINT (exp
, 0), GET_MODE_NAME (GET_MODE (exp
)));
4628 /* Constant integer. */
4630 printf (HOST_WIDE_INT_PRINT_DEC
, XWINT (exp
, 0));
4633 /* A random C expression. */
4635 printf ("%s", XSTR (exp
, 0));
4638 /* The address of the branch target. */
4640 printf ("insn_addresses[INSN_UID (GET_CODE (operands[%d]) == LABEL_REF ? XEXP (operands[%d], 0) : operands[%d])]",
4641 XINT (exp
, 0), XINT (exp
, 0), XINT (exp
, 0));
4645 /* The address of the current insn. We implement this actually as the
4646 address of the current insn for backward branches, but the last
4647 address of the next insn for forward branches, and both with
4648 adjustments that account for the worst-case possible stretching of
4649 intervening alignments between this insn and its destination. */
4650 printf("insn_current_reference_address (insn)");
4654 printf ("%s", XSTR (exp
, 0));
4658 write_test_expr (XEXP (exp
, 0), flags
& 2);
4660 write_test_expr (XEXP (exp
, 1), flags
| 1);
4662 write_test_expr (XEXP (exp
, 2), flags
| 1);
4666 fatal ("bad RTX code `%s' in attribute calculation\n",
4667 GET_RTX_NAME (code
));
4673 /* Given an attribute value, return the maximum CONST_STRING argument
4674 encountered. It is assumed that they are all numeric. */
4677 max_attr_value (exp
)
4680 int current_max
= 0;
4684 if (GET_CODE (exp
) == CONST_STRING
)
4685 return atoi (XSTR (exp
, 0));
4687 else if (GET_CODE (exp
) == COND
)
4689 for (i
= 0; i
< XVECLEN (exp
, 0); i
+= 2)
4691 n
= max_attr_value (XVECEXP (exp
, 0, i
+ 1));
4692 if (n
> current_max
)
4696 n
= max_attr_value (XEXP (exp
, 1));
4697 if (n
> current_max
)
4701 else if (GET_CODE (exp
) == IF_THEN_ELSE
)
4703 current_max
= max_attr_value (XEXP (exp
, 1));
4704 n
= max_attr_value (XEXP (exp
, 2));
4705 if (n
> current_max
)
4715 /* Given an attribute value, return the result of ORing together all
4716 CONST_STRING arguments encountered. It is assumed that they are
4726 if (GET_CODE (exp
) == CONST_STRING
)
4727 return atoi (XSTR (exp
, 0));
4729 else if (GET_CODE (exp
) == COND
)
4731 for (i
= 0; i
< XVECLEN (exp
, 0); i
+= 2)
4733 current_or
|= or_attr_value (XVECEXP (exp
, 0, i
+ 1));
4736 current_or
|= or_attr_value (XEXP (exp
, 1));
4739 else if (GET_CODE (exp
) == IF_THEN_ELSE
)
4741 current_or
= or_attr_value (XEXP (exp
, 1));
4742 current_or
|= or_attr_value (XEXP (exp
, 2));
4751 /* Scan an attribute value, possibly a conditional, and record what actions
4752 will be required to do any conditional tests in it.
4755 `must_extract' if we need to extract the insn operands
4756 `must_constrain' if we must compute `which_alternative'
4757 `address_used' if an address expression was used
4758 `length_used' if an (eq_attr "length" ...) was used
4762 walk_attr_value (exp
)
4772 code
= GET_CODE (exp
);
4776 if (! RTX_UNCHANGING_P (exp
))
4777 /* Since this is an arbitrary expression, it can look at anything.
4778 However, constant expressions do not depend on any particular
4780 must_extract
= must_constrain
= 1;
4788 if (XSTR (exp
, 0) == alternative_name
)
4789 must_extract
= must_constrain
= 1;
4790 else if (strcmp (XSTR (exp
, 0), "length") == 0)
4810 for (i
= 0, fmt
= GET_RTX_FORMAT (code
); i
< GET_RTX_LENGTH (code
); i
++)
4815 walk_attr_value (XEXP (exp
, i
));
4819 if (XVEC (exp
, i
) != NULL
)
4820 for (j
= 0; j
< XVECLEN (exp
, i
); j
++)
4821 walk_attr_value (XVECEXP (exp
, i
, j
));
4826 /* Write out a function to obtain the attribute for a given INSN. */
4829 write_attr_get (attr
)
4830 struct attr_desc
*attr
;
4832 struct attr_value
*av
, *common_av
;
4834 /* Find the most used attribute value. Handle that as the `default' of the
4835 switch we will generate. */
4836 common_av
= find_most_used (attr
);
4838 /* Write out start of function, then all values with explicit `case' lines,
4839 then a `default', then the value with the most uses. */
4840 if (!attr
->is_numeric
)
4841 printf ("enum attr_%s\n", attr
->name
);
4842 else if (attr
->unsigned_p
)
4843 printf ("unsigned int\n");
4847 /* If the attribute name starts with a star, the remainder is the name of
4848 the subroutine to use, instead of `get_attr_...'. */
4849 if (attr
->name
[0] == '*')
4850 printf ("%s (insn)\n", &attr
->name
[1]);
4851 else if (attr
->is_const
== 0)
4852 printf ("get_attr_%s (insn)\n", attr
->name
);
4855 printf ("get_attr_%s ()\n", attr
->name
);
4858 for (av
= attr
->first_value
; av
; av
= av
->next
)
4859 if (av
->num_insns
!= 0)
4860 write_attr_set (attr
, 2, av
->value
, "return", ";",
4861 true_rtx
, av
->first_insn
->insn_code
,
4862 av
->first_insn
->insn_index
);
4868 printf (" rtx insn;\n");
4871 if (GET_CODE (common_av
->value
) == FFS
)
4873 rtx p
= XEXP (common_av
->value
, 0);
4875 /* No need to emit code to abort if the insn is unrecognized; the
4876 other get_attr_foo functions will do that when we call them. */
4878 write_toplevel_expr (p
);
4880 printf ("\n if (accum && accum == (accum & -accum))\n");
4882 printf (" int i;\n");
4883 printf (" for (i = 0; accum >>= 1; ++i) continue;\n");
4884 printf (" accum = i;\n");
4885 printf (" }\n else\n");
4886 printf (" accum = ~accum;\n");
4887 printf (" return accum;\n}\n\n");
4891 printf (" switch (recog_memoized (insn))\n");
4894 for (av
= attr
->first_value
; av
; av
= av
->next
)
4895 if (av
!= common_av
)
4896 write_attr_case (attr
, av
, 1, "return", ";", 4, true_rtx
);
4898 write_attr_case (attr
, common_av
, 0, "return", ";", 4, true_rtx
);
4899 printf (" }\n}\n\n");
4903 /* Given an AND tree of known true terms (because we are inside an `if' with
4904 that as the condition or are in an `else' clause) and an expression,
4905 replace any known true terms with TRUE. Use `simplify_and_tree' to do
4906 the bulk of the work. */
4909 eliminate_known_true (known_true
, exp
, insn_code
, insn_index
)
4912 int insn_code
, insn_index
;
4916 known_true
= SIMPLIFY_TEST_EXP (known_true
, insn_code
, insn_index
);
4918 if (GET_CODE (known_true
) == AND
)
4920 exp
= eliminate_known_true (XEXP (known_true
, 0), exp
,
4921 insn_code
, insn_index
);
4922 exp
= eliminate_known_true (XEXP (known_true
, 1), exp
,
4923 insn_code
, insn_index
);
4928 exp
= simplify_and_tree (exp
, &term
, insn_code
, insn_index
);
4934 /* Write out a series of tests and assignment statements to perform tests and
4935 sets of an attribute value. We are passed an indentation amount and prefix
4936 and suffix strings to write around each attribute value (e.g., "return"
4940 write_attr_set (attr
, indent
, value
, prefix
, suffix
, known_true
,
4941 insn_code
, insn_index
)
4942 struct attr_desc
*attr
;
4948 int insn_code
, insn_index
;
4950 if (GET_CODE (value
) == CONST_STRING
)
4952 write_indent (indent
);
4953 printf ("%s ", prefix
);
4954 write_attr_value (attr
, value
);
4955 printf ("%s\n", suffix
);
4957 else if (GET_CODE (value
) == COND
)
4959 /* Assume the default value will be the default of the COND unless we
4960 find an always true expression. */
4961 rtx default_val
= XEXP (value
, 1);
4962 rtx our_known_true
= known_true
;
4967 for (i
= 0; i
< XVECLEN (value
, 0); i
+= 2)
4972 testexp
= eliminate_known_true (our_known_true
,
4973 XVECEXP (value
, 0, i
),
4974 insn_code
, insn_index
);
4975 newexp
= attr_rtx (NOT
, testexp
);
4976 newexp
= insert_right_side (AND
, our_known_true
, newexp
,
4977 insn_code
, insn_index
);
4979 /* If the test expression is always true or if the next `known_true'
4980 expression is always false, this is the last case, so break
4981 out and let this value be the `else' case. */
4982 if (testexp
== true_rtx
|| newexp
== false_rtx
)
4984 default_val
= XVECEXP (value
, 0, i
+ 1);
4988 /* Compute the expression to pass to our recursive call as being
4990 inner_true
= insert_right_side (AND
, our_known_true
,
4991 testexp
, insn_code
, insn_index
);
4993 /* If this is always false, skip it. */
4994 if (inner_true
== false_rtx
)
4997 write_indent (indent
);
4998 printf ("%sif ", first_if
? "" : "else ");
5000 write_test_expr (testexp
, 0);
5002 write_indent (indent
+ 2);
5005 write_attr_set (attr
, indent
+ 4,
5006 XVECEXP (value
, 0, i
+ 1), prefix
, suffix
,
5007 inner_true
, insn_code
, insn_index
);
5008 write_indent (indent
+ 2);
5010 our_known_true
= newexp
;
5015 write_indent (indent
);
5017 write_indent (indent
+ 2);
5021 write_attr_set (attr
, first_if
? indent
: indent
+ 4, default_val
,
5022 prefix
, suffix
, our_known_true
, insn_code
, insn_index
);
5026 write_indent (indent
+ 2);
5034 /* Write out the computation for one attribute value. */
5037 write_attr_case (attr
, av
, write_case_lines
, prefix
, suffix
, indent
,
5039 struct attr_desc
*attr
;
5040 struct attr_value
*av
;
5041 int write_case_lines
;
5042 char *prefix
, *suffix
;
5046 struct insn_ent
*ie
;
5048 if (av
->num_insns
== 0)
5051 if (av
->has_asm_insn
)
5053 write_indent (indent
);
5054 printf ("case -1:\n");
5055 write_indent (indent
+ 2);
5056 printf ("if (GET_CODE (PATTERN (insn)) != ASM_INPUT\n");
5057 write_indent (indent
+ 2);
5058 printf (" && asm_noperands (PATTERN (insn)) < 0)\n");
5059 write_indent (indent
+ 2);
5060 printf (" fatal_insn_not_found (insn);\n");
5063 if (write_case_lines
)
5065 for (ie
= av
->first_insn
; ie
; ie
= ie
->next
)
5066 if (ie
->insn_code
!= -1)
5068 write_indent (indent
);
5069 printf ("case %d:\n", ie
->insn_code
);
5074 write_indent (indent
);
5075 printf ("default:\n");
5078 /* See what we have to do to output this value. */
5079 must_extract
= must_constrain
= address_used
= 0;
5080 walk_attr_value (av
->value
);
5084 write_indent (indent
+ 2);
5085 printf ("insn_extract (insn);\n");
5090 #ifdef REGISTER_CONSTRAINTS
5091 write_indent (indent
+ 2);
5092 printf ("if (! constrain_operands (INSN_CODE (insn), reload_completed))\n");
5093 write_indent (indent
+ 2);
5094 printf (" fatal_insn_not_found (insn);\n");
5098 write_attr_set (attr
, indent
+ 2, av
->value
, prefix
, suffix
,
5099 known_true
, av
->first_insn
->insn_code
,
5100 av
->first_insn
->insn_index
);
5102 if (strncmp (prefix
, "return", 6))
5104 write_indent (indent
+ 2);
5105 printf ("break;\n");
5110 /* Search for uses of non-const attributes and write code to cache them. */
5113 write_expr_attr_cache (p
, attr
)
5115 struct attr_desc
*attr
;
5120 if (GET_CODE (p
) == EQ_ATTR
)
5122 if (XSTR (p
, 0) != attr
->name
)
5125 if (!attr
->is_numeric
)
5126 printf (" register enum attr_%s ", attr
->name
);
5127 else if (attr
->unsigned_p
)
5128 printf (" register unsigned int ");
5130 printf (" register int ");
5132 printf ("attr_%s = get_attr_%s (insn);\n", attr
->name
, attr
->name
);
5136 fmt
= GET_RTX_FORMAT (GET_CODE (p
));
5137 ie
= GET_RTX_LENGTH (GET_CODE (p
));
5138 for (i
= 0; i
< ie
; i
++)
5143 if (write_expr_attr_cache (XEXP (p
, i
), attr
))
5148 je
= XVECLEN (p
, i
);
5149 for (j
= 0; j
< je
; ++j
)
5150 if (write_expr_attr_cache (XVECEXP (p
, i
, j
), attr
))
5159 /* Evaluate an expression at top level. A front end to write_test_expr,
5160 in which we cache attribute values and break up excessively large
5161 expressions to cater to older compilers. */
5164 write_toplevel_expr (p
)
5167 struct attr_desc
*attr
;
5170 for (i
= 0; i
< MAX_ATTRS_INDEX
; ++i
)
5171 for (attr
= attrs
[i
]; attr
; attr
= attr
->next
)
5172 if (!attr
->is_const
)
5173 write_expr_attr_cache (p
, attr
);
5175 printf(" register unsigned long accum = 0;\n\n");
5177 while (GET_CODE (p
) == IOR
)
5180 if (GET_CODE (XEXP (p
, 0)) == IOR
)
5181 e
= XEXP (p
, 1), p
= XEXP (p
, 0);
5183 e
= XEXP (p
, 0), p
= XEXP (p
, 1);
5185 printf (" accum |= ");
5186 write_test_expr (e
, 3);
5189 printf (" accum |= ");
5190 write_test_expr (p
, 3);
5194 /* Utilities to write names in various forms. */
5197 write_attr_valueq (attr
, s
)
5198 struct attr_desc
*attr
;
5201 if (attr
->is_numeric
)
5204 /* Make the blockage range values easier to read. */
5206 printf (" /* 0x%x */", atoi (s
));
5210 write_upcase (attr
->name
);
5217 write_attr_value (attr
, value
)
5218 struct attr_desc
*attr
;
5221 if (GET_CODE (value
) != CONST_STRING
)
5224 write_attr_valueq (attr
, XSTR (value
, 0));
5232 if (*str
< 'a' || *str
> 'z')
5233 printf ("%c", *str
++);
5235 printf ("%c", *str
++ - 'a' + 'A');
5239 write_indent (indent
)
5242 for (; indent
> 8; indent
-= 8)
5245 for (; indent
; indent
--)
5249 /* Write a subroutine that is given an insn that requires a delay slot, a
5250 delay slot ordinal, and a candidate insn. It returns non-zero if the
5251 candidate can be placed in the specified delay slot of the insn.
5253 We can write as many as three subroutines. `eligible_for_delay'
5254 handles normal delay slots, `eligible_for_annul_true' indicates that
5255 the specified insn can be annulled if the branch is true, and likewise
5256 for `eligible_for_annul_false'.
5258 KIND is a string distinguishing these three cases ("delay", "annul_true",
5259 or "annul_false"). */
5262 write_eligible_delay (kind
)
5265 struct delay_desc
*delay
;
5268 struct attr_desc
*attr
;
5269 struct attr_value
*av
, *common_av
;
5272 /* Compute the maximum number of delay slots required. We use the delay
5273 ordinal times this number plus one, plus the slot number as an index into
5274 the appropriate predicate to test. */
5276 for (delay
= delays
, max_slots
= 0; delay
; delay
= delay
->next
)
5277 if (XVECLEN (delay
->def
, 1) / 3 > max_slots
)
5278 max_slots
= XVECLEN (delay
->def
, 1) / 3;
5280 /* Write function prelude. */
5283 printf ("eligible_for_%s (delay_insn, slot, candidate_insn, flags)\n",
5285 printf (" rtx delay_insn;\n");
5286 printf (" int slot;\n");
5287 printf (" rtx candidate_insn;\n");
5288 printf (" int flags;\n");
5290 printf (" rtx insn;\n");
5292 printf (" if (slot >= %d)\n", max_slots
);
5293 printf (" abort ();\n");
5296 /* If more than one delay type, find out which type the delay insn is. */
5300 attr
= find_attr ("*delay_type", 0);
5301 if (! attr
) abort ();
5302 common_av
= find_most_used (attr
);
5304 printf (" insn = delay_insn;\n");
5305 printf (" switch (recog_memoized (insn))\n");
5308 sprintf (str
, " * %d;\n break;", max_slots
);
5309 for (av
= attr
->first_value
; av
; av
= av
->next
)
5310 if (av
!= common_av
)
5311 write_attr_case (attr
, av
, 1, "slot +=", str
, 4, true_rtx
);
5313 write_attr_case (attr
, common_av
, 0, "slot +=", str
, 4, true_rtx
);
5316 /* Ensure matched. Otherwise, shouldn't have been called. */
5317 printf (" if (slot < %d)\n", max_slots
);
5318 printf (" abort ();\n\n");
5321 /* If just one type of delay slot, write simple switch. */
5322 if (num_delays
== 1 && max_slots
== 1)
5324 printf (" insn = candidate_insn;\n");
5325 printf (" switch (recog_memoized (insn))\n");
5328 attr
= find_attr ("*delay_1_0", 0);
5329 if (! attr
) abort ();
5330 common_av
= find_most_used (attr
);
5332 for (av
= attr
->first_value
; av
; av
= av
->next
)
5333 if (av
!= common_av
)
5334 write_attr_case (attr
, av
, 1, "return", ";", 4, true_rtx
);
5336 write_attr_case (attr
, common_av
, 0, "return", ";", 4, true_rtx
);
5342 /* Write a nested CASE. The first indicates which condition we need to
5343 test, and the inner CASE tests the condition. */
5344 printf (" insn = candidate_insn;\n");
5345 printf (" switch (slot)\n");
5348 for (delay
= delays
; delay
; delay
= delay
->next
)
5349 for (i
= 0; i
< XVECLEN (delay
->def
, 1); i
+= 3)
5351 printf (" case %d:\n",
5352 (i
/ 3) + (num_delays
== 1 ? 0 : delay
->num
* max_slots
));
5353 printf (" switch (recog_memoized (insn))\n");
5356 sprintf (str
, "*%s_%d_%d", kind
, delay
->num
, i
/ 3);
5357 attr
= find_attr (str
, 0);
5358 if (! attr
) abort ();
5359 common_av
= find_most_used (attr
);
5361 for (av
= attr
->first_value
; av
; av
= av
->next
)
5362 if (av
!= common_av
)
5363 write_attr_case (attr
, av
, 1, "return", ";", 8, true_rtx
);
5365 write_attr_case (attr
, common_av
, 0, "return", ";", 8, true_rtx
);
5369 printf (" default:\n");
5370 printf (" abort ();\n");
5377 /* Write routines to compute conflict cost for function units. Then write a
5378 table describing the available function units. */
5381 write_function_unit_info ()
5383 struct function_unit
*unit
;
5386 /* Write out conflict routines for function units. Don't bother writing
5387 one if there is only one issue delay value. */
5389 for (unit
= units
; unit
; unit
= unit
->next
)
5391 if (unit
->needs_blockage_function
)
5392 write_complex_function (unit
, "blockage", "block");
5394 /* If the minimum and maximum conflict costs are the same, there
5395 is only one value, so we don't need a function. */
5396 if (! unit
->needs_conflict_function
)
5398 unit
->default_cost
= make_numeric_value (unit
->issue_delay
.max
);
5402 /* The function first computes the case from the candidate insn. */
5403 unit
->default_cost
= make_numeric_value (0);
5404 write_complex_function (unit
, "conflict_cost", "cost");
5407 /* Now that all functions have been written, write the table describing
5408 the function units. The name is included for documentation purposes
5411 printf ("struct function_unit_desc function_units[] = {\n");
5413 /* Write out the descriptions in numeric order, but don't force that order
5414 on the list. Doing so increases the runtime of genattrtab.c. */
5415 for (i
= 0; i
< num_units
; i
++)
5417 for (unit
= units
; unit
; unit
= unit
->next
)
5421 printf (" {\"%s\", %d, %d, %d, %s, %d, %s_unit_ready_cost, ",
5422 unit
->name
, 1 << unit
->num
, unit
->multiplicity
,
5423 unit
->simultaneity
, XSTR (unit
->default_cost
, 0),
5424 unit
->issue_delay
.max
, unit
->name
);
5426 if (unit
->needs_conflict_function
)
5427 printf ("%s_unit_conflict_cost, ", unit
->name
);
5431 printf ("%d, ", unit
->max_blockage
);
5433 if (unit
->needs_range_function
)
5434 printf ("%s_unit_blockage_range, ", unit
->name
);
5438 if (unit
->needs_blockage_function
)
5439 printf ("%s_unit_blockage", unit
->name
);
5450 write_complex_function (unit
, name
, connection
)
5451 struct function_unit
*unit
;
5452 char *name
, *connection
;
5454 struct attr_desc
*case_attr
, *attr
;
5455 struct attr_value
*av
, *common_av
;
5461 printf ("static int\n");
5462 printf ("%s_unit_%s (executing_insn, candidate_insn)\n",
5464 printf (" rtx executing_insn;\n");
5465 printf (" rtx candidate_insn;\n");
5467 printf (" rtx insn;\n");
5468 printf (" int casenum;\n\n");
5469 printf (" insn = executing_insn;\n");
5470 printf (" switch (recog_memoized (insn))\n");
5473 /* Write the `switch' statement to get the case value. */
5474 str
= (char *) alloca (strlen (unit
->name
) + strlen (name
) + strlen (connection
) + 10);
5475 sprintf (str
, "*%s_cases", unit
->name
);
5476 case_attr
= find_attr (str
, 0);
5477 if (! case_attr
) abort ();
5478 common_av
= find_most_used (case_attr
);
5480 for (av
= case_attr
->first_value
; av
; av
= av
->next
)
5481 if (av
!= common_av
)
5482 write_attr_case (case_attr
, av
, 1,
5483 "casenum =", ";", 4, unit
->condexp
);
5485 write_attr_case (case_attr
, common_av
, 0,
5486 "casenum =", ";", 4, unit
->condexp
);
5489 /* Now write an outer switch statement on each case. Then write
5490 the tests on the executing function within each. */
5491 printf (" insn = candidate_insn;\n");
5492 printf (" switch (casenum)\n");
5495 for (i
= 0; i
< unit
->num_opclasses
; i
++)
5497 /* Ensure using this case. */
5499 for (av
= case_attr
->first_value
; av
; av
= av
->next
)
5501 && contained_in_p (make_numeric_value (i
), av
->value
))
5507 printf (" case %d:\n", i
);
5508 sprintf (str
, "*%s_%s_%d", unit
->name
, connection
, i
);
5509 attr
= find_attr (str
, 0);
5510 if (! attr
) abort ();
5512 /* If single value, just write it. */
5513 value
= find_single_value (attr
);
5515 write_attr_set (attr
, 6, value
, "return", ";\n", true_rtx
, -2, -2);
5518 common_av
= find_most_used (attr
);
5519 printf (" switch (recog_memoized (insn))\n");
5522 for (av
= attr
->first_value
; av
; av
= av
->next
)
5523 if (av
!= common_av
)
5524 write_attr_case (attr
, av
, 1,
5525 "return", ";", 8, unit
->condexp
);
5527 write_attr_case (attr
, common_av
, 0,
5528 "return", ";", 8, unit
->condexp
);
5533 /* This default case should not be needed, but gcc's analysis is not
5534 good enough to realize that the default case is not needed for the
5535 second switch statement. */
5536 printf (" default:\n abort ();\n");
5537 printf (" }\n}\n\n");
5540 /* This page contains miscellaneous utility routines. */
5542 /* Given a string, return the number of comma-separated elements in it.
5543 Return 0 for the null string. */
5554 for (n
= 1; *s
; s
++)
5561 /* Given a pointer to a (char *), return a malloc'ed string containing the
5562 next comma-separated element. Advance the pointer to after the string
5563 scanned, or the end-of-string. Return NULL if at end of string. */
5566 next_comma_elt (pstr
)
5575 /* Find end of string to compute length. */
5576 for (p
= *pstr
; *p
!= ',' && *p
!= '\0'; p
++)
5579 out_str
= attr_string (*pstr
, p
- *pstr
);
5588 /* Return a `struct attr_desc' pointer for a given named attribute. If CREATE
5589 is non-zero, build a new attribute, if one does not exist. */
5591 static struct attr_desc
*
5592 find_attr (name
, create
)
5596 struct attr_desc
*attr
;
5599 /* Before we resort to using `strcmp', see if the string address matches
5600 anywhere. In most cases, it should have been canonicalized to do so. */
5601 if (name
== alternative_name
)
5604 index
= name
[0] & (MAX_ATTRS_INDEX
- 1);
5605 for (attr
= attrs
[index
]; attr
; attr
= attr
->next
)
5606 if (name
== attr
->name
)
5609 /* Otherwise, do it the slow way. */
5610 for (attr
= attrs
[index
]; attr
; attr
= attr
->next
)
5611 if (name
[0] == attr
->name
[0] && ! strcmp (name
, attr
->name
))
5617 attr
= (struct attr_desc
*) oballoc (sizeof (struct attr_desc
));
5618 attr
->name
= attr_string (name
, strlen (name
));
5619 attr
->first_value
= attr
->default_val
= NULL
;
5620 attr
->is_numeric
= attr
->negative_ok
= attr
->is_const
= attr
->is_special
= 0;
5621 attr
->next
= attrs
[index
];
5622 attrs
[index
] = attr
;
5627 /* Create internal attribute with the given default value. */
5630 make_internal_attr (name
, value
, special
)
5635 struct attr_desc
*attr
;
5637 attr
= find_attr (name
, 1);
5638 if (attr
->default_val
)
5641 attr
->is_numeric
= 1;
5643 attr
->is_special
= (special
& 1) != 0;
5644 attr
->negative_ok
= (special
& 2) != 0;
5645 attr
->unsigned_p
= (special
& 4) != 0;
5646 attr
->default_val
= get_attr_value (value
, attr
, -2);
5649 /* Find the most used value of an attribute. */
5651 static struct attr_value
*
5652 find_most_used (attr
)
5653 struct attr_desc
*attr
;
5655 struct attr_value
*av
;
5656 struct attr_value
*most_used
;
5662 for (av
= attr
->first_value
; av
; av
= av
->next
)
5663 if (av
->num_insns
> nuses
)
5664 nuses
= av
->num_insns
, most_used
= av
;
5669 /* If an attribute only has a single value used, return it. Otherwise
5673 find_single_value (attr
)
5674 struct attr_desc
*attr
;
5676 struct attr_value
*av
;
5679 unique_value
= NULL
;
5680 for (av
= attr
->first_value
; av
; av
= av
->next
)
5686 unique_value
= av
->value
;
5689 return unique_value
;
5692 /* Return (attr_value "n") */
5695 make_numeric_value (n
)
5698 static rtx int_values
[20];
5705 if (n
< 20 && int_values
[n
])
5706 return int_values
[n
];
5708 p
= attr_printf (MAX_DIGITS
, "%d", n
);
5709 exp
= attr_rtx (CONST_STRING
, p
);
5712 int_values
[n
] = exp
;
5718 extend_range (range
, min
, max
)
5719 struct range
*range
;
5723 if (range
->min
> min
) range
->min
= min
;
5724 if (range
->max
< max
) range
->max
= max
;
5728 xrealloc (ptr
, size
)
5732 char *result
= (char *) realloc (ptr
, size
);
5734 fatal ("virtual memory exhausted");
5742 register char *val
= (char *) malloc (size
);
5745 fatal ("virtual memory exhausted");
5750 copy_rtx_unchanging (orig
)
5755 register RTX_CODE code
;
5758 if (RTX_UNCHANGING_P (orig
) || MEM_IN_STRUCT_P (orig
))
5761 MEM_IN_STRUCT_P (orig
) = 1;
5765 code
= GET_CODE (orig
);
5778 copy
= rtx_alloc (code
);
5779 PUT_MODE (copy
, GET_MODE (orig
));
5780 RTX_UNCHANGING_P (copy
) = 1;
5782 bcopy ((char *) &XEXP (orig
, 0), (char *) &XEXP (copy
, 0),
5783 GET_RTX_LENGTH (GET_CODE (copy
)) * sizeof (rtx
));
5793 fprintf (stderr
, "genattrtab: ");
5794 fprintf (stderr
, s
, a1
, a2
);
5795 fprintf (stderr
, "\n");
5796 exit (FATAL_EXIT_CODE
);
5799 /* More 'friendly' abort that prints the line and file.
5800 config.h can #define abort fancy_abort if you like that sort of thing. */
5805 fatal ("Internal gcc abort.");
5808 /* Determine if an insn has a constant number of delay slots, i.e., the
5809 number of delay slots is not a function of the length of the insn. */
5812 write_const_num_delay_slots ()
5814 struct attr_desc
*attr
= find_attr ("*num_delay_slots", 0);
5815 struct attr_value
*av
;
5816 struct insn_ent
*ie
;
5820 printf ("int\nconst_num_delay_slots (insn)\n");
5821 printf (" rtx insn;\n");
5823 printf (" switch (recog_memoized (insn))\n");
5826 for (av
= attr
->first_value
; av
; av
= av
->next
)
5829 walk_attr_value (av
->value
);
5832 for (ie
= av
->first_insn
; ie
; ie
= ie
->next
)
5833 if (ie
->insn_code
!= -1)
5834 printf (" case %d:\n", ie
->insn_code
);
5835 printf (" return 0;\n");
5839 printf (" default:\n");
5840 printf (" return 1;\n");
5841 printf (" }\n}\n\n");
5854 struct attr_desc
*attr
;
5855 struct insn_def
*id
;
5859 #if defined (RLIMIT_STACK) && defined (HAVE_GETRLIMIT) && defined (HAVE_SETRLIMIT)
5860 /* Get rid of any avoidable limit on stack size. */
5864 /* Set the stack limit huge so that alloca does not fail. */
5865 getrlimit (RLIMIT_STACK
, &rlim
);
5866 rlim
.rlim_cur
= rlim
.rlim_max
;
5867 setrlimit (RLIMIT_STACK
, &rlim
);
5871 obstack_init (rtl_obstack
);
5872 obstack_init (hash_obstack
);
5873 obstack_init (temp_obstack
);
5876 fatal ("No input file name.");
5878 infile
= fopen (argv
[1], "r");
5882 exit (FATAL_EXIT_CODE
);
5887 /* Set up true and false rtx's */
5888 true_rtx
= rtx_alloc (CONST_INT
);
5889 XWINT (true_rtx
, 0) = 1;
5890 false_rtx
= rtx_alloc (CONST_INT
);
5891 XWINT (false_rtx
, 0) = 0;
5892 RTX_UNCHANGING_P (true_rtx
) = RTX_UNCHANGING_P (false_rtx
) = 1;
5893 RTX_INTEGRATED_P (true_rtx
) = RTX_INTEGRATED_P (false_rtx
) = 1;
5895 alternative_name
= attr_string ("alternative", strlen ("alternative"));
5897 printf ("/* Generated automatically by the program `genattrtab'\n\
5898 from the machine description file `md'. */\n\n");
5900 /* Read the machine description. */
5904 c
= read_skip_spaces (infile
);
5909 desc
= read_rtx (infile
);
5910 if (GET_CODE (desc
) == DEFINE_INSN
5911 || GET_CODE (desc
) == DEFINE_PEEPHOLE
5912 || GET_CODE (desc
) == DEFINE_ASM_ATTRIBUTES
)
5915 else if (GET_CODE (desc
) == DEFINE_EXPAND
)
5916 insn_code_number
++, insn_index_number
++;
5918 else if (GET_CODE (desc
) == DEFINE_SPLIT
)
5919 insn_code_number
++, insn_index_number
++;
5921 else if (GET_CODE (desc
) == DEFINE_ATTR
)
5924 insn_index_number
++;
5927 else if (GET_CODE (desc
) == DEFINE_DELAY
)
5930 insn_index_number
++;
5933 else if (GET_CODE (desc
) == DEFINE_FUNCTION_UNIT
)
5936 insn_index_number
++;
5940 /* If we didn't have a DEFINE_ASM_ATTRIBUTES, make a null one. */
5941 if (! got_define_asm_attributes
)
5943 tem
= rtx_alloc (DEFINE_ASM_ATTRIBUTES
);
5944 XVEC (tem
, 0) = rtvec_alloc (0);
5948 /* Expand DEFINE_DELAY information into new attribute. */
5952 /* Expand DEFINE_FUNCTION_UNIT information into new attributes. */
5956 printf ("#include \"config.h\"\n");
5957 printf ("#include \"system.h\"\n");
5958 printf ("#include \"rtl.h\"\n");
5959 printf ("#include \"insn-config.h\"\n");
5960 printf ("#include \"recog.h\"\n");
5961 printf ("#include \"regs.h\"\n");
5962 printf ("#include \"real.h\"\n");
5963 printf ("#include \"output.h\"\n");
5964 printf ("#include \"insn-attr.h\"\n");
5966 printf ("#define operands recog_operand\n\n");
5968 /* Make `insn_alternatives'. */
5969 insn_alternatives
= (int *) oballoc (insn_code_number
* sizeof (int));
5970 for (id
= defs
; id
; id
= id
->next
)
5971 if (id
->insn_code
>= 0)
5972 insn_alternatives
[id
->insn_code
] = (1 << id
->num_alternatives
) - 1;
5974 /* Make `insn_n_alternatives'. */
5975 insn_n_alternatives
= (int *) oballoc (insn_code_number
* sizeof (int));
5976 for (id
= defs
; id
; id
= id
->next
)
5977 if (id
->insn_code
>= 0)
5978 insn_n_alternatives
[id
->insn_code
] = id
->num_alternatives
;
5980 /* Prepare to write out attribute subroutines by checking everything stored
5981 away and building the attribute cases. */
5984 for (i
= 0; i
< MAX_ATTRS_INDEX
; i
++)
5985 for (attr
= attrs
[i
]; attr
; attr
= attr
->next
)
5987 attr
->default_val
->value
5988 = check_attr_value (attr
->default_val
->value
, attr
);
5992 /* Construct extra attributes for `length'. */
5993 make_length_attrs ();
5995 /* Perform any possible optimizations to speed up compilation. */
5998 /* Now write out all the `gen_attr_...' routines. Do these before the
5999 special routines (specifically before write_function_unit_info), so
6000 that they get defined before they are used. */
6002 for (i
= 0; i
< MAX_ATTRS_INDEX
; i
++)
6003 for (attr
= attrs
[i
]; attr
; attr
= attr
->next
)
6005 if (! attr
->is_special
&& ! attr
->is_const
)
6006 write_attr_get (attr
);
6009 /* Write out delay eligibility information, if DEFINE_DELAY present.
6010 (The function to compute the number of delay slots will be written
6014 write_eligible_delay ("delay");
6015 if (have_annul_true
)
6016 write_eligible_delay ("annul_true");
6017 if (have_annul_false
)
6018 write_eligible_delay ("annul_false");
6021 /* Write out information about function units. */
6023 write_function_unit_info ();
6025 /* Write out constant delay slot info */
6026 write_const_num_delay_slots ();
6028 write_length_unit_log ();
6031 exit (ferror (stdout
) != 0 ? FATAL_EXIT_CODE
: SUCCESS_EXIT_CODE
);