1 /* Generate code from machine description to compute values of attributes.
2 Copyright (C) 1991, 93-98, 1999 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, `extract_insn' 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. */
101 #include "insn-config.h" /* For REGISTER_CONSTRAINTS */
104 #ifdef HAVE_SYS_RESOURCE_H
105 # include <sys/resource.h>
108 /* We must include obstack.h after <sys/time.h>, to avoid lossage with
109 /usr/include/sys/stdtypes.h on Sun OS 4.x. */
113 static struct obstack obstack
, obstack1
, obstack2
;
114 struct obstack
*rtl_obstack
= &obstack
;
115 struct obstack
*hash_obstack
= &obstack1
;
116 struct obstack
*temp_obstack
= &obstack2
;
118 #define obstack_chunk_alloc xmalloc
119 #define obstack_chunk_free free
121 /* enough space to reserve for printing out ints */
122 #define MAX_DIGITS (HOST_BITS_PER_INT * 3 / 10 + 3)
124 /* Define structures used to record attributes and values. */
126 /* As each DEFINE_INSN, DEFINE_PEEPHOLE, or DEFINE_ASM_ATTRIBUTES is
127 encountered, we store all the relevant information into a
128 `struct insn_def'. This is done to allow attribute definitions to occur
129 anywhere in the file. */
133 int insn_code
; /* Instruction number. */
134 int insn_index
; /* Expression numer in file, for errors. */
135 struct insn_def
*next
; /* Next insn in chain. */
136 rtx def
; /* The DEFINE_... */
137 int num_alternatives
; /* Number of alternatives. */
138 int vec_idx
; /* Index of attribute vector in `def'. */
141 /* Once everything has been read in, we store in each attribute value a list
142 of insn codes that have that value. Here is the structure used for the
147 int insn_code
; /* Instruction number. */
148 int insn_index
; /* Index of definition in file */
149 struct insn_ent
*next
; /* Next in chain. */
152 /* Each value of an attribute (either constant or computed) is assigned a
153 structure which is used as the listhead of the insns that have that
158 rtx value
; /* Value of attribute. */
159 struct attr_value
*next
; /* Next attribute value in chain. */
160 struct insn_ent
*first_insn
; /* First insn with this value. */
161 int num_insns
; /* Number of insns with this value. */
162 int has_asm_insn
; /* True if this value used for `asm' insns */
165 /* Structure for each attribute. */
169 char *name
; /* Name of attribute. */
170 struct attr_desc
*next
; /* Next attribute. */
171 unsigned is_numeric
: 1; /* Values of this attribute are numeric. */
172 unsigned negative_ok
: 1; /* Allow negative numeric values. */
173 unsigned unsigned_p
: 1; /* Make the output function unsigned int. */
174 unsigned is_const
: 1; /* Attribute value constant for each run. */
175 unsigned is_special
: 1; /* Don't call `write_attr_set'. */
176 unsigned func_units_p
: 1; /* this is the function_units attribute */
177 unsigned blockage_p
: 1; /* this is the blockage range function */
178 struct attr_value
*first_value
; /* First value of this attribute. */
179 struct attr_value
*default_val
; /* Default value for this attribute. */
182 #define NULL_ATTR (struct attr_desc *) NULL
184 /* A range of values. */
192 /* Structure for each DEFINE_DELAY. */
196 rtx def
; /* DEFINE_DELAY expression. */
197 struct delay_desc
*next
; /* Next DEFINE_DELAY. */
198 int num
; /* Number of DEFINE_DELAY, starting at 1. */
201 /* Record information about each DEFINE_FUNCTION_UNIT. */
203 struct function_unit_op
205 rtx condexp
; /* Expression TRUE for applicable insn. */
206 struct function_unit_op
*next
; /* Next operation for this function unit. */
207 int num
; /* Ordinal for this operation type in unit. */
208 int ready
; /* Cost until data is ready. */
209 int issue_delay
; /* Cost until unit can accept another insn. */
210 rtx conflict_exp
; /* Expression TRUE for insns incurring issue delay. */
211 rtx issue_exp
; /* Expression computing issue delay. */
214 /* Record information about each function unit mentioned in a
215 DEFINE_FUNCTION_UNIT. */
219 char *name
; /* Function unit name. */
220 struct function_unit
*next
; /* Next function unit. */
221 int num
; /* Ordinal of this unit type. */
222 int multiplicity
; /* Number of units of this type. */
223 int simultaneity
; /* Maximum number of simultaneous insns
224 on this function unit or 0 if unlimited. */
225 rtx condexp
; /* Expression TRUE for insn needing unit. */
226 int num_opclasses
; /* Number of different operation types. */
227 struct function_unit_op
*ops
; /* Pointer to first operation type. */
228 int needs_conflict_function
; /* Nonzero if a conflict function required. */
229 int needs_blockage_function
; /* Nonzero if a blockage function required. */
230 int needs_range_function
; /* Nonzero if blockage range function needed.*/
231 rtx default_cost
; /* Conflict cost, if constant. */
232 struct range issue_delay
; /* Range of issue delay values. */
233 int max_blockage
; /* Maximum time an insn blocks the unit. */
236 /* Listheads of above structures. */
238 /* This one is indexed by the first character of the attribute name. */
239 #define MAX_ATTRS_INDEX 256
240 static struct attr_desc
*attrs
[MAX_ATTRS_INDEX
];
241 static struct insn_def
*defs
;
242 static struct delay_desc
*delays
;
243 static struct function_unit
*units
;
245 /* An expression where all the unknown terms are EQ_ATTR tests can be
246 rearranged into a COND provided we can enumerate all possible
247 combinations of the unknown values. The set of combinations become the
248 tests of the COND; the value of the expression given that combination is
249 computed and becomes the corresponding value. To do this, we must be
250 able to enumerate all values for each attribute used in the expression
251 (currently, we give up if we find a numeric attribute).
253 If the set of EQ_ATTR tests used in an expression tests the value of N
254 different attributes, the list of all possible combinations can be made
255 by walking the N-dimensional attribute space defined by those
256 attributes. We record each of these as a struct dimension.
258 The algorithm relies on sharing EQ_ATTR nodes: if two nodes in an
259 expression are the same, the will also have the same address. We find
260 all the EQ_ATTR nodes by marking them MEM_VOLATILE_P. This bit later
261 represents the value of an EQ_ATTR node, so once all nodes are marked,
262 they are also given an initial value of FALSE.
264 We then separate the set of EQ_ATTR nodes into dimensions for each
265 attribute and put them on the VALUES list. Terms are added as needed by
266 `add_values_to_cover' so that all possible values of the attribute are
269 Each dimension also has a current value. This is the node that is
270 currently considered to be TRUE. If this is one of the nodes added by
271 `add_values_to_cover', all the EQ_ATTR tests in the original expression
272 will be FALSE. Otherwise, only the CURRENT_VALUE will be true.
274 NUM_VALUES is simply the length of the VALUES list and is there for
277 Once the dimensions are created, the algorithm enumerates all possible
278 values and computes the current value of the given expression. */
282 struct attr_desc
*attr
; /* Attribute for this dimension. */
283 rtx values
; /* List of attribute values used. */
284 rtx current_value
; /* Position in the list for the TRUE value. */
285 int num_values
; /* Length of the values list. */
288 /* Other variables. */
290 static int insn_code_number
;
291 static int insn_index_number
;
292 static int got_define_asm_attributes
;
293 static int must_extract
;
294 static int must_constrain
;
295 static int address_used
;
296 static int length_used
;
297 static int num_delays
;
298 static int have_annul_true
, have_annul_false
;
299 static int num_units
, num_unit_opclasses
;
300 static int num_insn_ents
;
302 /* Used as operand to `operate_exp': */
304 enum operator {PLUS_OP
, MINUS_OP
, POS_MINUS_OP
, EQ_OP
, OR_OP
, ORX_OP
, MAX_OP
, MIN_OP
, RANGE_OP
};
306 /* Stores, for each insn code, the number of constraint alternatives. */
308 static int *insn_n_alternatives
;
310 /* Stores, for each insn code, a bitmap that has bits on for each possible
313 static int *insn_alternatives
;
315 /* If nonzero, assume that the `alternative' attr has this value.
316 This is the hashed, unique string for the numeral
317 whose value is chosen alternative. */
319 static char *current_alternative_string
;
321 /* Used to simplify expressions. */
323 static rtx true_rtx
, false_rtx
;
325 /* Used to reduce calls to `strcmp' */
327 static char *alternative_name
;
329 /* Indicate that REG_DEAD notes are valid if dead_or_set_p is ever
332 int reload_completed
= 0;
334 /* Some machines test `optimize' in macros called from rtlanal.c, so we need
335 to define it here. */
339 /* Simplify an expression. Only call the routine if there is something to
341 #define SIMPLIFY_TEST_EXP(EXP,INSN_CODE,INSN_INDEX) \
342 (RTX_UNCHANGING_P (EXP) || MEM_IN_STRUCT_P (EXP) ? (EXP) \
343 : simplify_test_exp (EXP, INSN_CODE, INSN_INDEX))
345 /* Simplify (eq_attr ("alternative") ...)
346 when we are working with a particular alternative. */
347 #define SIMPLIFY_ALTERNATIVE(EXP) \
348 if (current_alternative_string \
349 && GET_CODE ((EXP)) == EQ_ATTR \
350 && XSTR ((EXP), 0) == alternative_name) \
351 (EXP) = (XSTR ((EXP), 1) == current_alternative_string \
352 ? true_rtx : false_rtx);
354 /* These are referenced by rtlanal.c and hence need to be defined somewhere.
355 They won't actually be used. */
357 struct _global_rtl global_rtl
;
358 rtx pic_offset_table_rtx
;
360 static void attr_hash_add_rtx
PROTO((int, rtx
));
361 static void attr_hash_add_string
PROTO((int, char *));
362 static rtx attr_rtx
PVPROTO((enum rtx_code
, ...));
363 static char *attr_printf
PVPROTO((int, const char *, ...))
365 static char *attr_string
PROTO((const char *, int));
366 static rtx check_attr_test
PROTO((rtx
, int));
367 static rtx check_attr_value
PROTO((rtx
, struct attr_desc
*));
368 static rtx convert_set_attr_alternative
PROTO((rtx
, int, int));
369 static rtx convert_set_attr
PROTO((rtx
, int, int));
370 static void check_defs
PROTO((void));
372 static rtx convert_const_symbol_ref
PROTO((rtx
, struct attr_desc
*));
374 static rtx make_canonical
PROTO((struct attr_desc
*, rtx
));
375 static struct attr_value
*get_attr_value
PROTO((rtx
, struct attr_desc
*, int));
376 static rtx copy_rtx_unchanging
PROTO((rtx
));
377 static rtx copy_boolean
PROTO((rtx
));
378 static void expand_delays
PROTO((void));
379 static rtx operate_exp
PROTO((enum operator, rtx
, rtx
));
380 static void expand_units
PROTO((void));
381 static rtx simplify_knowing
PROTO((rtx
, rtx
));
382 static rtx encode_units_mask
PROTO((rtx
));
383 static void fill_attr
PROTO((struct attr_desc
*));
384 /* dpx2 compiler chokes if we specify the arg types of the args. */
385 static rtx substitute_address
PROTO((rtx
, rtx (*) (rtx
), rtx (*) (rtx
)));
386 static void make_length_attrs
PROTO((void));
387 static rtx identity_fn
PROTO((rtx
));
388 static rtx zero_fn
PROTO((rtx
));
389 static rtx one_fn
PROTO((rtx
));
390 static rtx max_fn
PROTO((rtx
));
391 static void write_length_unit_log
PROTO ((void));
392 static rtx simplify_cond
PROTO((rtx
, int, int));
394 static rtx simplify_by_alternatives
PROTO((rtx
, int, int));
396 static rtx simplify_by_exploding
PROTO((rtx
));
397 static int find_and_mark_used_attributes
PROTO((rtx
, rtx
*, int *));
398 static void unmark_used_attributes
PROTO((rtx
, struct dimension
*, int));
399 static int add_values_to_cover
PROTO((struct dimension
*));
400 static int increment_current_value
PROTO((struct dimension
*, int));
401 static rtx test_for_current_value
PROTO((struct dimension
*, int));
402 static rtx simplify_with_current_value
PROTO((rtx
, struct dimension
*, int));
403 static rtx simplify_with_current_value_aux
PROTO((rtx
));
404 static void clear_struct_flag
PROTO((rtx
));
405 static int count_sub_rtxs
PROTO((rtx
, int));
406 static void remove_insn_ent
PROTO((struct attr_value
*, struct insn_ent
*));
407 static void insert_insn_ent
PROTO((struct attr_value
*, struct insn_ent
*));
408 static rtx insert_right_side
PROTO((enum rtx_code
, rtx
, rtx
, int, int));
409 static rtx make_alternative_compare
PROTO((int));
410 static int compute_alternative_mask
PROTO((rtx
, enum rtx_code
));
411 static rtx evaluate_eq_attr
PROTO((rtx
, rtx
, int, int));
412 static rtx simplify_and_tree
PROTO((rtx
, rtx
*, int, int));
413 static rtx simplify_or_tree
PROTO((rtx
, rtx
*, int, int));
414 static rtx simplify_test_exp
PROTO((rtx
, int, int));
415 static void optimize_attrs
PROTO((void));
416 static void gen_attr
PROTO((rtx
));
417 static int count_alternatives
PROTO((rtx
));
418 static int compares_alternatives_p
PROTO((rtx
));
419 static int contained_in_p
PROTO((rtx
, rtx
));
420 static void gen_insn
PROTO((rtx
));
421 static void gen_delay
PROTO((rtx
));
422 static void gen_unit
PROTO((rtx
));
423 static void write_test_expr
PROTO((rtx
, int));
424 static int max_attr_value
PROTO((rtx
, int*));
425 static int or_attr_value
PROTO((rtx
, int*));
426 static void walk_attr_value
PROTO((rtx
));
427 static void write_attr_get
PROTO((struct attr_desc
*));
428 static rtx eliminate_known_true
PROTO((rtx
, rtx
, int, int));
429 static void write_attr_set
PROTO((struct attr_desc
*, int, rtx
,
430 const char *, const char *, rtx
,
432 static void write_attr_case
PROTO((struct attr_desc
*, struct attr_value
*,
433 int, const char *, const char *, int, rtx
));
434 static void write_unit_name
PROTO((const char *, int, const char *));
435 static void write_attr_valueq
PROTO((struct attr_desc
*, char *));
436 static void write_attr_value
PROTO((struct attr_desc
*, rtx
));
437 static void write_upcase
PROTO((char *));
438 static void write_indent
PROTO((int));
439 static void write_eligible_delay
PROTO((const char *));
440 static void write_function_unit_info
PROTO((void));
441 static void write_complex_function
PROTO((struct function_unit
*, const char *,
443 static int write_expr_attr_cache
PROTO((rtx
, struct attr_desc
*));
444 static void write_toplevel_expr
PROTO((rtx
));
445 static void write_const_num_delay_slots
PROTO ((void));
446 static int n_comma_elts
PROTO((char *));
447 static char *next_comma_elt
PROTO((char **));
448 static struct attr_desc
*find_attr
PROTO((const char *, int));
449 static void make_internal_attr
PROTO((const char *, rtx
, int));
450 static struct attr_value
*find_most_used
PROTO((struct attr_desc
*));
451 static rtx find_single_value
PROTO((struct attr_desc
*));
452 static rtx make_numeric_value
PROTO((int));
453 static void extend_range
PROTO((struct range
*, int, int));
454 static rtx attr_eq
PROTO((char *, char *));
455 static char *attr_numeral
PROTO((int));
456 static int attr_equal_p
PROTO((rtx
, rtx
));
457 static rtx attr_copy_rtx
PROTO((rtx
));
459 #define oballoc(size) obstack_alloc (hash_obstack, size)
462 /* Hash table for sharing RTL and strings. */
464 /* Each hash table slot is a bucket containing a chain of these structures.
465 Strings are given negative hash codes; RTL expressions are given positive
470 struct attr_hash
*next
; /* Next structure in the bucket. */
471 int hashcode
; /* Hash code of this rtx or string. */
474 char *str
; /* The string (negative hash codes) */
475 rtx rtl
; /* or the RTL recorded here. */
479 /* Now here is the hash table. When recording an RTL, it is added to
480 the slot whose index is the hash code mod the table size. Note
481 that the hash table is used for several kinds of RTL (see attr_rtx)
482 and for strings. While all these live in the same table, they are
483 completely independent, and the hash code is computed differently
486 #define RTL_HASH_SIZE 4093
487 struct attr_hash
*attr_hash_table
[RTL_HASH_SIZE
];
489 /* Here is how primitive or already-shared RTL's hash
491 #define RTL_HASH(RTL) ((long) (RTL) & 0777777)
493 /* Add an entry to the hash table for RTL with hash code HASHCODE. */
496 attr_hash_add_rtx (hashcode
, rtl
)
500 register struct attr_hash
*h
;
502 h
= (struct attr_hash
*) obstack_alloc (hash_obstack
,
503 sizeof (struct attr_hash
));
504 h
->hashcode
= hashcode
;
506 h
->next
= attr_hash_table
[hashcode
% RTL_HASH_SIZE
];
507 attr_hash_table
[hashcode
% RTL_HASH_SIZE
] = h
;
510 /* Add an entry to the hash table for STRING with hash code HASHCODE. */
513 attr_hash_add_string (hashcode
, str
)
517 register struct attr_hash
*h
;
519 h
= (struct attr_hash
*) obstack_alloc (hash_obstack
,
520 sizeof (struct attr_hash
));
521 h
->hashcode
= -hashcode
;
523 h
->next
= attr_hash_table
[hashcode
% RTL_HASH_SIZE
];
524 attr_hash_table
[hashcode
% RTL_HASH_SIZE
] = h
;
527 /* Generate an RTL expression, but avoid duplicates.
528 Set the RTX_INTEGRATED_P flag for these permanent objects.
530 In some cases we cannot uniquify; then we return an ordinary
531 impermanent rtx with RTX_INTEGRATED_P clear.
533 Args are like gen_rtx, but without the mode:
535 rtx attr_rtx (code, [element1, ..., elementn]) */
539 attr_rtx
VPROTO((enum rtx_code code
, ...))
541 #ifndef ANSI_PROTOTYPES
545 register int i
; /* Array indices... */
546 register const char *fmt
; /* Current rtx's format... */
547 register rtx rt_val
; /* RTX to return to caller... */
549 register struct attr_hash
*h
;
550 struct obstack
*old_obstack
= rtl_obstack
;
554 #ifndef ANSI_PROTOTYPES
555 code
= va_arg (p
, enum rtx_code
);
558 /* For each of several cases, search the hash table for an existing entry.
559 Use that entry if one is found; otherwise create a new RTL and add it
562 if (GET_RTX_CLASS (code
) == '1')
564 rtx arg0
= va_arg (p
, rtx
);
566 /* A permanent object cannot point to impermanent ones. */
567 if (! RTX_INTEGRATED_P (arg0
))
569 rt_val
= rtx_alloc (code
);
570 XEXP (rt_val
, 0) = arg0
;
575 hashcode
= ((HOST_WIDE_INT
) code
+ RTL_HASH (arg0
));
576 for (h
= attr_hash_table
[hashcode
% RTL_HASH_SIZE
]; h
; h
= h
->next
)
577 if (h
->hashcode
== hashcode
578 && GET_CODE (h
->u
.rtl
) == code
579 && XEXP (h
->u
.rtl
, 0) == arg0
)
584 rtl_obstack
= hash_obstack
;
585 rt_val
= rtx_alloc (code
);
586 XEXP (rt_val
, 0) = arg0
;
589 else if (GET_RTX_CLASS (code
) == 'c'
590 || GET_RTX_CLASS (code
) == '2'
591 || GET_RTX_CLASS (code
) == '<')
593 rtx arg0
= va_arg (p
, rtx
);
594 rtx arg1
= va_arg (p
, rtx
);
596 /* A permanent object cannot point to impermanent ones. */
597 if (! RTX_INTEGRATED_P (arg0
) || ! RTX_INTEGRATED_P (arg1
))
599 rt_val
= rtx_alloc (code
);
600 XEXP (rt_val
, 0) = arg0
;
601 XEXP (rt_val
, 1) = arg1
;
606 hashcode
= ((HOST_WIDE_INT
) code
+ RTL_HASH (arg0
) + RTL_HASH (arg1
));
607 for (h
= attr_hash_table
[hashcode
% RTL_HASH_SIZE
]; h
; h
= h
->next
)
608 if (h
->hashcode
== hashcode
609 && GET_CODE (h
->u
.rtl
) == code
610 && XEXP (h
->u
.rtl
, 0) == arg0
611 && XEXP (h
->u
.rtl
, 1) == arg1
)
616 rtl_obstack
= hash_obstack
;
617 rt_val
= rtx_alloc (code
);
618 XEXP (rt_val
, 0) = arg0
;
619 XEXP (rt_val
, 1) = arg1
;
622 else if (GET_RTX_LENGTH (code
) == 1
623 && GET_RTX_FORMAT (code
)[0] == 's')
625 char * arg0
= va_arg (p
, char *);
627 if (code
== SYMBOL_REF
)
628 arg0
= attr_string (arg0
, strlen (arg0
));
630 hashcode
= ((HOST_WIDE_INT
) code
+ RTL_HASH (arg0
));
631 for (h
= attr_hash_table
[hashcode
% RTL_HASH_SIZE
]; h
; h
= h
->next
)
632 if (h
->hashcode
== hashcode
633 && GET_CODE (h
->u
.rtl
) == code
634 && XSTR (h
->u
.rtl
, 0) == arg0
)
639 rtl_obstack
= hash_obstack
;
640 rt_val
= rtx_alloc (code
);
641 XSTR (rt_val
, 0) = arg0
;
644 else if (GET_RTX_LENGTH (code
) == 2
645 && GET_RTX_FORMAT (code
)[0] == 's'
646 && GET_RTX_FORMAT (code
)[1] == 's')
648 char *arg0
= va_arg (p
, char *);
649 char *arg1
= va_arg (p
, char *);
651 hashcode
= ((HOST_WIDE_INT
) code
+ RTL_HASH (arg0
) + RTL_HASH (arg1
));
652 for (h
= attr_hash_table
[hashcode
% RTL_HASH_SIZE
]; h
; h
= h
->next
)
653 if (h
->hashcode
== hashcode
654 && GET_CODE (h
->u
.rtl
) == code
655 && XSTR (h
->u
.rtl
, 0) == arg0
656 && XSTR (h
->u
.rtl
, 1) == arg1
)
661 rtl_obstack
= hash_obstack
;
662 rt_val
= rtx_alloc (code
);
663 XSTR (rt_val
, 0) = arg0
;
664 XSTR (rt_val
, 1) = arg1
;
667 else if (code
== CONST_INT
)
669 HOST_WIDE_INT arg0
= va_arg (p
, HOST_WIDE_INT
);
679 rt_val
= rtx_alloc (code
); /* Allocate the storage space. */
681 fmt
= GET_RTX_FORMAT (code
); /* Find the right format... */
682 for (i
= 0; i
< GET_RTX_LENGTH (code
); i
++)
686 case '0': /* Unused field. */
689 case 'i': /* An integer? */
690 XINT (rt_val
, i
) = va_arg (p
, int);
693 case 'w': /* A wide integer? */
694 XWINT (rt_val
, i
) = va_arg (p
, HOST_WIDE_INT
);
697 case 's': /* A string? */
698 XSTR (rt_val
, i
) = va_arg (p
, char *);
701 case 'e': /* An expression? */
702 case 'u': /* An insn? Same except when printing. */
703 XEXP (rt_val
, i
) = va_arg (p
, rtx
);
706 case 'E': /* An RTX vector? */
707 XVEC (rt_val
, i
) = va_arg (p
, rtvec
);
718 rtl_obstack
= old_obstack
;
720 attr_hash_add_rtx (hashcode
, rt_val
);
721 RTX_INTEGRATED_P (rt_val
) = 1;
729 /* Create a new string printed with the printf line arguments into a space
730 of at most LEN bytes:
732 rtx attr_printf (len, format, [arg1, ..., argn]) */
736 attr_printf
VPROTO((register int len
, const char *fmt
, ...))
738 #ifndef ANSI_PROTOTYPES
747 #ifndef ANSI_PROTOTYPES
748 len
= va_arg (p
, int);
749 fmt
= va_arg (p
, const char *);
752 /* Print the string into a temporary location. */
753 str
= (char *) alloca (len
);
754 vsprintf (str
, fmt
, p
);
757 return attr_string (str
, strlen (str
));
761 attr_eq (name
, value
)
764 return attr_rtx (EQ_ATTR
, attr_string (name
, strlen (name
)),
765 attr_string (value
, strlen (value
)));
772 return XSTR (make_numeric_value (n
), 0);
775 /* Return a permanent (possibly shared) copy of a string STR (not assumed
776 to be null terminated) with LEN bytes. */
779 attr_string (str
, len
)
783 register struct attr_hash
*h
;
786 register char *new_str
;
788 /* Compute the hash code. */
789 hashcode
= (len
+ 1) * 613 + (unsigned)str
[0];
790 for (i
= 1; i
<= len
; i
+= 2)
791 hashcode
= ((hashcode
* 613) + (unsigned)str
[i
]);
793 hashcode
= -hashcode
;
795 /* Search the table for the string. */
796 for (h
= attr_hash_table
[hashcode
% RTL_HASH_SIZE
]; h
; h
= h
->next
)
797 if (h
->hashcode
== -hashcode
&& h
->u
.str
[0] == str
[0]
798 && !strncmp (h
->u
.str
, str
, len
))
799 return h
->u
.str
; /* <-- return if found. */
801 /* Not found; create a permanent copy and add it to the hash table. */
802 new_str
= (char *) obstack_alloc (hash_obstack
, len
+ 1);
803 bcopy (str
, new_str
, len
);
805 attr_hash_add_string (hashcode
, new_str
);
807 return new_str
; /* Return the new string. */
810 /* Check two rtx's for equality of contents,
811 taking advantage of the fact that if both are hashed
812 then they can't be equal unless they are the same object. */
818 return (x
== y
|| (! (RTX_INTEGRATED_P (x
) && RTX_INTEGRATED_P (y
))
819 && rtx_equal_p (x
, y
)));
822 /* Copy an attribute value expression,
823 descending to all depths, but not copying any
824 permanent hashed subexpressions. */
832 register RTX_CODE code
;
833 register const char *format_ptr
;
835 /* No need to copy a permanent object. */
836 if (RTX_INTEGRATED_P (orig
))
839 code
= GET_CODE (orig
);
857 copy
= rtx_alloc (code
);
858 PUT_MODE (copy
, GET_MODE (orig
));
859 copy
->in_struct
= orig
->in_struct
;
860 copy
->volatil
= orig
->volatil
;
861 copy
->unchanging
= orig
->unchanging
;
862 copy
->integrated
= orig
->integrated
;
864 format_ptr
= GET_RTX_FORMAT (GET_CODE (copy
));
866 for (i
= 0; i
< GET_RTX_LENGTH (GET_CODE (copy
)); i
++)
868 switch (*format_ptr
++)
871 XEXP (copy
, i
) = XEXP (orig
, i
);
872 if (XEXP (orig
, i
) != NULL
)
873 XEXP (copy
, i
) = attr_copy_rtx (XEXP (orig
, i
));
878 XVEC (copy
, i
) = XVEC (orig
, i
);
879 if (XVEC (orig
, i
) != NULL
)
881 XVEC (copy
, i
) = rtvec_alloc (XVECLEN (orig
, i
));
882 for (j
= 0; j
< XVECLEN (copy
, i
); j
++)
883 XVECEXP (copy
, i
, j
) = attr_copy_rtx (XVECEXP (orig
, i
, j
));
889 XINT (copy
, i
) = XINT (orig
, i
);
893 XWINT (copy
, i
) = XWINT (orig
, i
);
898 XSTR (copy
, i
) = XSTR (orig
, i
);
908 /* Given a test expression for an attribute, ensure it is validly formed.
909 IS_CONST indicates whether the expression is constant for each compiler
910 run (a constant expression may not test any particular insn).
912 Convert (eq_attr "att" "a1,a2") to (ior (eq_attr ... ) (eq_attrq ..))
913 and (eq_attr "att" "!a1") to (not (eq_attr "att" "a1")). Do the latter
914 test first so that (eq_attr "att" "!a1,a2,a3") works as expected.
916 Update the string address in EQ_ATTR expression to be the same used
917 in the attribute (or `alternative_name') to speed up subsequent
918 `find_attr' calls and eliminate most `strcmp' calls.
920 Return the new expression, if any. */
923 check_attr_test (exp
, is_const
)
927 struct attr_desc
*attr
;
928 struct attr_value
*av
;
932 switch (GET_CODE (exp
))
935 /* Handle negation test. */
936 if (XSTR (exp
, 1)[0] == '!')
937 return check_attr_test (attr_rtx (NOT
,
938 attr_eq (XSTR (exp
, 0),
942 else if (n_comma_elts (XSTR (exp
, 1)) == 1)
944 attr
= find_attr (XSTR (exp
, 0), 0);
947 if (! strcmp (XSTR (exp
, 0), "alternative"))
949 XSTR (exp
, 0) = alternative_name
;
950 /* This can't be simplified any further. */
951 RTX_UNCHANGING_P (exp
) = 1;
955 fatal ("Unknown attribute `%s' in EQ_ATTR", XSTR (exp
, 0));
958 if (is_const
&& ! attr
->is_const
)
959 fatal ("Constant expression uses insn attribute `%s' in EQ_ATTR",
962 /* Copy this just to make it permanent,
963 so expressions using it can be permanent too. */
964 exp
= attr_eq (XSTR (exp
, 0), XSTR (exp
, 1));
966 /* It shouldn't be possible to simplify the value given to a
967 constant attribute, so don't expand this until it's time to
968 write the test expression. */
970 RTX_UNCHANGING_P (exp
) = 1;
972 if (attr
->is_numeric
)
974 for (p
= XSTR (exp
, 1); *p
; p
++)
975 if (*p
< '0' || *p
> '9')
976 fatal ("Attribute `%s' takes only numeric values",
981 for (av
= attr
->first_value
; av
; av
= av
->next
)
982 if (GET_CODE (av
->value
) == CONST_STRING
983 && ! strcmp (XSTR (exp
, 1), XSTR (av
->value
, 0)))
987 fatal ("Unknown value `%s' for `%s' attribute",
988 XSTR (exp
, 1), XSTR (exp
, 0));
993 /* Make an IOR tree of the possible values. */
995 name_ptr
= XSTR (exp
, 1);
996 while ((p
= next_comma_elt (&name_ptr
)) != NULL
)
998 newexp
= attr_eq (XSTR (exp
, 0), p
);
999 orexp
= insert_right_side (IOR
, orexp
, newexp
, -2, -2);
1002 return check_attr_test (orexp
, is_const
);
1010 /* Either TRUE or FALSE. */
1018 XEXP (exp
, 0) = check_attr_test (XEXP (exp
, 0), is_const
);
1019 XEXP (exp
, 1) = check_attr_test (XEXP (exp
, 1), is_const
);
1023 XEXP (exp
, 0) = check_attr_test (XEXP (exp
, 0), is_const
);
1029 fatal ("RTL operator \"%s\" not valid in constant attribute test",
1030 GET_RTX_NAME (GET_CODE (exp
)));
1031 /* These cases can't be simplified. */
1032 RTX_UNCHANGING_P (exp
) = 1;
1035 case LE
: case LT
: case GT
: case GE
:
1036 case LEU
: case LTU
: case GTU
: case GEU
:
1038 if (GET_CODE (XEXP (exp
, 0)) == SYMBOL_REF
1039 && GET_CODE (XEXP (exp
, 1)) == SYMBOL_REF
)
1040 exp
= attr_rtx (GET_CODE (exp
),
1041 attr_rtx (SYMBOL_REF
, XSTR (XEXP (exp
, 0), 0)),
1042 attr_rtx (SYMBOL_REF
, XSTR (XEXP (exp
, 1), 0)));
1043 /* These cases can't be simplified. */
1044 RTX_UNCHANGING_P (exp
) = 1;
1050 /* These cases are valid for constant attributes, but can't be
1052 exp
= attr_rtx (SYMBOL_REF
, XSTR (exp
, 0));
1053 RTX_UNCHANGING_P (exp
) = 1;
1057 fatal ("RTL operator \"%s\" not valid in attribute test",
1058 GET_RTX_NAME (GET_CODE (exp
)));
1064 /* Given an expression, ensure that it is validly formed and that all named
1065 attribute values are valid for the given attribute. Issue a fatal error
1066 if not. If no attribute is specified, assume a numeric attribute.
1068 Return a perhaps modified replacement expression for the value. */
1071 check_attr_value (exp
, attr
)
1073 struct attr_desc
*attr
;
1075 struct attr_value
*av
;
1079 switch (GET_CODE (exp
))
1082 if (attr
&& ! attr
->is_numeric
)
1083 fatal ("CONST_INT not valid for non-numeric `%s' attribute",
1086 if (INTVAL (exp
) < 0 && ! attr
->negative_ok
)
1087 fatal ("Negative numeric value specified for `%s' attribute",
1093 if (! strcmp (XSTR (exp
, 0), "*"))
1096 if (attr
== 0 || attr
->is_numeric
)
1099 if (attr
&& attr
->negative_ok
&& *p
== '-')
1102 if (*p
> '9' || *p
< '0')
1103 fatal ("Non-numeric value for numeric `%s' attribute",
1104 attr
? attr
->name
: "internal");
1108 for (av
= attr
->first_value
; av
; av
= av
->next
)
1109 if (GET_CODE (av
->value
) == CONST_STRING
1110 && ! strcmp (XSTR (av
->value
, 0), XSTR (exp
, 0)))
1114 fatal ("Unknown value `%s' for `%s' attribute",
1115 XSTR (exp
, 0), attr
? attr
->name
: "internal");
1120 XEXP (exp
, 0) = check_attr_test (XEXP (exp
, 0),
1121 attr
? attr
->is_const
: 0);
1122 XEXP (exp
, 1) = check_attr_value (XEXP (exp
, 1), attr
);
1123 XEXP (exp
, 2) = check_attr_value (XEXP (exp
, 2), attr
);
1131 if (attr
&& !attr
->is_numeric
)
1132 fatal ("Invalid operation `%s' for non-numeric attribute value",
1133 GET_RTX_NAME (GET_CODE (exp
)));
1138 XEXP (exp
, 0) = check_attr_value (XEXP (exp
, 0), attr
);
1139 XEXP (exp
, 1) = check_attr_value (XEXP (exp
, 1), attr
);
1143 XEXP (exp
, 0) = check_attr_value (XEXP (exp
, 0), attr
);
1147 if (XVECLEN (exp
, 0) % 2 != 0)
1148 fatal ("First operand of COND must have even length");
1150 for (i
= 0; i
< XVECLEN (exp
, 0); i
+= 2)
1152 XVECEXP (exp
, 0, i
) = check_attr_test (XVECEXP (exp
, 0, i
),
1153 attr
? attr
->is_const
: 0);
1154 XVECEXP (exp
, 0, i
+ 1)
1155 = check_attr_value (XVECEXP (exp
, 0, i
+ 1), attr
);
1158 XEXP (exp
, 1) = check_attr_value (XEXP (exp
, 1), attr
);
1163 struct attr_desc
*attr2
= find_attr (XSTR (exp
, 0), 0);
1165 fatal ("Unknown attribute `%s' in ATTR", XSTR (exp
, 0));
1166 else if ((attr
&& attr
->is_const
) && ! attr2
->is_const
)
1167 fatal ("Non-constant attribute `%s' referenced from `%s'",
1168 XSTR (exp
, 0), attr
->name
);
1170 && (attr
->is_numeric
!= attr2
->is_numeric
1171 || (! attr
->negative_ok
&& attr2
->negative_ok
)))
1172 fatal ("Numeric attribute mismatch calling `%s' from `%s'",
1173 XSTR (exp
, 0), attr
->name
);
1178 /* A constant SYMBOL_REF is valid as a constant attribute test and
1179 is expanded later by make_canonical into a COND. In a non-constant
1180 attribute test, it is left be. */
1181 return attr_rtx (SYMBOL_REF
, XSTR (exp
, 0));
1184 fatal ("Invalid operation `%s' for attribute value",
1185 GET_RTX_NAME (GET_CODE (exp
)));
1191 /* Given an SET_ATTR_ALTERNATIVE expression, convert to the canonical SET.
1192 It becomes a COND with each test being (eq_attr "alternative "n") */
1195 convert_set_attr_alternative (exp
, num_alt
, insn_index
)
1203 if (XVECLEN (exp
, 1) != num_alt
)
1204 fatal ("Bad number of entries in SET_ATTR_ALTERNATIVE for insn %d",
1207 /* Make a COND with all tests but the last. Select the last value via the
1209 condexp
= rtx_alloc (COND
);
1210 XVEC (condexp
, 0) = rtvec_alloc ((num_alt
- 1) * 2);
1212 for (i
= 0; i
< num_alt
- 1; i
++)
1215 p
= attr_numeral (i
);
1217 XVECEXP (condexp
, 0, 2 * i
) = attr_eq (alternative_name
, p
);
1219 /* Sharing this EQ_ATTR rtl causes trouble. */
1220 XVECEXP (condexp
, 0, 2 * i
) = rtx_alloc (EQ_ATTR
);
1221 XSTR (XVECEXP (condexp
, 0, 2 * i
), 0) = alternative_name
;
1222 XSTR (XVECEXP (condexp
, 0, 2 * i
), 1) = p
;
1224 XVECEXP (condexp
, 0, 2 * i
+ 1) = XVECEXP (exp
, 1, i
);
1227 XEXP (condexp
, 1) = XVECEXP (exp
, 1, i
);
1229 return attr_rtx (SET
, attr_rtx (ATTR
, XSTR (exp
, 0)), condexp
);
1232 /* Given a SET_ATTR, convert to the appropriate SET. If a comma-separated
1233 list of values is given, convert to SET_ATTR_ALTERNATIVE first. */
1236 convert_set_attr (exp
, num_alt
, insn_index
)
1246 /* See how many alternative specified. */
1247 n
= n_comma_elts (XSTR (exp
, 1));
1249 return attr_rtx (SET
,
1250 attr_rtx (ATTR
, XSTR (exp
, 0)),
1251 attr_rtx (CONST_STRING
, XSTR (exp
, 1)));
1253 newexp
= rtx_alloc (SET_ATTR_ALTERNATIVE
);
1254 XSTR (newexp
, 0) = XSTR (exp
, 0);
1255 XVEC (newexp
, 1) = rtvec_alloc (n
);
1257 /* Process each comma-separated name. */
1258 name_ptr
= XSTR (exp
, 1);
1260 while ((p
= next_comma_elt (&name_ptr
)) != NULL
)
1261 XVECEXP (newexp
, 1, n
++) = attr_rtx (CONST_STRING
, p
);
1263 return convert_set_attr_alternative (newexp
, num_alt
, insn_index
);
1266 /* Scan all definitions, checking for validity. Also, convert any SET_ATTR
1267 and SET_ATTR_ALTERNATIVE expressions to the corresponding SET
1273 struct insn_def
*id
;
1274 struct attr_desc
*attr
;
1278 for (id
= defs
; id
; id
= id
->next
)
1280 if (XVEC (id
->def
, id
->vec_idx
) == NULL
)
1283 for (i
= 0; i
< XVECLEN (id
->def
, id
->vec_idx
); i
++)
1285 value
= XVECEXP (id
->def
, id
->vec_idx
, i
);
1286 switch (GET_CODE (value
))
1289 if (GET_CODE (XEXP (value
, 0)) != ATTR
)
1290 fatal ("Bad attribute set in pattern %d", id
->insn_index
);
1293 case SET_ATTR_ALTERNATIVE
:
1294 value
= convert_set_attr_alternative (value
,
1295 id
->num_alternatives
,
1300 value
= convert_set_attr (value
, id
->num_alternatives
,
1305 fatal ("Invalid attribute code `%s' for pattern %d",
1306 GET_RTX_NAME (GET_CODE (value
)), id
->insn_index
);
1309 if ((attr
= find_attr (XSTR (XEXP (value
, 0), 0), 0)) == NULL
)
1310 fatal ("Unknown attribute `%s' for pattern number %d",
1311 XSTR (XEXP (value
, 0), 0), id
->insn_index
);
1313 XVECEXP (id
->def
, id
->vec_idx
, i
) = value
;
1314 XEXP (value
, 1) = check_attr_value (XEXP (value
, 1), attr
);
1320 /* Given a constant SYMBOL_REF expression, convert to a COND that
1321 explicitly tests each enumerated value. */
1324 convert_const_symbol_ref (exp
, attr
)
1326 struct attr_desc
*attr
;
1329 struct attr_value
*av
;
1333 for (av
= attr
->first_value
; av
; av
= av
->next
)
1336 /* Make a COND with all tests but the last, and in the original order.
1337 Select the last value via the default. Note that the attr values
1338 are constructed in reverse order. */
1340 condexp
= rtx_alloc (COND
);
1341 XVEC (condexp
, 0) = rtvec_alloc ((num_alt
- 1) * 2);
1342 av
= attr
->first_value
;
1343 XEXP (condexp
, 1) = av
->value
;
1345 for (i
= num_alt
- 2; av
= av
->next
, i
>= 0; i
--)
1350 string
= p
= (char *) oballoc (2
1351 + strlen (attr
->name
)
1352 + strlen (XSTR (av
->value
, 0)));
1353 strcpy (p
, attr
->name
);
1355 strcat (p
, XSTR (av
->value
, 0));
1356 for (; *p
!= '\0'; p
++)
1360 value
= attr_rtx (SYMBOL_REF
, string
);
1361 RTX_UNCHANGING_P (value
) = 1;
1363 XVECEXP (condexp
, 0, 2 * i
) = attr_rtx (EQ
, exp
, value
);
1365 XVECEXP (condexp
, 0, 2 * i
+ 1) = av
->value
;
1372 /* Given a valid expression for an attribute value, remove any IF_THEN_ELSE
1373 expressions by converting them into a COND. This removes cases from this
1374 program. Also, replace an attribute value of "*" with the default attribute
1378 make_canonical (attr
, exp
)
1379 struct attr_desc
*attr
;
1385 switch (GET_CODE (exp
))
1388 exp
= make_numeric_value (INTVAL (exp
));
1392 if (! strcmp (XSTR (exp
, 0), "*"))
1394 if (attr
== 0 || attr
->default_val
== 0)
1395 fatal ("(attr_value \"*\") used in invalid context.");
1396 exp
= attr
->default_val
->value
;
1402 if (!attr
->is_const
|| RTX_UNCHANGING_P (exp
))
1404 /* The SYMBOL_REF is constant for a given run, so mark it as unchanging.
1405 This makes the COND something that won't be considered an arbitrary
1406 expression by walk_attr_value. */
1407 RTX_UNCHANGING_P (exp
) = 1;
1409 /* ??? Why do we do this? With attribute values { A B C D E }, this
1410 tends to generate (!(x==A) && !(x==B) && !(x==C) && !(x==D)) rather
1412 exp
= convert_const_symbol_ref (exp
, attr
);
1413 RTX_UNCHANGING_P (exp
) = 1;
1414 exp
= check_attr_value (exp
, attr
);
1415 /* Goto COND case since this is now a COND. Note that while the
1416 new expression is rescanned, all symbol_ref notes are marked as
1420 exp
= check_attr_value (exp
, attr
);
1425 newexp
= rtx_alloc (COND
);
1426 XVEC (newexp
, 0) = rtvec_alloc (2);
1427 XVECEXP (newexp
, 0, 0) = XEXP (exp
, 0);
1428 XVECEXP (newexp
, 0, 1) = XEXP (exp
, 1);
1430 XEXP (newexp
, 1) = XEXP (exp
, 2);
1433 /* Fall through to COND case since this is now a COND. */
1440 /* First, check for degenerate COND. */
1441 if (XVECLEN (exp
, 0) == 0)
1442 return make_canonical (attr
, XEXP (exp
, 1));
1443 defval
= XEXP (exp
, 1) = make_canonical (attr
, XEXP (exp
, 1));
1445 for (i
= 0; i
< XVECLEN (exp
, 0); i
+= 2)
1447 XVECEXP (exp
, 0, i
) = copy_boolean (XVECEXP (exp
, 0, i
));
1448 XVECEXP (exp
, 0, i
+ 1)
1449 = make_canonical (attr
, XVECEXP (exp
, 0, i
+ 1));
1450 if (! rtx_equal_p (XVECEXP (exp
, 0, i
+ 1), defval
))
1469 if (GET_CODE (exp
) == AND
|| GET_CODE (exp
) == IOR
)
1470 return attr_rtx (GET_CODE (exp
), copy_boolean (XEXP (exp
, 0)),
1471 copy_boolean (XEXP (exp
, 1)));
1475 /* Given a value and an attribute description, return a `struct attr_value *'
1476 that represents that value. This is either an existing structure, if the
1477 value has been previously encountered, or a newly-created structure.
1479 `insn_code' is the code of an insn whose attribute has the specified
1480 value (-2 if not processing an insn). We ensure that all insns for
1481 a given value have the same number of alternatives if the value checks
1484 static struct attr_value
*
1485 get_attr_value (value
, attr
, insn_code
)
1487 struct attr_desc
*attr
;
1490 struct attr_value
*av
;
1493 value
= make_canonical (attr
, value
);
1494 if (compares_alternatives_p (value
))
1496 if (insn_code
< 0 || insn_alternatives
== NULL
)
1497 fatal ("(eq_attr \"alternatives\" ...) used in non-insn context");
1499 num_alt
= insn_alternatives
[insn_code
];
1502 for (av
= attr
->first_value
; av
; av
= av
->next
)
1503 if (rtx_equal_p (value
, av
->value
)
1504 && (num_alt
== 0 || av
->first_insn
== NULL
1505 || insn_alternatives
[av
->first_insn
->insn_code
]))
1508 av
= (struct attr_value
*) oballoc (sizeof (struct attr_value
));
1510 av
->next
= attr
->first_value
;
1511 attr
->first_value
= av
;
1512 av
->first_insn
= NULL
;
1514 av
->has_asm_insn
= 0;
1519 /* After all DEFINE_DELAYs have been read in, create internal attributes
1520 to generate the required routines.
1522 First, we compute the number of delay slots for each insn (as a COND of
1523 each of the test expressions in DEFINE_DELAYs). Then, if more than one
1524 delay type is specified, we compute a similar function giving the
1525 DEFINE_DELAY ordinal for each insn.
1527 Finally, for each [DEFINE_DELAY, slot #] pair, we compute an attribute that
1528 tells whether a given insn can be in that delay slot.
1530 Normal attribute filling and optimization expands these to contain the
1531 information needed to handle delay slots. */
1536 struct delay_desc
*delay
;
1542 /* First, generate data for `num_delay_slots' function. */
1544 condexp
= rtx_alloc (COND
);
1545 XVEC (condexp
, 0) = rtvec_alloc (num_delays
* 2);
1546 XEXP (condexp
, 1) = make_numeric_value (0);
1548 for (i
= 0, delay
= delays
; delay
; i
+= 2, delay
= delay
->next
)
1550 XVECEXP (condexp
, 0, i
) = XEXP (delay
->def
, 0);
1551 XVECEXP (condexp
, 0, i
+ 1)
1552 = make_numeric_value (XVECLEN (delay
->def
, 1) / 3);
1555 make_internal_attr ("*num_delay_slots", condexp
, 0);
1557 /* If more than one delay type, do the same for computing the delay type. */
1560 condexp
= rtx_alloc (COND
);
1561 XVEC (condexp
, 0) = rtvec_alloc (num_delays
* 2);
1562 XEXP (condexp
, 1) = make_numeric_value (0);
1564 for (i
= 0, delay
= delays
; delay
; i
+= 2, delay
= delay
->next
)
1566 XVECEXP (condexp
, 0, i
) = XEXP (delay
->def
, 0);
1567 XVECEXP (condexp
, 0, i
+ 1) = make_numeric_value (delay
->num
);
1570 make_internal_attr ("*delay_type", condexp
, 1);
1573 /* For each delay possibility and delay slot, compute an eligibility
1574 attribute for non-annulled insns and for each type of annulled (annul
1575 if true and annul if false). */
1576 for (delay
= delays
; delay
; delay
= delay
->next
)
1578 for (i
= 0; i
< XVECLEN (delay
->def
, 1); i
+= 3)
1580 condexp
= XVECEXP (delay
->def
, 1, i
);
1581 if (condexp
== 0) condexp
= false_rtx
;
1582 newexp
= attr_rtx (IF_THEN_ELSE
, condexp
,
1583 make_numeric_value (1), make_numeric_value (0));
1585 p
= attr_printf (sizeof ("*delay__") + MAX_DIGITS
*2, "*delay_%d_%d",
1587 make_internal_attr (p
, newexp
, 1);
1589 if (have_annul_true
)
1591 condexp
= XVECEXP (delay
->def
, 1, i
+ 1);
1592 if (condexp
== 0) condexp
= false_rtx
;
1593 newexp
= attr_rtx (IF_THEN_ELSE
, condexp
,
1594 make_numeric_value (1),
1595 make_numeric_value (0));
1596 p
= attr_printf (sizeof ("*annul_true__") + MAX_DIGITS
*2,
1597 "*annul_true_%d_%d", delay
->num
, i
/ 3);
1598 make_internal_attr (p
, newexp
, 1);
1601 if (have_annul_false
)
1603 condexp
= XVECEXP (delay
->def
, 1, i
+ 2);
1604 if (condexp
== 0) condexp
= false_rtx
;
1605 newexp
= attr_rtx (IF_THEN_ELSE
, condexp
,
1606 make_numeric_value (1),
1607 make_numeric_value (0));
1608 p
= attr_printf (sizeof ("*annul_false__") + MAX_DIGITS
*2,
1609 "*annul_false_%d_%d", delay
->num
, i
/ 3);
1610 make_internal_attr (p
, newexp
, 1);
1616 /* This function is given a left and right side expression and an operator.
1617 Each side is a conditional expression, each alternative of which has a
1618 numerical value. The function returns another conditional expression
1619 which, for every possible set of condition values, returns a value that is
1620 the operator applied to the values of the two sides.
1622 Since this is called early, it must also support IF_THEN_ELSE. */
1625 operate_exp (op
, left
, right
)
1629 int left_value
, right_value
;
1633 /* If left is a string, apply operator to it and the right side. */
1634 if (GET_CODE (left
) == CONST_STRING
)
1636 /* If right is also a string, just perform the operation. */
1637 if (GET_CODE (right
) == CONST_STRING
)
1639 left_value
= atoi (XSTR (left
, 0));
1640 right_value
= atoi (XSTR (right
, 0));
1644 i
= left_value
+ right_value
;
1648 i
= left_value
- right_value
;
1651 case POS_MINUS_OP
: /* The positive part of LEFT - RIGHT. */
1652 if (left_value
> right_value
)
1653 i
= left_value
- right_value
;
1660 i
= left_value
| right_value
;
1664 i
= left_value
== right_value
;
1668 i
= (left_value
<< (HOST_BITS_PER_INT
/ 2)) | right_value
;
1672 if (left_value
> right_value
)
1679 if (left_value
< right_value
)
1689 if (i
== left_value
)
1691 if (i
== right_value
)
1693 return make_numeric_value (i
);
1695 else if (GET_CODE (right
) == IF_THEN_ELSE
)
1697 /* Apply recursively to all values within. */
1698 rtx newleft
= operate_exp (op
, left
, XEXP (right
, 1));
1699 rtx newright
= operate_exp (op
, left
, XEXP (right
, 2));
1700 if (rtx_equal_p (newleft
, newright
))
1702 return attr_rtx (IF_THEN_ELSE
, XEXP (right
, 0), newleft
, newright
);
1704 else if (GET_CODE (right
) == COND
)
1709 newexp
= rtx_alloc (COND
);
1710 XVEC (newexp
, 0) = rtvec_alloc (XVECLEN (right
, 0));
1711 defval
= XEXP (newexp
, 1) = operate_exp (op
, left
, XEXP (right
, 1));
1713 for (i
= 0; i
< XVECLEN (right
, 0); i
+= 2)
1715 XVECEXP (newexp
, 0, i
) = XVECEXP (right
, 0, i
);
1716 XVECEXP (newexp
, 0, i
+ 1)
1717 = operate_exp (op
, left
, XVECEXP (right
, 0, i
+ 1));
1718 if (! rtx_equal_p (XVECEXP (newexp
, 0, i
+ 1),
1723 /* If the resulting cond is trivial (all alternatives
1724 give the same value), optimize it away. */
1728 obstack_free (rtl_obstack
, newexp
);
1729 return operate_exp (op
, left
, XEXP (right
, 1));
1732 /* If the result is the same as the RIGHT operand,
1734 if (rtx_equal_p (newexp
, right
))
1737 obstack_free (rtl_obstack
, newexp
);
1744 fatal ("Badly formed attribute value");
1747 /* A hack to prevent expand_units from completely blowing up: ORX_OP does
1748 not associate through IF_THEN_ELSE. */
1749 else if (op
== ORX_OP
&& GET_CODE (right
) == IF_THEN_ELSE
)
1751 return attr_rtx (IOR
, left
, right
);
1754 /* Otherwise, do recursion the other way. */
1755 else if (GET_CODE (left
) == IF_THEN_ELSE
)
1757 rtx newleft
= operate_exp (op
, XEXP (left
, 1), right
);
1758 rtx newright
= operate_exp (op
, XEXP (left
, 2), right
);
1759 if (rtx_equal_p (newleft
, newright
))
1761 return attr_rtx (IF_THEN_ELSE
, XEXP (left
, 0), newleft
, newright
);
1763 else if (GET_CODE (left
) == COND
)
1768 newexp
= rtx_alloc (COND
);
1769 XVEC (newexp
, 0) = rtvec_alloc (XVECLEN (left
, 0));
1770 defval
= XEXP (newexp
, 1) = operate_exp (op
, XEXP (left
, 1), right
);
1772 for (i
= 0; i
< XVECLEN (left
, 0); i
+= 2)
1774 XVECEXP (newexp
, 0, i
) = XVECEXP (left
, 0, i
);
1775 XVECEXP (newexp
, 0, i
+ 1)
1776 = operate_exp (op
, XVECEXP (left
, 0, i
+ 1), right
);
1777 if (! rtx_equal_p (XVECEXP (newexp
, 0, i
+ 1),
1782 /* If the cond is trivial (all alternatives give the same value),
1783 optimize it away. */
1787 obstack_free (rtl_obstack
, newexp
);
1788 return operate_exp (op
, XEXP (left
, 1), right
);
1791 /* If the result is the same as the LEFT operand,
1793 if (rtx_equal_p (newexp
, left
))
1796 obstack_free (rtl_obstack
, newexp
);
1804 fatal ("Badly formed attribute value.");
1809 /* Once all attributes and DEFINE_FUNCTION_UNITs have been read, we
1810 construct a number of attributes.
1812 The first produces a function `function_units_used' which is given an
1813 insn and produces an encoding showing which function units are required
1814 for the execution of that insn. If the value is non-negative, the insn
1815 uses that unit; otherwise, the value is a one's compliment mask of units
1818 The second produces a function `result_ready_cost' which is used to
1819 determine the time that the result of an insn will be ready and hence
1820 a worst-case schedule.
1822 Both of these produce quite complex expressions which are then set as the
1823 default value of internal attributes. Normal attribute simplification
1824 should produce reasonable expressions.
1826 For each unit, a `<name>_unit_ready_cost' function will take an
1827 insn and give the delay until that unit will be ready with the result
1828 and a `<name>_unit_conflict_cost' function is given an insn already
1829 executing on the unit and a candidate to execute and will give the
1830 cost from the time the executing insn started until the candidate
1831 can start (ignore limitations on the number of simultaneous insns).
1833 For each unit, a `<name>_unit_blockage' function is given an insn
1834 already executing on the unit and a candidate to execute and will
1835 give the delay incurred due to function unit conflicts. The range of
1836 blockage cost values for a given executing insn is given by the
1837 `<name>_unit_blockage_range' function. These values are encoded in
1838 an int where the upper half gives the minimum value and the lower
1839 half gives the maximum value. */
1844 struct function_unit
*unit
, **unit_num
;
1845 struct function_unit_op
*op
, **op_array
, ***unit_ops
;
1850 int i
, j
, u
, num
, nvalues
;
1852 /* Rebuild the condition for the unit to share the RTL expressions.
1853 Sharing is required by simplify_by_exploding. Build the issue delay
1854 expressions. Validate the expressions we were given for the conditions
1855 and conflict vector. Then make attributes for use in the conflict
1858 for (unit
= units
; unit
; unit
= unit
->next
)
1860 unit
->condexp
= check_attr_test (unit
->condexp
, 0);
1862 for (op
= unit
->ops
; op
; op
= op
->next
)
1864 rtx issue_delay
= make_numeric_value (op
->issue_delay
);
1865 rtx issue_exp
= issue_delay
;
1867 /* Build, validate, and simplify the issue delay expression. */
1868 if (op
->conflict_exp
!= true_rtx
)
1869 issue_exp
= attr_rtx (IF_THEN_ELSE
, op
->conflict_exp
,
1870 issue_exp
, make_numeric_value (0));
1871 issue_exp
= check_attr_value (make_canonical (NULL_ATTR
,
1874 issue_exp
= simplify_knowing (issue_exp
, unit
->condexp
);
1875 op
->issue_exp
= issue_exp
;
1877 /* Make an attribute for use in the conflict function if needed. */
1878 unit
->needs_conflict_function
= (unit
->issue_delay
.min
1879 != unit
->issue_delay
.max
);
1880 if (unit
->needs_conflict_function
)
1882 str
= attr_printf (strlen (unit
->name
) + sizeof ("*_cost_") + MAX_DIGITS
,
1883 "*%s_cost_%d", unit
->name
, op
->num
);
1884 make_internal_attr (str
, issue_exp
, 1);
1887 /* Validate the condition. */
1888 op
->condexp
= check_attr_test (op
->condexp
, 0);
1892 /* Compute the mask of function units used. Initially, the unitsmask is
1893 zero. Set up a conditional to compute each unit's contribution. */
1894 unitsmask
= make_numeric_value (0);
1895 newexp
= rtx_alloc (IF_THEN_ELSE
);
1896 XEXP (newexp
, 2) = make_numeric_value (0);
1898 /* If we have just a few units, we may be all right expanding the whole
1899 thing. But the expansion is 2**N in space on the number of opclasses,
1900 so we can't do this for very long -- Alpha and MIPS in particular have
1901 problems with this. So in that situation, we fall back on an alternate
1902 implementation method. */
1903 #define NUM_UNITOP_CUTOFF 20
1905 if (num_unit_opclasses
< NUM_UNITOP_CUTOFF
)
1907 /* Merge each function unit into the unit mask attributes. */
1908 for (unit
= units
; unit
; unit
= unit
->next
)
1910 XEXP (newexp
, 0) = unit
->condexp
;
1911 XEXP (newexp
, 1) = make_numeric_value (1 << unit
->num
);
1912 unitsmask
= operate_exp (OR_OP
, unitsmask
, newexp
);
1917 /* Merge each function unit into the unit mask attributes. */
1918 for (unit
= units
; unit
; unit
= unit
->next
)
1920 XEXP (newexp
, 0) = unit
->condexp
;
1921 XEXP (newexp
, 1) = make_numeric_value (1 << unit
->num
);
1922 unitsmask
= operate_exp (ORX_OP
, unitsmask
, attr_copy_rtx (newexp
));
1926 /* Simplify the unit mask expression, encode it, and make an attribute
1927 for the function_units_used function. */
1928 unitsmask
= simplify_by_exploding (unitsmask
);
1930 if (num_unit_opclasses
< NUM_UNITOP_CUTOFF
)
1931 unitsmask
= encode_units_mask (unitsmask
);
1934 /* We can no longer encode unitsmask at compile time, so emit code to
1935 calculate it at runtime. Rather, put a marker for where we'd do
1936 the code, and actually output it in write_attr_get(). */
1937 unitsmask
= attr_rtx (FFS
, unitsmask
);
1940 make_internal_attr ("*function_units_used", unitsmask
, 10);
1942 /* Create an array of ops for each unit. Add an extra unit for the
1943 result_ready_cost function that has the ops of all other units. */
1944 unit_ops
= (struct function_unit_op
***)
1945 alloca ((num_units
+ 1) * sizeof (struct function_unit_op
**));
1946 unit_num
= (struct function_unit
**)
1947 alloca ((num_units
+ 1) * sizeof (struct function_unit
*));
1949 unit_num
[num_units
] = unit
= (struct function_unit
*)
1950 alloca (sizeof (struct function_unit
));
1951 unit
->num
= num_units
;
1952 unit
->num_opclasses
= 0;
1954 for (unit
= units
; unit
; unit
= unit
->next
)
1956 unit_num
[num_units
]->num_opclasses
+= unit
->num_opclasses
;
1957 unit_num
[unit
->num
] = unit
;
1958 unit_ops
[unit
->num
] = op_array
= (struct function_unit_op
**)
1959 alloca (unit
->num_opclasses
* sizeof (struct function_unit_op
*));
1961 for (op
= unit
->ops
; op
; op
= op
->next
)
1962 op_array
[op
->num
] = op
;
1965 /* Compose the array of ops for the extra unit. */
1966 unit_ops
[num_units
] = op_array
= (struct function_unit_op
**)
1967 alloca (unit_num
[num_units
]->num_opclasses
1968 * sizeof (struct function_unit_op
*));
1970 for (unit
= units
, i
= 0; unit
; i
+= unit
->num_opclasses
, unit
= unit
->next
)
1971 bcopy ((char *) unit_ops
[unit
->num
], (char *) &op_array
[i
],
1972 unit
->num_opclasses
* sizeof (struct function_unit_op
*));
1974 /* Compute the ready cost function for each unit by computing the
1975 condition for each non-default value. */
1976 for (u
= 0; u
<= num_units
; u
++)
1982 op_array
= unit_ops
[unit
->num
];
1983 num
= unit
->num_opclasses
;
1985 /* Sort the array of ops into increasing ready cost order. */
1986 for (i
= 0; i
< num
; i
++)
1987 for (j
= num
- 1; j
> i
; j
--)
1988 if (op_array
[j
-1]->ready
< op_array
[j
]->ready
)
1991 op_array
[j
] = op_array
[j
-1];
1995 /* Determine how many distinct non-default ready cost values there
1996 are. We use a default ready cost value of 1. */
1997 nvalues
= 0; value
= 1;
1998 for (i
= num
- 1; i
>= 0; i
--)
1999 if (op_array
[i
]->ready
> value
)
2001 value
= op_array
[i
]->ready
;
2006 readycost
= make_numeric_value (1);
2009 /* Construct the ready cost expression as a COND of each value from
2010 the largest to the smallest. */
2011 readycost
= rtx_alloc (COND
);
2012 XVEC (readycost
, 0) = rtvec_alloc (nvalues
* 2);
2013 XEXP (readycost
, 1) = make_numeric_value (1);
2015 nvalues
= 0; orexp
= false_rtx
; value
= op_array
[0]->ready
;
2016 for (i
= 0; i
< num
; i
++)
2021 else if (op
->ready
== value
)
2022 orexp
= insert_right_side (IOR
, orexp
, op
->condexp
, -2, -2);
2025 XVECEXP (readycost
, 0, nvalues
* 2) = orexp
;
2026 XVECEXP (readycost
, 0, nvalues
* 2 + 1)
2027 = make_numeric_value (value
);
2030 orexp
= op
->condexp
;
2033 XVECEXP (readycost
, 0, nvalues
* 2) = orexp
;
2034 XVECEXP (readycost
, 0, nvalues
* 2 + 1) = make_numeric_value (value
);
2039 rtx max_blockage
= 0, min_blockage
= 0;
2041 /* Simplify the readycost expression by only considering insns
2042 that use the unit. */
2043 readycost
= simplify_knowing (readycost
, unit
->condexp
);
2045 /* Determine the blockage cost the executing insn (E) given
2046 the candidate insn (C). This is the maximum of the issue
2047 delay, the pipeline delay, and the simultaneity constraint.
2048 Each function_unit_op represents the characteristics of the
2049 candidate insn, so in the expressions below, C is a known
2050 term and E is an unknown term.
2052 We compute the blockage cost for each E for every possible C.
2053 Thus OP represents E, and READYCOST is a list of values for
2056 The issue delay function for C is op->issue_exp and is used to
2057 write the `<name>_unit_conflict_cost' function. Symbolicly
2058 this is "ISSUE-DELAY (E,C)".
2060 The pipeline delay results form the FIFO constraint on the
2061 function unit and is "READY-COST (E) + 1 - READY-COST (C)".
2063 The simultaneity constraint is based on how long it takes to
2064 fill the unit given the minimum issue delay. FILL-TIME is the
2065 constant "MIN (ISSUE-DELAY (*,*)) * (SIMULTANEITY - 1)", and
2066 the simultaneity constraint is "READY-COST (E) - FILL-TIME"
2067 if SIMULTANEITY is non-zero and zero otherwise.
2069 Thus, BLOCKAGE (E,C) when SIMULTANEITY is zero is
2071 MAX (ISSUE-DELAY (E,C),
2072 READY-COST (E) - (READY-COST (C) - 1))
2076 MAX (ISSUE-DELAY (E,C),
2077 READY-COST (E) - (READY-COST (C) - 1),
2078 READY-COST (E) - FILL-TIME)
2080 The `<name>_unit_blockage' function is computed by determining
2081 this value for each candidate insn. As these values are
2082 computed, we also compute the upper and lower bounds for
2083 BLOCKAGE (E,*). These are combined to form the function
2084 `<name>_unit_blockage_range'. Finally, the maximum blockage
2085 cost, MAX (BLOCKAGE (*,*)), is computed. */
2087 for (op
= unit
->ops
; op
; op
= op
->next
)
2089 rtx blockage
= op
->issue_exp
;
2090 blockage
= simplify_knowing (blockage
, unit
->condexp
);
2092 /* Add this op's contribution to MAX (BLOCKAGE (E,*)) and
2093 MIN (BLOCKAGE (E,*)). */
2094 if (max_blockage
== 0)
2095 max_blockage
= min_blockage
= blockage
;
2099 = simplify_knowing (operate_exp (MAX_OP
, max_blockage
,
2103 = simplify_knowing (operate_exp (MIN_OP
, min_blockage
,
2108 /* Make an attribute for use in the blockage function. */
2109 str
= attr_printf (strlen (unit
->name
) + sizeof ("*_block_") + MAX_DIGITS
,
2110 "*%s_block_%d", unit
->name
, op
->num
);
2111 make_internal_attr (str
, blockage
, 1);
2114 /* Record MAX (BLOCKAGE (*,*)). */
2117 unit
->max_blockage
= max_attr_value (max_blockage
, &unknown
);
2120 /* See if the upper and lower bounds of BLOCKAGE (E,*) are the
2121 same. If so, the blockage function carries no additional
2122 information and is not written. */
2123 newexp
= operate_exp (EQ_OP
, max_blockage
, min_blockage
);
2124 newexp
= simplify_knowing (newexp
, unit
->condexp
);
2125 unit
->needs_blockage_function
2126 = (GET_CODE (newexp
) != CONST_STRING
2127 || atoi (XSTR (newexp
, 0)) != 1);
2129 /* If the all values of BLOCKAGE (E,C) have the same value,
2130 neither blockage function is written. */
2131 unit
->needs_range_function
2132 = (unit
->needs_blockage_function
2133 || GET_CODE (max_blockage
) != CONST_STRING
);
2135 if (unit
->needs_range_function
)
2137 /* Compute the blockage range function and make an attribute
2138 for writing its value. */
2139 newexp
= operate_exp (RANGE_OP
, min_blockage
, max_blockage
);
2140 newexp
= simplify_knowing (newexp
, unit
->condexp
);
2142 str
= attr_printf (strlen (unit
->name
) + sizeof ("*_unit_blockage_range"),
2143 "*%s_unit_blockage_range", unit
->name
);
2144 make_internal_attr (str
, newexp
, 20);
2147 str
= attr_printf (strlen (unit
->name
) + sizeof ("*_unit_ready_cost"),
2148 "*%s_unit_ready_cost", unit
->name
);
2151 str
= "*result_ready_cost";
2153 /* Make an attribute for the ready_cost function. Simplifying
2154 further with simplify_by_exploding doesn't win. */
2155 make_internal_attr (str
, readycost
, 0);
2158 /* For each unit that requires a conflict cost function, make an attribute
2159 that maps insns to the operation number. */
2160 for (unit
= units
; unit
; unit
= unit
->next
)
2164 if (! unit
->needs_conflict_function
2165 && ! unit
->needs_blockage_function
)
2168 caseexp
= rtx_alloc (COND
);
2169 XVEC (caseexp
, 0) = rtvec_alloc ((unit
->num_opclasses
- 1) * 2);
2171 for (op
= unit
->ops
; op
; op
= op
->next
)
2173 /* Make our adjustment to the COND being computed. If we are the
2174 last operation class, place our values into the default of the
2176 if (op
->num
== unit
->num_opclasses
- 1)
2178 XEXP (caseexp
, 1) = make_numeric_value (op
->num
);
2182 XVECEXP (caseexp
, 0, op
->num
* 2) = op
->condexp
;
2183 XVECEXP (caseexp
, 0, op
->num
* 2 + 1)
2184 = make_numeric_value (op
->num
);
2188 /* Simplifying caseexp with simplify_by_exploding doesn't win. */
2189 str
= attr_printf (strlen (unit
->name
) + sizeof ("*_cases"),
2190 "*%s_cases", unit
->name
);
2191 make_internal_attr (str
, caseexp
, 1);
2195 /* Simplify EXP given KNOWN_TRUE. */
2198 simplify_knowing (exp
, known_true
)
2199 rtx exp
, known_true
;
2201 if (GET_CODE (exp
) != CONST_STRING
)
2203 int unknown
= 0, max
;
2204 max
= max_attr_value (exp
, &unknown
);
2207 exp
= attr_rtx (IF_THEN_ELSE
, known_true
, exp
,
2208 make_numeric_value (max
));
2209 exp
= simplify_by_exploding (exp
);
2215 /* Translate the CONST_STRING expressions in X to change the encoding of
2216 value. On input, the value is a bitmask with a one bit for each unit
2217 used; on output, the value is the unit number (zero based) if one
2218 and only one unit is used or the one's compliment of the bitmask. */
2221 encode_units_mask (x
)
2226 register enum rtx_code code
;
2227 register const char *fmt
;
2229 code
= GET_CODE (x
);
2234 i
= atoi (XSTR (x
, 0));
2236 abort (); /* The sign bit encodes a one's compliment mask. */
2237 else if (i
!= 0 && i
== (i
& -i
))
2238 /* Only one bit is set, so yield that unit number. */
2239 for (j
= 0; (i
>>= 1) != 0; j
++)
2243 return attr_rtx (CONST_STRING
, attr_printf (MAX_DIGITS
, "%d", j
));
2260 /* Compare the elements. If any pair of corresponding elements
2261 fail to match, return 0 for the whole things. */
2263 fmt
= GET_RTX_FORMAT (code
);
2264 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
2270 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
2271 XVECEXP (x
, i
, j
) = encode_units_mask (XVECEXP (x
, i
, j
));
2275 XEXP (x
, i
) = encode_units_mask (XEXP (x
, i
));
2282 /* Once all attributes and insns have been read and checked, we construct for
2283 each attribute value a list of all the insns that have that value for
2288 struct attr_desc
*attr
;
2290 struct attr_value
*av
;
2291 struct insn_ent
*ie
;
2292 struct insn_def
*id
;
2296 /* Don't fill constant attributes. The value is independent of
2297 any particular insn. */
2301 for (id
= defs
; id
; id
= id
->next
)
2303 /* If no value is specified for this insn for this attribute, use the
2306 if (XVEC (id
->def
, id
->vec_idx
))
2307 for (i
= 0; i
< XVECLEN (id
->def
, id
->vec_idx
); i
++)
2308 if (! strcmp (XSTR (XEXP (XVECEXP (id
->def
, id
->vec_idx
, i
), 0), 0),
2310 value
= XEXP (XVECEXP (id
->def
, id
->vec_idx
, i
), 1);
2313 av
= attr
->default_val
;
2315 av
= get_attr_value (value
, attr
, id
->insn_code
);
2317 ie
= (struct insn_ent
*) oballoc (sizeof (struct insn_ent
));
2318 ie
->insn_code
= id
->insn_code
;
2319 ie
->insn_index
= id
->insn_code
;
2320 insert_insn_ent (av
, ie
);
2324 /* Given an expression EXP, see if it is a COND or IF_THEN_ELSE that has a
2325 test that checks relative positions of insns (uses MATCH_DUP or PC).
2326 If so, replace it with what is obtained by passing the expression to
2327 ADDRESS_FN. If not but it is a COND or IF_THEN_ELSE, call this routine
2328 recursively on each value (including the default value). Otherwise,
2329 return the value returned by NO_ADDRESS_FN applied to EXP. */
2332 substitute_address (exp
, no_address_fn
, address_fn
)
2334 rtx (*no_address_fn
) PROTO ((rtx
));
2335 rtx (*address_fn
) PROTO ((rtx
));
2340 if (GET_CODE (exp
) == COND
)
2342 /* See if any tests use addresses. */
2344 for (i
= 0; i
< XVECLEN (exp
, 0); i
+= 2)
2345 walk_attr_value (XVECEXP (exp
, 0, i
));
2348 return (*address_fn
) (exp
);
2350 /* Make a new copy of this COND, replacing each element. */
2351 newexp
= rtx_alloc (COND
);
2352 XVEC (newexp
, 0) = rtvec_alloc (XVECLEN (exp
, 0));
2353 for (i
= 0; i
< XVECLEN (exp
, 0); i
+= 2)
2355 XVECEXP (newexp
, 0, i
) = XVECEXP (exp
, 0, i
);
2356 XVECEXP (newexp
, 0, i
+ 1)
2357 = substitute_address (XVECEXP (exp
, 0, i
+ 1),
2358 no_address_fn
, address_fn
);
2361 XEXP (newexp
, 1) = substitute_address (XEXP (exp
, 1),
2362 no_address_fn
, address_fn
);
2367 else if (GET_CODE (exp
) == IF_THEN_ELSE
)
2370 walk_attr_value (XEXP (exp
, 0));
2372 return (*address_fn
) (exp
);
2374 return attr_rtx (IF_THEN_ELSE
,
2375 substitute_address (XEXP (exp
, 0),
2376 no_address_fn
, address_fn
),
2377 substitute_address (XEXP (exp
, 1),
2378 no_address_fn
, address_fn
),
2379 substitute_address (XEXP (exp
, 2),
2380 no_address_fn
, address_fn
));
2383 return (*no_address_fn
) (exp
);
2386 /* Make new attributes from the `length' attribute. The following are made,
2387 each corresponding to a function called from `shorten_branches' or
2390 *insn_default_length This is the length of the insn to be returned
2391 by `get_attr_length' before `shorten_branches'
2392 has been called. In each case where the length
2393 depends on relative addresses, the largest
2394 possible is used. This routine is also used
2395 to compute the initial size of the insn.
2397 *insn_variable_length_p This returns 1 if the insn's length depends
2398 on relative addresses, zero otherwise.
2400 *insn_current_length This is only called when it is known that the
2401 insn has a variable length and returns the
2402 current length, based on relative addresses.
2406 make_length_attrs ()
2408 static const char *new_names
[] = {"*insn_default_length",
2409 "*insn_variable_length_p",
2410 "*insn_current_length"};
2411 static rtx (*no_address_fn
[]) PROTO((rtx
)) = {identity_fn
, zero_fn
, zero_fn
};
2412 static rtx (*address_fn
[]) PROTO((rtx
)) = {max_fn
, one_fn
, identity_fn
};
2414 struct attr_desc
*length_attr
, *new_attr
;
2415 struct attr_value
*av
, *new_av
;
2416 struct insn_ent
*ie
, *new_ie
;
2418 /* See if length attribute is defined. If so, it must be numeric. Make
2419 it special so we don't output anything for it. */
2420 length_attr
= find_attr ("length", 0);
2421 if (length_attr
== 0)
2424 if (! length_attr
->is_numeric
)
2425 fatal ("length attribute must be numeric.");
2427 length_attr
->is_const
= 0;
2428 length_attr
->is_special
= 1;
2430 /* Make each new attribute, in turn. */
2431 for (i
= 0; i
< sizeof new_names
/ sizeof new_names
[0]; i
++)
2433 make_internal_attr (new_names
[i
],
2434 substitute_address (length_attr
->default_val
->value
,
2435 no_address_fn
[i
], address_fn
[i
]),
2437 new_attr
= find_attr (new_names
[i
], 0);
2438 for (av
= length_attr
->first_value
; av
; av
= av
->next
)
2439 for (ie
= av
->first_insn
; ie
; ie
= ie
->next
)
2441 new_av
= get_attr_value (substitute_address (av
->value
,
2444 new_attr
, ie
->insn_code
);
2445 new_ie
= (struct insn_ent
*) oballoc (sizeof (struct insn_ent
));
2446 new_ie
->insn_code
= ie
->insn_code
;
2447 new_ie
->insn_index
= ie
->insn_index
;
2448 insert_insn_ent (new_av
, new_ie
);
2453 /* Utility functions called from above routine. */
2464 rtx exp ATTRIBUTE_UNUSED
;
2466 return make_numeric_value (0);
2471 rtx exp ATTRIBUTE_UNUSED
;
2473 return make_numeric_value (1);
2481 return make_numeric_value (max_attr_value (exp
, &unknown
));
2485 write_length_unit_log ()
2487 struct attr_desc
*length_attr
= find_attr ("length", 0);
2488 struct attr_value
*av
;
2489 struct insn_ent
*ie
;
2490 unsigned int length_unit_log
, length_or
;
2493 if (length_attr
== 0)
2495 length_or
= or_attr_value (length_attr
->default_val
->value
, &unknown
);
2496 for (av
= length_attr
->first_value
; av
; av
= av
->next
)
2497 for (ie
= av
->first_insn
; ie
; ie
= ie
->next
)
2498 length_or
|= or_attr_value (av
->value
, &unknown
);
2501 length_unit_log
= 0;
2504 length_or
= ~length_or
;
2505 for (length_unit_log
= 0; length_or
& 1; length_or
>>= 1)
2508 printf ("int length_unit_log = %u;\n", length_unit_log
);
2511 /* Take a COND expression and see if any of the conditions in it can be
2512 simplified. If any are known true or known false for the particular insn
2513 code, the COND can be further simplified.
2515 Also call ourselves on any COND operations that are values of this COND.
2517 We do not modify EXP; rather, we make and return a new rtx. */
2520 simplify_cond (exp
, insn_code
, insn_index
)
2522 int insn_code
, insn_index
;
2525 /* We store the desired contents here,
2526 then build a new expression if they don't match EXP. */
2527 rtx defval
= XEXP (exp
, 1);
2528 rtx new_defval
= XEXP (exp
, 1);
2529 int len
= XVECLEN (exp
, 0);
2530 rtunion
*tests
= (rtunion
*) alloca (len
* sizeof (rtunion
));
2534 /* This lets us free all storage allocated below, if appropriate. */
2535 first_spacer
= (char *) obstack_finish (rtl_obstack
);
2537 bcopy ((char *) XVEC (exp
, 0)->elem
, (char *) tests
, len
* sizeof (rtunion
));
2539 /* See if default value needs simplification. */
2540 if (GET_CODE (defval
) == COND
)
2541 new_defval
= simplify_cond (defval
, insn_code
, insn_index
);
2543 /* Simplify the subexpressions, and see what tests we can get rid of. */
2545 for (i
= 0; i
< len
; i
+= 2)
2547 rtx newtest
, newval
;
2549 /* Simplify this test. */
2550 newtest
= SIMPLIFY_TEST_EXP (tests
[i
].rtx
, insn_code
, insn_index
);
2551 tests
[i
].rtx
= newtest
;
2553 newval
= tests
[i
+ 1].rtx
;
2554 /* See if this value may need simplification. */
2555 if (GET_CODE (newval
) == COND
)
2556 newval
= simplify_cond (newval
, insn_code
, insn_index
);
2558 /* Look for ways to delete or combine this test. */
2559 if (newtest
== true_rtx
)
2561 /* If test is true, make this value the default
2562 and discard this + any following tests. */
2564 defval
= tests
[i
+ 1].rtx
;
2565 new_defval
= newval
;
2568 else if (newtest
== false_rtx
)
2570 /* If test is false, discard it and its value. */
2571 for (j
= i
; j
< len
- 2; j
++)
2572 tests
[j
].rtx
= tests
[j
+ 2].rtx
;
2576 else if (i
> 0 && attr_equal_p (newval
, tests
[i
- 1].rtx
))
2578 /* If this value and the value for the prev test are the same,
2582 = insert_right_side (IOR
, tests
[i
- 2].rtx
, newtest
,
2583 insn_code
, insn_index
);
2585 /* Delete this test/value. */
2586 for (j
= i
; j
< len
- 2; j
++)
2587 tests
[j
].rtx
= tests
[j
+ 2].rtx
;
2592 tests
[i
+ 1].rtx
= newval
;
2595 /* If the last test in a COND has the same value
2596 as the default value, that test isn't needed. */
2598 while (len
> 0 && attr_equal_p (tests
[len
- 1].rtx
, new_defval
))
2601 /* See if we changed anything. */
2602 if (len
!= XVECLEN (exp
, 0) || new_defval
!= XEXP (exp
, 1))
2605 for (i
= 0; i
< len
; i
++)
2606 if (! attr_equal_p (tests
[i
].rtx
, XVECEXP (exp
, 0, i
)))
2615 obstack_free (rtl_obstack
, first_spacer
);
2616 if (GET_CODE (defval
) == COND
)
2617 return simplify_cond (defval
, insn_code
, insn_index
);
2623 obstack_free (rtl_obstack
, first_spacer
);
2628 rtx newexp
= rtx_alloc (COND
);
2630 XVEC (newexp
, 0) = rtvec_alloc (len
);
2631 bcopy ((char *) tests
, (char *) XVEC (newexp
, 0)->elem
,
2632 len
* sizeof (rtunion
));
2633 XEXP (newexp
, 1) = new_defval
;
2638 /* Remove an insn entry from an attribute value. */
2641 remove_insn_ent (av
, ie
)
2642 struct attr_value
*av
;
2643 struct insn_ent
*ie
;
2645 struct insn_ent
*previe
;
2647 if (av
->first_insn
== ie
)
2648 av
->first_insn
= ie
->next
;
2651 for (previe
= av
->first_insn
; previe
->next
!= ie
; previe
= previe
->next
)
2653 previe
->next
= ie
->next
;
2657 if (ie
->insn_code
== -1)
2658 av
->has_asm_insn
= 0;
2663 /* Insert an insn entry in an attribute value list. */
2666 insert_insn_ent (av
, ie
)
2667 struct attr_value
*av
;
2668 struct insn_ent
*ie
;
2670 ie
->next
= av
->first_insn
;
2671 av
->first_insn
= ie
;
2673 if (ie
->insn_code
== -1)
2674 av
->has_asm_insn
= 1;
2679 /* This is a utility routine to take an expression that is a tree of either
2680 AND or IOR expressions and insert a new term. The new term will be
2681 inserted at the right side of the first node whose code does not match
2682 the root. A new node will be created with the root's code. Its left
2683 side will be the old right side and its right side will be the new
2686 If the `term' is itself a tree, all its leaves will be inserted. */
2689 insert_right_side (code
, exp
, term
, insn_code
, insn_index
)
2693 int insn_code
, insn_index
;
2697 /* Avoid consing in some special cases. */
2698 if (code
== AND
&& term
== true_rtx
)
2700 if (code
== AND
&& term
== false_rtx
)
2702 if (code
== AND
&& exp
== true_rtx
)
2704 if (code
== AND
&& exp
== false_rtx
)
2706 if (code
== IOR
&& term
== true_rtx
)
2708 if (code
== IOR
&& term
== false_rtx
)
2710 if (code
== IOR
&& exp
== true_rtx
)
2712 if (code
== IOR
&& exp
== false_rtx
)
2714 if (attr_equal_p (exp
, term
))
2717 if (GET_CODE (term
) == code
)
2719 exp
= insert_right_side (code
, exp
, XEXP (term
, 0),
2720 insn_code
, insn_index
);
2721 exp
= insert_right_side (code
, exp
, XEXP (term
, 1),
2722 insn_code
, insn_index
);
2727 if (GET_CODE (exp
) == code
)
2729 rtx
new = insert_right_side (code
, XEXP (exp
, 1),
2730 term
, insn_code
, insn_index
);
2731 if (new != XEXP (exp
, 1))
2732 /* Make a copy of this expression and call recursively. */
2733 newexp
= attr_rtx (code
, XEXP (exp
, 0), new);
2739 /* Insert the new term. */
2740 newexp
= attr_rtx (code
, exp
, term
);
2743 return SIMPLIFY_TEST_EXP (newexp
, insn_code
, insn_index
);
2746 /* If we have an expression which AND's a bunch of
2747 (not (eq_attrq "alternative" "n"))
2748 terms, we may have covered all or all but one of the possible alternatives.
2749 If so, we can optimize. Similarly for IOR's of EQ_ATTR.
2751 This routine is passed an expression and either AND or IOR. It returns a
2752 bitmask indicating which alternatives are mentioned within EXP. */
2755 compute_alternative_mask (exp
, code
)
2760 if (GET_CODE (exp
) == code
)
2761 return compute_alternative_mask (XEXP (exp
, 0), code
)
2762 | compute_alternative_mask (XEXP (exp
, 1), code
);
2764 else if (code
== AND
&& GET_CODE (exp
) == NOT
2765 && GET_CODE (XEXP (exp
, 0)) == EQ_ATTR
2766 && XSTR (XEXP (exp
, 0), 0) == alternative_name
)
2767 string
= XSTR (XEXP (exp
, 0), 1);
2769 else if (code
== IOR
&& GET_CODE (exp
) == EQ_ATTR
2770 && XSTR (exp
, 0) == alternative_name
)
2771 string
= XSTR (exp
, 1);
2777 return 1 << (string
[0] - '0');
2778 return 1 << atoi (string
);
2781 /* Given I, a single-bit mask, return RTX to compare the `alternative'
2782 attribute with the value represented by that bit. */
2785 make_alternative_compare (mask
)
2792 for (i
= 0; (mask
& (1 << i
)) == 0; i
++)
2795 newexp
= attr_rtx (EQ_ATTR
, alternative_name
, attr_numeral (i
));
2796 RTX_UNCHANGING_P (newexp
) = 1;
2801 /* If we are processing an (eq_attr "attr" "value") test, we find the value
2802 of "attr" for this insn code. From that value, we can compute a test
2803 showing when the EQ_ATTR will be true. This routine performs that
2804 computation. If a test condition involves an address, we leave the EQ_ATTR
2805 intact because addresses are only valid for the `length' attribute.
2807 EXP is the EQ_ATTR expression and VALUE is the value of that attribute
2808 for the insn corresponding to INSN_CODE and INSN_INDEX. */
2811 evaluate_eq_attr (exp
, value
, insn_code
, insn_index
)
2814 int insn_code
, insn_index
;
2821 if (GET_CODE (value
) == CONST_STRING
)
2823 if (! strcmp (XSTR (value
, 0), XSTR (exp
, 1)))
2828 else if (GET_CODE (value
) == SYMBOL_REF
)
2832 if (GET_CODE (exp
) != EQ_ATTR
)
2835 string
= (char *) alloca (2 + strlen (XSTR (exp
, 0))
2836 + strlen (XSTR (exp
, 1)));
2837 strcpy (string
, XSTR (exp
, 0));
2838 strcat (string
, "_");
2839 strcat (string
, XSTR (exp
, 1));
2840 for (p
= string
; *p
; p
++)
2844 newexp
= attr_rtx (EQ
, value
,
2845 attr_rtx (SYMBOL_REF
,
2846 attr_string(string
, strlen(string
))));
2848 else if (GET_CODE (value
) == COND
)
2850 /* We construct an IOR of all the cases for which the requested attribute
2851 value is present. Since we start with FALSE, if it is not present,
2852 FALSE will be returned.
2854 Each case is the AND of the NOT's of the previous conditions with the
2855 current condition; in the default case the current condition is TRUE.
2857 For each possible COND value, call ourselves recursively.
2859 The extra TRUE and FALSE expressions will be eliminated by another
2860 call to the simplification routine. */
2865 if (current_alternative_string
)
2866 clear_struct_flag (value
);
2868 for (i
= 0; i
< XVECLEN (value
, 0); i
+= 2)
2870 rtx
this = SIMPLIFY_TEST_EXP (XVECEXP (value
, 0, i
),
2871 insn_code
, insn_index
);
2873 SIMPLIFY_ALTERNATIVE (this);
2875 right
= insert_right_side (AND
, andexp
, this,
2876 insn_code
, insn_index
);
2877 right
= insert_right_side (AND
, right
,
2878 evaluate_eq_attr (exp
,
2881 insn_code
, insn_index
),
2882 insn_code
, insn_index
);
2883 orexp
= insert_right_side (IOR
, orexp
, right
,
2884 insn_code
, insn_index
);
2886 /* Add this condition into the AND expression. */
2887 newexp
= attr_rtx (NOT
, this);
2888 andexp
= insert_right_side (AND
, andexp
, newexp
,
2889 insn_code
, insn_index
);
2892 /* Handle the default case. */
2893 right
= insert_right_side (AND
, andexp
,
2894 evaluate_eq_attr (exp
, XEXP (value
, 1),
2895 insn_code
, insn_index
),
2896 insn_code
, insn_index
);
2897 newexp
= insert_right_side (IOR
, orexp
, right
, insn_code
, insn_index
);
2902 /* If uses an address, must return original expression. But set the
2903 RTX_UNCHANGING_P bit so we don't try to simplify it again. */
2906 walk_attr_value (newexp
);
2910 /* This had `&& current_alternative_string', which seems to be wrong. */
2911 if (! RTX_UNCHANGING_P (exp
))
2912 return copy_rtx_unchanging (exp
);
2919 /* This routine is called when an AND of a term with a tree of AND's is
2920 encountered. If the term or its complement is present in the tree, it
2921 can be replaced with TRUE or FALSE, respectively.
2923 Note that (eq_attr "att" "v1") and (eq_attr "att" "v2") cannot both
2924 be true and hence are complementary.
2926 There is one special case: If we see
2927 (and (not (eq_attr "att" "v1"))
2928 (eq_attr "att" "v2"))
2929 this can be replaced by (eq_attr "att" "v2"). To do this we need to
2930 replace the term, not anything in the AND tree. So we pass a pointer to
2934 simplify_and_tree (exp
, pterm
, insn_code
, insn_index
)
2937 int insn_code
, insn_index
;
2942 int left_eliminates_term
, right_eliminates_term
;
2944 if (GET_CODE (exp
) == AND
)
2946 left
= simplify_and_tree (XEXP (exp
, 0), pterm
, insn_code
, insn_index
);
2947 right
= simplify_and_tree (XEXP (exp
, 1), pterm
, insn_code
, insn_index
);
2948 if (left
!= XEXP (exp
, 0) || right
!= XEXP (exp
, 1))
2950 newexp
= attr_rtx (GET_CODE (exp
), left
, right
);
2952 exp
= SIMPLIFY_TEST_EXP (newexp
, insn_code
, insn_index
);
2956 else if (GET_CODE (exp
) == IOR
)
2958 /* For the IOR case, we do the same as above, except that we can
2959 only eliminate `term' if both sides of the IOR would do so. */
2961 left
= simplify_and_tree (XEXP (exp
, 0), &temp
, insn_code
, insn_index
);
2962 left_eliminates_term
= (temp
== true_rtx
);
2965 right
= simplify_and_tree (XEXP (exp
, 1), &temp
, insn_code
, insn_index
);
2966 right_eliminates_term
= (temp
== true_rtx
);
2968 if (left_eliminates_term
&& right_eliminates_term
)
2971 if (left
!= XEXP (exp
, 0) || right
!= XEXP (exp
, 1))
2973 newexp
= attr_rtx (GET_CODE (exp
), left
, right
);
2975 exp
= SIMPLIFY_TEST_EXP (newexp
, insn_code
, insn_index
);
2979 /* Check for simplifications. Do some extra checking here since this
2980 routine is called so many times. */
2985 else if (GET_CODE (exp
) == NOT
&& XEXP (exp
, 0) == *pterm
)
2988 else if (GET_CODE (*pterm
) == NOT
&& exp
== XEXP (*pterm
, 0))
2991 else if (GET_CODE (exp
) == EQ_ATTR
&& GET_CODE (*pterm
) == EQ_ATTR
)
2993 if (XSTR (exp
, 0) != XSTR (*pterm
, 0))
2996 if (! strcmp (XSTR (exp
, 1), XSTR (*pterm
, 1)))
3002 else if (GET_CODE (*pterm
) == EQ_ATTR
&& GET_CODE (exp
) == NOT
3003 && GET_CODE (XEXP (exp
, 0)) == EQ_ATTR
)
3005 if (XSTR (*pterm
, 0) != XSTR (XEXP (exp
, 0), 0))
3008 if (! strcmp (XSTR (*pterm
, 1), XSTR (XEXP (exp
, 0), 1)))
3014 else if (GET_CODE (exp
) == EQ_ATTR
&& GET_CODE (*pterm
) == NOT
3015 && GET_CODE (XEXP (*pterm
, 0)) == EQ_ATTR
)
3017 if (XSTR (exp
, 0) != XSTR (XEXP (*pterm
, 0), 0))
3020 if (! strcmp (XSTR (exp
, 1), XSTR (XEXP (*pterm
, 0), 1)))
3026 else if (GET_CODE (exp
) == NOT
&& GET_CODE (*pterm
) == NOT
)
3028 if (attr_equal_p (XEXP (exp
, 0), XEXP (*pterm
, 0)))
3032 else if (GET_CODE (exp
) == NOT
)
3034 if (attr_equal_p (XEXP (exp
, 0), *pterm
))
3038 else if (GET_CODE (*pterm
) == NOT
)
3040 if (attr_equal_p (XEXP (*pterm
, 0), exp
))
3044 else if (attr_equal_p (exp
, *pterm
))
3050 /* Similar to `simplify_and_tree', but for IOR trees. */
3053 simplify_or_tree (exp
, pterm
, insn_code
, insn_index
)
3056 int insn_code
, insn_index
;
3061 int left_eliminates_term
, right_eliminates_term
;
3063 if (GET_CODE (exp
) == IOR
)
3065 left
= simplify_or_tree (XEXP (exp
, 0), pterm
, insn_code
, insn_index
);
3066 right
= simplify_or_tree (XEXP (exp
, 1), pterm
, insn_code
, insn_index
);
3067 if (left
!= XEXP (exp
, 0) || right
!= XEXP (exp
, 1))
3069 newexp
= attr_rtx (GET_CODE (exp
), left
, right
);
3071 exp
= SIMPLIFY_TEST_EXP (newexp
, insn_code
, insn_index
);
3075 else if (GET_CODE (exp
) == AND
)
3077 /* For the AND case, we do the same as above, except that we can
3078 only eliminate `term' if both sides of the AND would do so. */
3080 left
= simplify_or_tree (XEXP (exp
, 0), &temp
, insn_code
, insn_index
);
3081 left_eliminates_term
= (temp
== false_rtx
);
3084 right
= simplify_or_tree (XEXP (exp
, 1), &temp
, insn_code
, insn_index
);
3085 right_eliminates_term
= (temp
== false_rtx
);
3087 if (left_eliminates_term
&& right_eliminates_term
)
3090 if (left
!= XEXP (exp
, 0) || right
!= XEXP (exp
, 1))
3092 newexp
= attr_rtx (GET_CODE (exp
), left
, right
);
3094 exp
= SIMPLIFY_TEST_EXP (newexp
, insn_code
, insn_index
);
3098 if (attr_equal_p (exp
, *pterm
))
3101 else if (GET_CODE (exp
) == NOT
&& attr_equal_p (XEXP (exp
, 0), *pterm
))
3104 else if (GET_CODE (*pterm
) == NOT
&& attr_equal_p (XEXP (*pterm
, 0), exp
))
3107 else if (GET_CODE (*pterm
) == EQ_ATTR
&& GET_CODE (exp
) == NOT
3108 && GET_CODE (XEXP (exp
, 0)) == EQ_ATTR
3109 && XSTR (*pterm
, 0) == XSTR (XEXP (exp
, 0), 0))
3112 else if (GET_CODE (exp
) == EQ_ATTR
&& GET_CODE (*pterm
) == NOT
3113 && GET_CODE (XEXP (*pterm
, 0)) == EQ_ATTR
3114 && XSTR (exp
, 0) == XSTR (XEXP (*pterm
, 0), 0))
3120 /* Given an expression, see if it can be simplified for a particular insn
3121 code based on the values of other attributes being tested. This can
3122 eliminate nested get_attr_... calls.
3124 Note that if an endless recursion is specified in the patterns, the
3125 optimization will loop. However, it will do so in precisely the cases where
3126 an infinite recursion loop could occur during compilation. It's better that
3130 simplify_test_exp (exp
, insn_code
, insn_index
)
3132 int insn_code
, insn_index
;
3135 struct attr_desc
*attr
;
3136 struct attr_value
*av
;
3137 struct insn_ent
*ie
;
3140 char *spacer
= (char *) obstack_finish (rtl_obstack
);
3142 /* Don't re-simplify something we already simplified. */
3143 if (RTX_UNCHANGING_P (exp
) || MEM_IN_STRUCT_P (exp
))
3146 switch (GET_CODE (exp
))
3149 left
= SIMPLIFY_TEST_EXP (XEXP (exp
, 0), insn_code
, insn_index
);
3150 SIMPLIFY_ALTERNATIVE (left
);
3151 if (left
== false_rtx
)
3154 obstack_free (rtl_obstack
, spacer
);
3157 right
= SIMPLIFY_TEST_EXP (XEXP (exp
, 1), insn_code
, insn_index
);
3158 SIMPLIFY_ALTERNATIVE (right
);
3159 if (left
== false_rtx
)
3162 obstack_free (rtl_obstack
, spacer
);
3166 /* If either side is an IOR and we have (eq_attr "alternative" ..")
3167 present on both sides, apply the distributive law since this will
3168 yield simplifications. */
3169 if ((GET_CODE (left
) == IOR
|| GET_CODE (right
) == IOR
)
3170 && compute_alternative_mask (left
, IOR
)
3171 && compute_alternative_mask (right
, IOR
))
3173 if (GET_CODE (left
) == IOR
)
3180 newexp
= attr_rtx (IOR
,
3181 attr_rtx (AND
, left
, XEXP (right
, 0)),
3182 attr_rtx (AND
, left
, XEXP (right
, 1)));
3184 return SIMPLIFY_TEST_EXP (newexp
, insn_code
, insn_index
);
3187 /* Try with the term on both sides. */
3188 right
= simplify_and_tree (right
, &left
, insn_code
, insn_index
);
3189 if (left
== XEXP (exp
, 0) && right
== XEXP (exp
, 1))
3190 left
= simplify_and_tree (left
, &right
, insn_code
, insn_index
);
3192 if (left
== false_rtx
|| right
== false_rtx
)
3195 obstack_free (rtl_obstack
, spacer
);
3198 else if (left
== true_rtx
)
3202 else if (right
== true_rtx
)
3206 /* See if all or all but one of the insn's alternatives are specified
3207 in this tree. Optimize if so. */
3209 else if (insn_code
>= 0
3210 && (GET_CODE (left
) == AND
3211 || (GET_CODE (left
) == NOT
3212 && GET_CODE (XEXP (left
, 0)) == EQ_ATTR
3213 && XSTR (XEXP (left
, 0), 0) == alternative_name
)
3214 || GET_CODE (right
) == AND
3215 || (GET_CODE (right
) == NOT
3216 && GET_CODE (XEXP (right
, 0)) == EQ_ATTR
3217 && XSTR (XEXP (right
, 0), 0) == alternative_name
)))
3219 i
= compute_alternative_mask (exp
, AND
);
3220 if (i
& ~insn_alternatives
[insn_code
])
3221 fatal ("Invalid alternative specified for pattern number %d",
3224 /* If all alternatives are excluded, this is false. */
3225 i
^= insn_alternatives
[insn_code
];
3228 else if ((i
& (i
- 1)) == 0 && insn_alternatives
[insn_code
] > 1)
3230 /* If just one excluded, AND a comparison with that one to the
3231 front of the tree. The others will be eliminated by
3232 optimization. We do not want to do this if the insn has one
3233 alternative and we have tested none of them! */
3234 left
= make_alternative_compare (i
);
3235 right
= simplify_and_tree (exp
, &left
, insn_code
, insn_index
);
3236 newexp
= attr_rtx (AND
, left
, right
);
3238 return SIMPLIFY_TEST_EXP (newexp
, insn_code
, insn_index
);
3242 if (left
!= XEXP (exp
, 0) || right
!= XEXP (exp
, 1))
3244 newexp
= attr_rtx (AND
, left
, right
);
3245 return SIMPLIFY_TEST_EXP (newexp
, insn_code
, insn_index
);
3250 left
= SIMPLIFY_TEST_EXP (XEXP (exp
, 0), insn_code
, insn_index
);
3251 SIMPLIFY_ALTERNATIVE (left
);
3252 if (left
== true_rtx
)
3255 obstack_free (rtl_obstack
, spacer
);
3258 right
= SIMPLIFY_TEST_EXP (XEXP (exp
, 1), insn_code
, insn_index
);
3259 SIMPLIFY_ALTERNATIVE (right
);
3260 if (right
== true_rtx
)
3263 obstack_free (rtl_obstack
, spacer
);
3267 right
= simplify_or_tree (right
, &left
, insn_code
, insn_index
);
3268 if (left
== XEXP (exp
, 0) && right
== XEXP (exp
, 1))
3269 left
= simplify_or_tree (left
, &right
, insn_code
, insn_index
);
3271 if (right
== true_rtx
|| left
== true_rtx
)
3274 obstack_free (rtl_obstack
, spacer
);
3277 else if (left
== false_rtx
)
3281 else if (right
== false_rtx
)
3286 /* Test for simple cases where the distributive law is useful. I.e.,
3287 convert (ior (and (x) (y))
3293 else if (GET_CODE (left
) == AND
&& GET_CODE (right
) == AND
3294 && attr_equal_p (XEXP (left
, 0), XEXP (right
, 0)))
3296 newexp
= attr_rtx (IOR
, XEXP (left
, 1), XEXP (right
, 1));
3298 left
= XEXP (left
, 0);
3300 newexp
= attr_rtx (AND
, left
, right
);
3301 return SIMPLIFY_TEST_EXP (newexp
, insn_code
, insn_index
);
3304 /* See if all or all but one of the insn's alternatives are specified
3305 in this tree. Optimize if so. */
3307 else if (insn_code
>= 0
3308 && (GET_CODE (left
) == IOR
3309 || (GET_CODE (left
) == EQ_ATTR
3310 && XSTR (left
, 0) == alternative_name
)
3311 || GET_CODE (right
) == IOR
3312 || (GET_CODE (right
) == EQ_ATTR
3313 && XSTR (right
, 0) == alternative_name
)))
3315 i
= compute_alternative_mask (exp
, IOR
);
3316 if (i
& ~insn_alternatives
[insn_code
])
3317 fatal ("Invalid alternative specified for pattern number %d",
3320 /* If all alternatives are included, this is true. */
3321 i
^= insn_alternatives
[insn_code
];
3324 else if ((i
& (i
- 1)) == 0 && insn_alternatives
[insn_code
] > 1)
3326 /* If just one excluded, IOR a comparison with that one to the
3327 front of the tree. The others will be eliminated by
3328 optimization. We do not want to do this if the insn has one
3329 alternative and we have tested none of them! */
3330 left
= make_alternative_compare (i
);
3331 right
= simplify_and_tree (exp
, &left
, insn_code
, insn_index
);
3332 newexp
= attr_rtx (IOR
, attr_rtx (NOT
, left
), right
);
3334 return SIMPLIFY_TEST_EXP (newexp
, insn_code
, insn_index
);
3338 if (left
!= XEXP (exp
, 0) || right
!= XEXP (exp
, 1))
3340 newexp
= attr_rtx (IOR
, left
, right
);
3341 return SIMPLIFY_TEST_EXP (newexp
, insn_code
, insn_index
);
3346 if (GET_CODE (XEXP (exp
, 0)) == NOT
)
3348 left
= SIMPLIFY_TEST_EXP (XEXP (XEXP (exp
, 0), 0),
3349 insn_code
, insn_index
);
3350 SIMPLIFY_ALTERNATIVE (left
);
3354 left
= SIMPLIFY_TEST_EXP (XEXP (exp
, 0), insn_code
, insn_index
);
3355 SIMPLIFY_ALTERNATIVE (left
);
3356 if (GET_CODE (left
) == NOT
)
3357 return XEXP (left
, 0);
3359 if (left
== false_rtx
)
3362 obstack_free (rtl_obstack
, spacer
);
3365 else if (left
== true_rtx
)
3368 obstack_free (rtl_obstack
, spacer
);
3372 /* Try to apply De`Morgan's laws. */
3373 else if (GET_CODE (left
) == IOR
)
3375 newexp
= attr_rtx (AND
,
3376 attr_rtx (NOT
, XEXP (left
, 0)),
3377 attr_rtx (NOT
, XEXP (left
, 1)));
3379 newexp
= SIMPLIFY_TEST_EXP (newexp
, insn_code
, insn_index
);
3381 else if (GET_CODE (left
) == AND
)
3383 newexp
= attr_rtx (IOR
,
3384 attr_rtx (NOT
, XEXP (left
, 0)),
3385 attr_rtx (NOT
, XEXP (left
, 1)));
3387 newexp
= SIMPLIFY_TEST_EXP (newexp
, insn_code
, insn_index
);
3389 else if (left
!= XEXP (exp
, 0))
3391 newexp
= attr_rtx (NOT
, left
);
3396 if (current_alternative_string
&& XSTR (exp
, 0) == alternative_name
)
3397 return (XSTR (exp
, 1) == current_alternative_string
3398 ? true_rtx
: false_rtx
);
3400 /* Look at the value for this insn code in the specified attribute.
3401 We normally can replace this comparison with the condition that
3402 would give this insn the values being tested for. */
3403 if (XSTR (exp
, 0) != alternative_name
3404 && (attr
= find_attr (XSTR (exp
, 0), 0)) != NULL
)
3405 for (av
= attr
->first_value
; av
; av
= av
->next
)
3406 for (ie
= av
->first_insn
; ie
; ie
= ie
->next
)
3407 if (ie
->insn_code
== insn_code
)
3408 return evaluate_eq_attr (exp
, av
->value
, insn_code
, insn_index
);
3415 /* We have already simplified this expression. Simplifying it again
3416 won't buy anything unless we weren't given a valid insn code
3417 to process (i.e., we are canonicalizing something.). */
3418 if (insn_code
!= -2 /* Seems wrong: && current_alternative_string. */
3419 && ! RTX_UNCHANGING_P (newexp
))
3420 return copy_rtx_unchanging (newexp
);
3425 /* Optimize the attribute lists by seeing if we can determine conditional
3426 values from the known values of other attributes. This will save subroutine
3427 calls during the compilation. */
3432 struct attr_desc
*attr
;
3433 struct attr_value
*av
;
3434 struct insn_ent
*ie
;
3436 int something_changed
= 1;
3438 struct attr_value_list
{ struct attr_value
*av
;
3439 struct insn_ent
*ie
;
3440 struct attr_desc
* attr
;
3441 struct attr_value_list
*next
; };
3442 struct attr_value_list
**insn_code_values
;
3443 struct attr_value_list
*ivbuf
;
3444 struct attr_value_list
*iv
;
3446 /* For each insn code, make a list of all the insn_ent's for it,
3447 for all values for all attributes. */
3449 if (num_insn_ents
== 0)
3452 /* Make 2 extra elements, for "code" values -2 and -1. */
3454 = (struct attr_value_list
**) alloca ((insn_code_number
+ 2)
3455 * sizeof (struct attr_value_list
*));
3456 bzero ((char *) insn_code_values
,
3457 (insn_code_number
+ 2) * sizeof (struct attr_value_list
*));
3459 /* Offset the table address so we can index by -2 or -1. */
3460 insn_code_values
+= 2;
3462 /* Allocate the attr_value_list structures using xmalloc rather than
3463 alloca, because using alloca can overflow the maximum permitted
3464 stack limit on SPARC Lynx. */
3465 iv
= ivbuf
= ((struct attr_value_list
*)
3466 xmalloc (num_insn_ents
* sizeof (struct attr_value_list
)));
3468 for (i
= 0; i
< MAX_ATTRS_INDEX
; i
++)
3469 for (attr
= attrs
[i
]; attr
; attr
= attr
->next
)
3470 for (av
= attr
->first_value
; av
; av
= av
->next
)
3471 for (ie
= av
->first_insn
; ie
; ie
= ie
->next
)
3476 iv
->next
= insn_code_values
[ie
->insn_code
];
3477 insn_code_values
[ie
->insn_code
] = iv
;
3481 /* Sanity check on num_insn_ents. */
3482 if (iv
!= ivbuf
+ num_insn_ents
)
3485 /* Process one insn code at a time. */
3486 for (i
= -2; i
< insn_code_number
; i
++)
3488 /* Clear the MEM_IN_STRUCT_P flag everywhere relevant.
3489 We use it to mean "already simplified for this insn". */
3490 for (iv
= insn_code_values
[i
]; iv
; iv
= iv
->next
)
3491 clear_struct_flag (iv
->av
->value
);
3493 /* Loop until nothing changes for one iteration. */
3494 something_changed
= 1;
3495 while (something_changed
)
3497 something_changed
= 0;
3498 for (iv
= insn_code_values
[i
]; iv
; iv
= iv
->next
)
3500 struct obstack
*old
= rtl_obstack
;
3501 char *spacer
= (char *) obstack_finish (temp_obstack
);
3506 if (GET_CODE (av
->value
) != COND
)
3509 rtl_obstack
= temp_obstack
;
3510 #if 0 /* This was intended as a speed up, but it was slower. */
3511 if (insn_n_alternatives
[ie
->insn_code
] > 6
3512 && count_sub_rtxs (av
->value
, 200) >= 200)
3513 newexp
= simplify_by_alternatives (av
->value
, ie
->insn_code
,
3517 newexp
= simplify_cond (av
->value
, ie
->insn_code
,
3521 if (newexp
!= av
->value
)
3523 newexp
= attr_copy_rtx (newexp
);
3524 remove_insn_ent (av
, ie
);
3525 av
= get_attr_value (newexp
, attr
, ie
->insn_code
);
3527 insert_insn_ent (av
, ie
);
3528 something_changed
= 1;
3531 obstack_free (temp_obstack
, spacer
);
3541 simplify_by_alternatives (exp
, insn_code
, insn_index
)
3543 int insn_code
, insn_index
;
3546 int len
= insn_n_alternatives
[insn_code
];
3547 rtx newexp
= rtx_alloc (COND
);
3551 XVEC (newexp
, 0) = rtvec_alloc (len
* 2);
3553 /* It will not matter what value we use as the default value
3554 of the new COND, since that default will never be used.
3555 Choose something of the right type. */
3556 for (ultimate
= exp
; GET_CODE (ultimate
) == COND
;)
3557 ultimate
= XEXP (ultimate
, 1);
3558 XEXP (newexp
, 1) = ultimate
;
3560 for (i
= 0; i
< insn_n_alternatives
[insn_code
]; i
++)
3562 current_alternative_string
= attr_numeral (i
);
3563 XVECEXP (newexp
, 0, i
* 2) = make_alternative_compare (1 << i
);
3564 XVECEXP (newexp
, 0, i
* 2 + 1)
3565 = simplify_cond (exp
, insn_code
, insn_index
);
3568 current_alternative_string
= 0;
3569 return simplify_cond (newexp
, insn_code
, insn_index
);
3573 /* If EXP is a suitable expression, reorganize it by constructing an
3574 equivalent expression that is a COND with the tests being all combinations
3575 of attribute values and the values being simple constants. */
3578 simplify_by_exploding (exp
)
3581 rtx list
= 0, link
, condexp
, defval
= NULL_RTX
;
3582 struct dimension
*space
;
3583 rtx
*condtest
, *condval
;
3584 int i
, j
, total
, ndim
= 0;
3585 int most_tests
, num_marks
, new_marks
;
3587 /* Locate all the EQ_ATTR expressions. */
3588 if (! find_and_mark_used_attributes (exp
, &list
, &ndim
) || ndim
== 0)
3590 unmark_used_attributes (list
, 0, 0);
3594 /* Create an attribute space from the list of used attributes. For each
3595 dimension in the attribute space, record the attribute, list of values
3596 used, and number of values used. Add members to the list of values to
3597 cover the domain of the attribute. This makes the expanded COND form
3598 order independent. */
3600 space
= (struct dimension
*) alloca (ndim
* sizeof (struct dimension
));
3603 for (ndim
= 0; list
; ndim
++)
3605 /* Pull the first attribute value from the list and record that
3606 attribute as another dimension in the attribute space. */
3607 char *name
= XSTR (XEXP (list
, 0), 0);
3610 if ((space
[ndim
].attr
= find_attr (name
, 0)) == 0
3611 || space
[ndim
].attr
->is_numeric
)
3613 unmark_used_attributes (list
, space
, ndim
);
3617 /* Add all remaining attribute values that refer to this attribute. */
3618 space
[ndim
].num_values
= 0;
3619 space
[ndim
].values
= 0;
3621 for (link
= list
; link
; link
= *prev
)
3622 if (! strcmp (XSTR (XEXP (link
, 0), 0), name
))
3624 space
[ndim
].num_values
++;
3625 *prev
= XEXP (link
, 1);
3626 XEXP (link
, 1) = space
[ndim
].values
;
3627 space
[ndim
].values
= link
;
3630 prev
= &XEXP (link
, 1);
3632 /* Add sufficient members to the list of values to make the list
3633 mutually exclusive and record the total size of the attribute
3635 total
*= add_values_to_cover (&space
[ndim
]);
3638 /* Sort the attribute space so that the attributes go from non-constant
3639 to constant and from most values to least values. */
3640 for (i
= 0; i
< ndim
; i
++)
3641 for (j
= ndim
- 1; j
> i
; j
--)
3642 if ((space
[j
-1].attr
->is_const
&& !space
[j
].attr
->is_const
)
3643 || space
[j
-1].num_values
< space
[j
].num_values
)
3645 struct dimension tmp
;
3647 space
[j
] = space
[j
-1];
3651 /* Establish the initial current value. */
3652 for (i
= 0; i
< ndim
; i
++)
3653 space
[i
].current_value
= space
[i
].values
;
3655 condtest
= (rtx
*) alloca (total
* sizeof (rtx
));
3656 condval
= (rtx
*) alloca (total
* sizeof (rtx
));
3658 /* Expand the tests and values by iterating over all values in the
3662 condtest
[i
] = test_for_current_value (space
, ndim
);
3663 condval
[i
] = simplify_with_current_value (exp
, space
, ndim
);
3664 if (! increment_current_value (space
, ndim
))
3670 /* We are now finished with the original expression. */
3671 unmark_used_attributes (0, space
, ndim
);
3673 /* Find the most used constant value and make that the default. */
3675 for (i
= num_marks
= 0; i
< total
; i
++)
3676 if (GET_CODE (condval
[i
]) == CONST_STRING
3677 && ! MEM_VOLATILE_P (condval
[i
]))
3679 /* Mark the unmarked constant value and count how many are marked. */
3680 MEM_VOLATILE_P (condval
[i
]) = 1;
3681 for (j
= new_marks
= 0; j
< total
; j
++)
3682 if (GET_CODE (condval
[j
]) == CONST_STRING
3683 && MEM_VOLATILE_P (condval
[j
]))
3685 if (new_marks
- num_marks
> most_tests
)
3687 most_tests
= new_marks
- num_marks
;
3688 defval
= condval
[i
];
3690 num_marks
= new_marks
;
3692 /* Clear all the marks. */
3693 for (i
= 0; i
< total
; i
++)
3694 MEM_VOLATILE_P (condval
[i
]) = 0;
3696 /* Give up if nothing is constant. */
3700 /* If all values are the default, use that. */
3701 if (total
== most_tests
)
3704 /* Make a COND with the most common constant value the default. (A more
3705 complex method where tests with the same value were combined didn't
3706 seem to improve things.) */
3707 condexp
= rtx_alloc (COND
);
3708 XVEC (condexp
, 0) = rtvec_alloc ((total
- most_tests
) * 2);
3709 XEXP (condexp
, 1) = defval
;
3710 for (i
= j
= 0; i
< total
; i
++)
3711 if (condval
[i
] != defval
)
3713 XVECEXP (condexp
, 0, 2 * j
) = condtest
[i
];
3714 XVECEXP (condexp
, 0, 2 * j
+ 1) = condval
[i
];
3721 /* Set the MEM_VOLATILE_P flag for all EQ_ATTR expressions in EXP and
3722 verify that EXP can be simplified to a constant term if all the EQ_ATTR
3723 tests have known value. */
3726 find_and_mark_used_attributes (exp
, terms
, nterms
)
3732 switch (GET_CODE (exp
))
3735 if (! MEM_VOLATILE_P (exp
))
3737 rtx link
= rtx_alloc (EXPR_LIST
);
3738 XEXP (link
, 0) = exp
;
3739 XEXP (link
, 1) = *terms
;
3742 MEM_VOLATILE_P (exp
) = 1;
3751 if (! find_and_mark_used_attributes (XEXP (exp
, 2), terms
, nterms
))
3755 if (! find_and_mark_used_attributes (XEXP (exp
, 1), terms
, nterms
))
3758 if (! find_and_mark_used_attributes (XEXP (exp
, 0), terms
, nterms
))
3763 for (i
= 0; i
< XVECLEN (exp
, 0); i
++)
3764 if (! find_and_mark_used_attributes (XVECEXP (exp
, 0, i
), terms
, nterms
))
3766 if (! find_and_mark_used_attributes (XEXP (exp
, 1), terms
, nterms
))
3775 /* Clear the MEM_VOLATILE_P flag in all EQ_ATTR expressions on LIST and
3776 in the values of the NDIM-dimensional attribute space SPACE. */
3779 unmark_used_attributes (list
, space
, ndim
)
3781 struct dimension
*space
;
3787 for (i
= 0; i
< ndim
; i
++)
3788 unmark_used_attributes (space
[i
].values
, 0, 0);
3790 for (link
= list
; link
; link
= XEXP (link
, 1))
3792 exp
= XEXP (link
, 0);
3793 if (GET_CODE (exp
) == EQ_ATTR
)
3794 MEM_VOLATILE_P (exp
) = 0;
3798 /* Update the attribute dimension DIM so that all values of the attribute
3799 are tested. Return the updated number of values. */
3802 add_values_to_cover (dim
)
3803 struct dimension
*dim
;
3805 struct attr_value
*av
;
3806 rtx exp
, link
, *prev
;
3809 for (av
= dim
->attr
->first_value
; av
; av
= av
->next
)
3810 if (GET_CODE (av
->value
) == CONST_STRING
)
3813 if (nalt
< dim
->num_values
)
3815 else if (nalt
== dim
->num_values
)
3817 else if (nalt
* 2 < dim
->num_values
* 3)
3819 /* Most all the values of the attribute are used, so add all the unused
3821 prev
= &dim
->values
;
3822 for (link
= dim
->values
; link
; link
= *prev
)
3823 prev
= &XEXP (link
, 1);
3825 for (av
= dim
->attr
->first_value
; av
; av
= av
->next
)
3826 if (GET_CODE (av
->value
) == CONST_STRING
)
3828 exp
= attr_eq (dim
->attr
->name
, XSTR (av
->value
, 0));
3829 if (MEM_VOLATILE_P (exp
))
3832 link
= rtx_alloc (EXPR_LIST
);
3833 XEXP (link
, 0) = exp
;
3836 prev
= &XEXP (link
, 1);
3838 dim
->num_values
= nalt
;
3842 rtx orexp
= false_rtx
;
3844 /* Very few values are used, so compute a mutually exclusive
3845 expression. (We could do this for numeric values if that becomes
3847 prev
= &dim
->values
;
3848 for (link
= dim
->values
; link
; link
= *prev
)
3850 orexp
= insert_right_side (IOR
, orexp
, XEXP (link
, 0), -2, -2);
3851 prev
= &XEXP (link
, 1);
3853 link
= rtx_alloc (EXPR_LIST
);
3854 XEXP (link
, 0) = attr_rtx (NOT
, orexp
);
3859 return dim
->num_values
;
3862 /* Increment the current value for the NDIM-dimensional attribute space SPACE
3863 and return FALSE if the increment overflowed. */
3866 increment_current_value (space
, ndim
)
3867 struct dimension
*space
;
3872 for (i
= ndim
- 1; i
>= 0; i
--)
3874 if ((space
[i
].current_value
= XEXP (space
[i
].current_value
, 1)) == 0)
3875 space
[i
].current_value
= space
[i
].values
;
3882 /* Construct an expression corresponding to the current value for the
3883 NDIM-dimensional attribute space SPACE. */
3886 test_for_current_value (space
, ndim
)
3887 struct dimension
*space
;
3893 for (i
= 0; i
< ndim
; i
++)
3894 exp
= insert_right_side (AND
, exp
, XEXP (space
[i
].current_value
, 0),
3900 /* Given the current value of the NDIM-dimensional attribute space SPACE,
3901 set the corresponding EQ_ATTR expressions to that value and reduce
3902 the expression EXP as much as possible. On input [and output], all
3903 known EQ_ATTR expressions are set to FALSE. */
3906 simplify_with_current_value (exp
, space
, ndim
)
3908 struct dimension
*space
;
3914 /* Mark each current value as TRUE. */
3915 for (i
= 0; i
< ndim
; i
++)
3917 x
= XEXP (space
[i
].current_value
, 0);
3918 if (GET_CODE (x
) == EQ_ATTR
)
3919 MEM_VOLATILE_P (x
) = 0;
3922 exp
= simplify_with_current_value_aux (exp
);
3924 /* Change each current value back to FALSE. */
3925 for (i
= 0; i
< ndim
; i
++)
3927 x
= XEXP (space
[i
].current_value
, 0);
3928 if (GET_CODE (x
) == EQ_ATTR
)
3929 MEM_VOLATILE_P (x
) = 1;
3935 /* Reduce the expression EXP based on the MEM_VOLATILE_P settings of
3936 all EQ_ATTR expressions. */
3939 simplify_with_current_value_aux (exp
)
3945 switch (GET_CODE (exp
))
3948 if (MEM_VOLATILE_P (exp
))
3957 cond
= simplify_with_current_value_aux (XEXP (exp
, 0));
3958 if (cond
== true_rtx
)
3959 return simplify_with_current_value_aux (XEXP (exp
, 1));
3960 else if (cond
== false_rtx
)
3961 return simplify_with_current_value_aux (XEXP (exp
, 2));
3963 return attr_rtx (IF_THEN_ELSE
, cond
,
3964 simplify_with_current_value_aux (XEXP (exp
, 1)),
3965 simplify_with_current_value_aux (XEXP (exp
, 2)));
3968 cond
= simplify_with_current_value_aux (XEXP (exp
, 1));
3969 if (cond
== true_rtx
)
3971 else if (cond
== false_rtx
)
3972 return simplify_with_current_value_aux (XEXP (exp
, 0));
3974 return attr_rtx (IOR
, cond
,
3975 simplify_with_current_value_aux (XEXP (exp
, 0)));
3978 cond
= simplify_with_current_value_aux (XEXP (exp
, 1));
3979 if (cond
== true_rtx
)
3980 return simplify_with_current_value_aux (XEXP (exp
, 0));
3981 else if (cond
== false_rtx
)
3984 return attr_rtx (AND
, cond
,
3985 simplify_with_current_value_aux (XEXP (exp
, 0)));
3988 cond
= simplify_with_current_value_aux (XEXP (exp
, 0));
3989 if (cond
== true_rtx
)
3991 else if (cond
== false_rtx
)
3994 return attr_rtx (NOT
, cond
);
3997 for (i
= 0; i
< XVECLEN (exp
, 0); i
+= 2)
3999 cond
= simplify_with_current_value_aux (XVECEXP (exp
, 0, i
));
4000 if (cond
== true_rtx
)
4001 return simplify_with_current_value_aux (XVECEXP (exp
, 0, i
+ 1));
4002 else if (cond
== false_rtx
)
4005 abort (); /* With all EQ_ATTR's of known value, a case should
4006 have been selected. */
4008 return simplify_with_current_value_aux (XEXP (exp
, 1));
4015 /* Clear the MEM_IN_STRUCT_P flag in EXP and its subexpressions. */
4018 clear_struct_flag (x
)
4023 register enum rtx_code code
;
4024 register const char *fmt
;
4026 MEM_IN_STRUCT_P (x
) = 0;
4027 if (RTX_UNCHANGING_P (x
))
4030 code
= GET_CODE (x
);
4050 /* Compare the elements. If any pair of corresponding elements
4051 fail to match, return 0 for the whole things. */
4053 fmt
= GET_RTX_FORMAT (code
);
4054 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
4060 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
4061 clear_struct_flag (XVECEXP (x
, i
, j
));
4065 clear_struct_flag (XEXP (x
, i
));
4071 /* Return the number of RTX objects making up the expression X.
4072 But if we count more than MAX objects, stop counting. */
4075 count_sub_rtxs (x
, max
)
4081 register enum rtx_code code
;
4082 register const char *fmt
;
4085 code
= GET_CODE (x
);
4105 /* Compare the elements. If any pair of corresponding elements
4106 fail to match, return 0 for the whole things. */
4108 fmt
= GET_RTX_FORMAT (code
);
4109 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
4118 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
4119 total
+= count_sub_rtxs (XVECEXP (x
, i
, j
), max
);
4123 total
+= count_sub_rtxs (XEXP (x
, i
), max
);
4131 /* Create table entries for DEFINE_ATTR. */
4137 struct attr_desc
*attr
;
4138 struct attr_value
*av
;
4142 /* Make a new attribute structure. Check for duplicate by looking at
4143 attr->default_val, since it is initialized by this routine. */
4144 attr
= find_attr (XSTR (exp
, 0), 1);
4145 if (attr
->default_val
)
4146 fatal ("Duplicate definition for `%s' attribute", attr
->name
);
4148 if (*XSTR (exp
, 1) == '\0')
4149 attr
->is_numeric
= 1;
4152 name_ptr
= XSTR (exp
, 1);
4153 while ((p
= next_comma_elt (&name_ptr
)) != NULL
)
4155 av
= (struct attr_value
*) oballoc (sizeof (struct attr_value
));
4156 av
->value
= attr_rtx (CONST_STRING
, p
);
4157 av
->next
= attr
->first_value
;
4158 attr
->first_value
= av
;
4159 av
->first_insn
= NULL
;
4161 av
->has_asm_insn
= 0;
4165 if (GET_CODE (XEXP (exp
, 2)) == CONST
)
4168 if (attr
->is_numeric
)
4169 fatal ("Constant attributes may not take numeric values");
4170 /* Get rid of the CONST node. It is allowed only at top-level. */
4171 XEXP (exp
, 2) = XEXP (XEXP (exp
, 2), 0);
4174 if (! strcmp (attr
->name
, "length") && ! attr
->is_numeric
)
4175 fatal ("`length' attribute must take numeric values");
4177 /* Set up the default value. */
4178 XEXP (exp
, 2) = check_attr_value (XEXP (exp
, 2), attr
);
4179 attr
->default_val
= get_attr_value (XEXP (exp
, 2), attr
, -2);
4182 /* Given a pattern for DEFINE_PEEPHOLE or DEFINE_INSN, return the number of
4183 alternatives in the constraints. Assume all MATCH_OPERANDs have the same
4184 number of alternatives as this should be checked elsewhere. */
4187 count_alternatives (exp
)
4193 if (GET_CODE (exp
) == MATCH_OPERAND
)
4194 return n_comma_elts (XSTR (exp
, 2));
4196 for (i
= 0, fmt
= GET_RTX_FORMAT (GET_CODE (exp
));
4197 i
< GET_RTX_LENGTH (GET_CODE (exp
)); i
++)
4202 n
= count_alternatives (XEXP (exp
, i
));
4209 if (XVEC (exp
, i
) != NULL
)
4210 for (j
= 0; j
< XVECLEN (exp
, i
); j
++)
4212 n
= count_alternatives (XVECEXP (exp
, i
, j
));
4221 /* Returns non-zero if the given expression contains an EQ_ATTR with the
4222 `alternative' attribute. */
4225 compares_alternatives_p (exp
)
4231 if (GET_CODE (exp
) == EQ_ATTR
&& XSTR (exp
, 0) == alternative_name
)
4234 for (i
= 0, fmt
= GET_RTX_FORMAT (GET_CODE (exp
));
4235 i
< GET_RTX_LENGTH (GET_CODE (exp
)); i
++)
4240 if (compares_alternatives_p (XEXP (exp
, i
)))
4245 for (j
= 0; j
< XVECLEN (exp
, i
); j
++)
4246 if (compares_alternatives_p (XVECEXP (exp
, i
, j
)))
4254 /* Returns non-zero is INNER is contained in EXP. */
4257 contained_in_p (inner
, exp
)
4264 if (rtx_equal_p (inner
, exp
))
4267 for (i
= 0, fmt
= GET_RTX_FORMAT (GET_CODE (exp
));
4268 i
< GET_RTX_LENGTH (GET_CODE (exp
)); i
++)
4273 if (contained_in_p (inner
, XEXP (exp
, i
)))
4278 for (j
= 0; j
< XVECLEN (exp
, i
); j
++)
4279 if (contained_in_p (inner
, XVECEXP (exp
, i
, j
)))
4287 /* Process DEFINE_PEEPHOLE, DEFINE_INSN, and DEFINE_ASM_ATTRIBUTES. */
4293 struct insn_def
*id
;
4295 id
= (struct insn_def
*) oballoc (sizeof (struct insn_def
));
4300 switch (GET_CODE (exp
))
4303 id
->insn_code
= insn_code_number
++;
4304 id
->insn_index
= insn_index_number
++;
4305 id
->num_alternatives
= count_alternatives (exp
);
4306 if (id
->num_alternatives
== 0)
4307 id
->num_alternatives
= 1;
4311 case DEFINE_PEEPHOLE
:
4312 id
->insn_code
= insn_code_number
++;
4313 id
->insn_index
= insn_index_number
++;
4314 id
->num_alternatives
= count_alternatives (exp
);
4315 if (id
->num_alternatives
== 0)
4316 id
->num_alternatives
= 1;
4320 case DEFINE_ASM_ATTRIBUTES
:
4322 id
->insn_index
= -1;
4323 id
->num_alternatives
= 1;
4325 got_define_asm_attributes
= 1;
4333 /* Process a DEFINE_DELAY. Validate the vector length, check if annul
4334 true or annul false is specified, and make a `struct delay_desc'. */
4340 struct delay_desc
*delay
;
4343 if (XVECLEN (def
, 1) % 3 != 0)
4344 fatal ("Number of elements in DEFINE_DELAY must be multiple of three.");
4346 for (i
= 0; i
< XVECLEN (def
, 1); i
+= 3)
4348 if (XVECEXP (def
, 1, i
+ 1))
4349 have_annul_true
= 1;
4350 if (XVECEXP (def
, 1, i
+ 2))
4351 have_annul_false
= 1;
4354 delay
= (struct delay_desc
*) oballoc (sizeof (struct delay_desc
));
4356 delay
->num
= ++num_delays
;
4357 delay
->next
= delays
;
4361 /* Process a DEFINE_FUNCTION_UNIT.
4363 This gives information about a function unit contained in the CPU.
4364 We fill in a `struct function_unit_op' and a `struct function_unit'
4365 with information used later by `expand_unit'. */
4371 struct function_unit
*unit
;
4372 struct function_unit_op
*op
;
4373 char *name
= XSTR (def
, 0);
4374 int multiplicity
= XINT (def
, 1);
4375 int simultaneity
= XINT (def
, 2);
4376 rtx condexp
= XEXP (def
, 3);
4377 int ready_cost
= MAX (XINT (def
, 4), 1);
4378 int issue_delay
= MAX (XINT (def
, 5), 1);
4380 /* See if we have already seen this function unit. If so, check that
4381 the multiplicity and simultaneity values are the same. If not, make
4382 a structure for this function unit. */
4383 for (unit
= units
; unit
; unit
= unit
->next
)
4384 if (! strcmp (unit
->name
, name
))
4386 if (unit
->multiplicity
!= multiplicity
4387 || unit
->simultaneity
!= simultaneity
)
4388 fatal ("Differing specifications given for `%s' function unit.",
4395 unit
= (struct function_unit
*) oballoc (sizeof (struct function_unit
));
4397 unit
->multiplicity
= multiplicity
;
4398 unit
->simultaneity
= simultaneity
;
4399 unit
->issue_delay
.min
= unit
->issue_delay
.max
= issue_delay
;
4400 unit
->num
= num_units
++;
4401 unit
->num_opclasses
= 0;
4402 unit
->condexp
= false_rtx
;
4408 /* Make a new operation class structure entry and initialize it. */
4409 op
= (struct function_unit_op
*) oballoc (sizeof (struct function_unit_op
));
4410 op
->condexp
= condexp
;
4411 op
->num
= unit
->num_opclasses
++;
4412 op
->ready
= ready_cost
;
4413 op
->issue_delay
= issue_delay
;
4414 op
->next
= unit
->ops
;
4416 num_unit_opclasses
++;
4418 /* Set our issue expression based on whether or not an optional conflict
4419 vector was specified. */
4422 /* Compute the IOR of all the specified expressions. */
4423 rtx orexp
= false_rtx
;
4426 for (i
= 0; i
< XVECLEN (def
, 6); i
++)
4427 orexp
= insert_right_side (IOR
, orexp
, XVECEXP (def
, 6, i
), -2, -2);
4429 op
->conflict_exp
= orexp
;
4430 extend_range (&unit
->issue_delay
, 1, issue_delay
);
4434 op
->conflict_exp
= true_rtx
;
4435 extend_range (&unit
->issue_delay
, issue_delay
, issue_delay
);
4438 /* Merge our conditional into that of the function unit so we can determine
4439 which insns are used by the function unit. */
4440 unit
->condexp
= insert_right_side (IOR
, unit
->condexp
, op
->condexp
, -2, -2);
4443 /* Given a piece of RTX, print a C expression to test its truth value.
4444 We use AND and IOR both for logical and bit-wise operations, so
4445 interpret them as logical unless they are inside a comparison expression.
4446 The first bit of FLAGS will be non-zero in that case.
4448 Set the second bit of FLAGS to make references to attribute values use
4449 a cached local variable instead of calling a function. */
4452 write_test_expr (exp
, flags
)
4456 int comparison_operator
= 0;
4458 struct attr_desc
*attr
;
4460 /* In order not to worry about operator precedence, surround our part of
4461 the expression with parentheses. */
4464 code
= GET_CODE (exp
);
4467 /* Binary operators. */
4469 case GE
: case GT
: case GEU
: case GTU
:
4470 case LE
: case LT
: case LEU
: case LTU
:
4471 comparison_operator
= 1;
4473 case PLUS
: case MINUS
: case MULT
: case DIV
: case MOD
:
4474 case AND
: case IOR
: case XOR
:
4475 case ASHIFT
: case LSHIFTRT
: case ASHIFTRT
:
4476 write_test_expr (XEXP (exp
, 0), flags
| comparison_operator
);
4492 printf (" >= (unsigned) ");
4495 printf (" > (unsigned) ");
4504 printf (" <= (unsigned) ");
4507 printf (" < (unsigned) ");
4550 write_test_expr (XEXP (exp
, 1), flags
| comparison_operator
);
4554 /* Special-case (not (eq_attrq "alternative" "x")) */
4555 if (! (flags
& 1) && GET_CODE (XEXP (exp
, 0)) == EQ_ATTR
4556 && XSTR (XEXP (exp
, 0), 0) == alternative_name
)
4558 printf ("which_alternative != %s", XSTR (XEXP (exp
, 0), 1));
4562 /* Otherwise, fall through to normal unary operator. */
4564 /* Unary operators. */
4584 write_test_expr (XEXP (exp
, 0), flags
);
4587 /* Comparison test of an attribute with a value. Most of these will
4588 have been removed by optimization. Handle "alternative"
4589 specially and give error if EQ_ATTR present inside a comparison. */
4592 fatal ("EQ_ATTR not valid inside comparison");
4594 if (XSTR (exp
, 0) == alternative_name
)
4596 printf ("which_alternative == %s", XSTR (exp
, 1));
4600 attr
= find_attr (XSTR (exp
, 0), 0);
4601 if (! attr
) abort ();
4603 /* Now is the time to expand the value of a constant attribute. */
4606 write_test_expr (evaluate_eq_attr (exp
, attr
->default_val
->value
,
4613 printf ("attr_%s", attr
->name
);
4615 printf ("get_attr_%s (insn)", attr
->name
);
4617 write_attr_valueq (attr
, XSTR (exp
, 1));
4621 /* Comparison test of flags for define_delays. */
4624 fatal ("ATTR_FLAG not valid inside comparison");
4625 printf ("(flags & ATTR_FLAG_%s) != 0", XSTR (exp
, 0));
4628 /* See if an operand matches a predicate. */
4630 /* If only a mode is given, just ensure the mode matches the operand.
4631 If neither a mode nor predicate is given, error. */
4632 if (XSTR (exp
, 1) == NULL
|| *XSTR (exp
, 1) == '\0')
4634 if (GET_MODE (exp
) == VOIDmode
)
4635 fatal ("Null MATCH_OPERAND specified as test");
4637 printf ("GET_MODE (operands[%d]) == %smode",
4638 XINT (exp
, 0), GET_MODE_NAME (GET_MODE (exp
)));
4641 printf ("%s (operands[%d], %smode)",
4642 XSTR (exp
, 1), XINT (exp
, 0), GET_MODE_NAME (GET_MODE (exp
)));
4646 printf ("%s (insn)", XSTR (exp
, 0));
4649 /* Constant integer. */
4651 printf (HOST_WIDE_INT_PRINT_DEC
, XWINT (exp
, 0));
4654 /* A random C expression. */
4656 printf ("%s", XSTR (exp
, 0));
4659 /* The address of the branch target. */
4661 printf ("insn_addresses[INSN_UID (GET_CODE (operands[%d]) == LABEL_REF ? XEXP (operands[%d], 0) : operands[%d])]",
4662 XINT (exp
, 0), XINT (exp
, 0), XINT (exp
, 0));
4666 /* The address of the current insn. We implement this actually as the
4667 address of the current insn for backward branches, but the last
4668 address of the next insn for forward branches, and both with
4669 adjustments that account for the worst-case possible stretching of
4670 intervening alignments between this insn and its destination. */
4671 printf("insn_current_reference_address (insn)");
4675 printf ("%s", XSTR (exp
, 0));
4679 write_test_expr (XEXP (exp
, 0), flags
& 2);
4681 write_test_expr (XEXP (exp
, 1), flags
| 1);
4683 write_test_expr (XEXP (exp
, 2), flags
| 1);
4687 fatal ("bad RTX code `%s' in attribute calculation\n",
4688 GET_RTX_NAME (code
));
4694 /* Given an attribute value, return the maximum CONST_STRING argument
4695 encountered. Set *UNKNOWNP and return INT_MAX if the value is unknown. */
4698 max_attr_value (exp
, unknownp
)
4705 switch (GET_CODE (exp
))
4708 current_max
= atoi (XSTR (exp
, 0));
4712 current_max
= max_attr_value (XEXP (exp
, 1), unknownp
);
4713 for (i
= 0; i
< XVECLEN (exp
, 0); i
+= 2)
4715 n
= max_attr_value (XVECEXP (exp
, 0, i
+ 1), unknownp
);
4716 if (n
> current_max
)
4722 current_max
= max_attr_value (XEXP (exp
, 1), unknownp
);
4723 n
= max_attr_value (XEXP (exp
, 2), unknownp
);
4724 if (n
> current_max
)
4730 current_max
= INT_MAX
;
4737 /* Given an attribute value, return the result of ORing together all
4738 CONST_STRING arguments encountered. Set *UNKNOWNP and return -1
4739 if the numeric value is not known. */
4742 or_attr_value (exp
, unknownp
)
4749 switch (GET_CODE (exp
))
4752 current_or
= atoi (XSTR (exp
, 0));
4756 current_or
= or_attr_value (XEXP (exp
, 1), unknownp
);
4757 for (i
= 0; i
< XVECLEN (exp
, 0); i
+= 2)
4758 current_or
|= or_attr_value (XVECEXP (exp
, 0, i
+ 1), unknownp
);
4762 current_or
= or_attr_value (XEXP (exp
, 1), unknownp
);
4763 current_or
|= or_attr_value (XEXP (exp
, 2), unknownp
);
4775 /* Scan an attribute value, possibly a conditional, and record what actions
4776 will be required to do any conditional tests in it.
4779 `must_extract' if we need to extract the insn operands
4780 `must_constrain' if we must compute `which_alternative'
4781 `address_used' if an address expression was used
4782 `length_used' if an (eq_attr "length" ...) was used
4786 walk_attr_value (exp
)
4790 register const char *fmt
;
4796 code
= GET_CODE (exp
);
4800 if (! RTX_UNCHANGING_P (exp
))
4801 /* Since this is an arbitrary expression, it can look at anything.
4802 However, constant expressions do not depend on any particular
4804 must_extract
= must_constrain
= 1;
4812 if (XSTR (exp
, 0) == alternative_name
)
4813 must_extract
= must_constrain
= 1;
4814 else if (strcmp (XSTR (exp
, 0), "length") == 0)
4834 for (i
= 0, fmt
= GET_RTX_FORMAT (code
); i
< GET_RTX_LENGTH (code
); i
++)
4839 walk_attr_value (XEXP (exp
, i
));
4843 if (XVEC (exp
, i
) != NULL
)
4844 for (j
= 0; j
< XVECLEN (exp
, i
); j
++)
4845 walk_attr_value (XVECEXP (exp
, i
, j
));
4850 /* Write out a function to obtain the attribute for a given INSN. */
4853 write_attr_get (attr
)
4854 struct attr_desc
*attr
;
4856 struct attr_value
*av
, *common_av
;
4858 /* Find the most used attribute value. Handle that as the `default' of the
4859 switch we will generate. */
4860 common_av
= find_most_used (attr
);
4862 /* Write out prototype of function. */
4863 if (!attr
->is_numeric
)
4864 printf ("extern enum attr_%s ", attr
->name
);
4865 else if (attr
->unsigned_p
)
4866 printf ("extern unsigned int ");
4868 printf ("extern int ");
4869 /* If the attribute name starts with a star, the remainder is the name of
4870 the subroutine to use, instead of `get_attr_...'. */
4871 if (attr
->name
[0] == '*')
4872 printf ("%s PROTO ((rtx));\n", &attr
->name
[1]);
4874 printf ("get_attr_%s PROTO ((%s));\n", attr
->name
,
4875 (attr
->is_const
? "void" : "rtx"));
4877 /* Write out start of function, then all values with explicit `case' lines,
4878 then a `default', then the value with the most uses. */
4879 if (!attr
->is_numeric
)
4880 printf ("enum attr_%s\n", attr
->name
);
4881 else if (attr
->unsigned_p
)
4882 printf ("unsigned int\n");
4886 /* If the attribute name starts with a star, the remainder is the name of
4887 the subroutine to use, instead of `get_attr_...'. */
4888 if (attr
->name
[0] == '*')
4889 printf ("%s (insn)\n", &attr
->name
[1]);
4890 else if (attr
->is_const
== 0)
4891 printf ("get_attr_%s (insn)\n", attr
->name
);
4894 printf ("get_attr_%s ()\n", attr
->name
);
4897 for (av
= attr
->first_value
; av
; av
= av
->next
)
4898 if (av
->num_insns
!= 0)
4899 write_attr_set (attr
, 2, av
->value
, "return", ";",
4900 true_rtx
, av
->first_insn
->insn_code
,
4901 av
->first_insn
->insn_index
);
4907 printf (" rtx insn;\n");
4910 if (GET_CODE (common_av
->value
) == FFS
)
4912 rtx p
= XEXP (common_av
->value
, 0);
4914 /* No need to emit code to abort if the insn is unrecognized; the
4915 other get_attr_foo functions will do that when we call them. */
4917 write_toplevel_expr (p
);
4919 printf ("\n if (accum && accum == (accum & -accum))\n");
4921 printf (" int i;\n");
4922 printf (" for (i = 0; accum >>= 1; ++i) continue;\n");
4923 printf (" accum = i;\n");
4924 printf (" }\n else\n");
4925 printf (" accum = ~accum;\n");
4926 printf (" return accum;\n}\n\n");
4930 printf (" switch (recog_memoized (insn))\n");
4933 for (av
= attr
->first_value
; av
; av
= av
->next
)
4934 if (av
!= common_av
)
4935 write_attr_case (attr
, av
, 1, "return", ";", 4, true_rtx
);
4937 write_attr_case (attr
, common_av
, 0, "return", ";", 4, true_rtx
);
4938 printf (" }\n}\n\n");
4942 /* Given an AND tree of known true terms (because we are inside an `if' with
4943 that as the condition or are in an `else' clause) and an expression,
4944 replace any known true terms with TRUE. Use `simplify_and_tree' to do
4945 the bulk of the work. */
4948 eliminate_known_true (known_true
, exp
, insn_code
, insn_index
)
4951 int insn_code
, insn_index
;
4955 known_true
= SIMPLIFY_TEST_EXP (known_true
, insn_code
, insn_index
);
4957 if (GET_CODE (known_true
) == AND
)
4959 exp
= eliminate_known_true (XEXP (known_true
, 0), exp
,
4960 insn_code
, insn_index
);
4961 exp
= eliminate_known_true (XEXP (known_true
, 1), exp
,
4962 insn_code
, insn_index
);
4967 exp
= simplify_and_tree (exp
, &term
, insn_code
, insn_index
);
4973 /* Write out a series of tests and assignment statements to perform tests and
4974 sets of an attribute value. We are passed an indentation amount and prefix
4975 and suffix strings to write around each attribute value (e.g., "return"
4979 write_attr_set (attr
, indent
, value
, prefix
, suffix
, known_true
,
4980 insn_code
, insn_index
)
4981 struct attr_desc
*attr
;
4987 int insn_code
, insn_index
;
4989 if (GET_CODE (value
) == COND
)
4991 /* Assume the default value will be the default of the COND unless we
4992 find an always true expression. */
4993 rtx default_val
= XEXP (value
, 1);
4994 rtx our_known_true
= known_true
;
4999 for (i
= 0; i
< XVECLEN (value
, 0); i
+= 2)
5004 testexp
= eliminate_known_true (our_known_true
,
5005 XVECEXP (value
, 0, i
),
5006 insn_code
, insn_index
);
5007 newexp
= attr_rtx (NOT
, testexp
);
5008 newexp
= insert_right_side (AND
, our_known_true
, newexp
,
5009 insn_code
, insn_index
);
5011 /* If the test expression is always true or if the next `known_true'
5012 expression is always false, this is the last case, so break
5013 out and let this value be the `else' case. */
5014 if (testexp
== true_rtx
|| newexp
== false_rtx
)
5016 default_val
= XVECEXP (value
, 0, i
+ 1);
5020 /* Compute the expression to pass to our recursive call as being
5022 inner_true
= insert_right_side (AND
, our_known_true
,
5023 testexp
, insn_code
, insn_index
);
5025 /* If this is always false, skip it. */
5026 if (inner_true
== false_rtx
)
5029 write_indent (indent
);
5030 printf ("%sif ", first_if
? "" : "else ");
5032 write_test_expr (testexp
, 0);
5034 write_indent (indent
+ 2);
5037 write_attr_set (attr
, indent
+ 4,
5038 XVECEXP (value
, 0, i
+ 1), prefix
, suffix
,
5039 inner_true
, insn_code
, insn_index
);
5040 write_indent (indent
+ 2);
5042 our_known_true
= newexp
;
5047 write_indent (indent
);
5049 write_indent (indent
+ 2);
5053 write_attr_set (attr
, first_if
? indent
: indent
+ 4, default_val
,
5054 prefix
, suffix
, our_known_true
, insn_code
, insn_index
);
5058 write_indent (indent
+ 2);
5064 write_indent (indent
);
5065 printf ("%s ", prefix
);
5066 write_attr_value (attr
, value
);
5067 printf ("%s\n", suffix
);
5071 /* Write out the computation for one attribute value. */
5074 write_attr_case (attr
, av
, write_case_lines
, prefix
, suffix
, indent
,
5076 struct attr_desc
*attr
;
5077 struct attr_value
*av
;
5078 int write_case_lines
;
5079 const char *prefix
, *suffix
;
5083 struct insn_ent
*ie
;
5085 if (av
->num_insns
== 0)
5088 if (av
->has_asm_insn
)
5090 write_indent (indent
);
5091 printf ("case -1:\n");
5092 write_indent (indent
+ 2);
5093 printf ("if (GET_CODE (PATTERN (insn)) != ASM_INPUT\n");
5094 write_indent (indent
+ 2);
5095 printf (" && asm_noperands (PATTERN (insn)) < 0)\n");
5096 write_indent (indent
+ 2);
5097 printf (" fatal_insn_not_found (insn);\n");
5100 if (write_case_lines
)
5102 for (ie
= av
->first_insn
; ie
; ie
= ie
->next
)
5103 if (ie
->insn_code
!= -1)
5105 write_indent (indent
);
5106 printf ("case %d:\n", ie
->insn_code
);
5111 write_indent (indent
);
5112 printf ("default:\n");
5115 /* See what we have to do to output this value. */
5116 must_extract
= must_constrain
= address_used
= 0;
5117 walk_attr_value (av
->value
);
5121 write_indent (indent
+ 2);
5122 printf ("extract_insn (insn);\n");
5127 #ifdef REGISTER_CONSTRAINTS
5128 write_indent (indent
+ 2);
5129 printf ("if (! constrain_operands (reload_completed))\n");
5130 write_indent (indent
+ 2);
5131 printf (" fatal_insn_not_found (insn);\n");
5135 write_attr_set (attr
, indent
+ 2, av
->value
, prefix
, suffix
,
5136 known_true
, av
->first_insn
->insn_code
,
5137 av
->first_insn
->insn_index
);
5139 if (strncmp (prefix
, "return", 6))
5141 write_indent (indent
+ 2);
5142 printf ("break;\n");
5147 /* Search for uses of non-const attributes and write code to cache them. */
5150 write_expr_attr_cache (p
, attr
)
5152 struct attr_desc
*attr
;
5157 if (GET_CODE (p
) == EQ_ATTR
)
5159 if (XSTR (p
, 0) != attr
->name
)
5162 if (!attr
->is_numeric
)
5163 printf (" register enum attr_%s ", attr
->name
);
5164 else if (attr
->unsigned_p
)
5165 printf (" register unsigned int ");
5167 printf (" register int ");
5169 printf ("attr_%s = get_attr_%s (insn);\n", attr
->name
, attr
->name
);
5173 fmt
= GET_RTX_FORMAT (GET_CODE (p
));
5174 ie
= GET_RTX_LENGTH (GET_CODE (p
));
5175 for (i
= 0; i
< ie
; i
++)
5180 if (write_expr_attr_cache (XEXP (p
, i
), attr
))
5185 je
= XVECLEN (p
, i
);
5186 for (j
= 0; j
< je
; ++j
)
5187 if (write_expr_attr_cache (XVECEXP (p
, i
, j
), attr
))
5196 /* Evaluate an expression at top level. A front end to write_test_expr,
5197 in which we cache attribute values and break up excessively large
5198 expressions to cater to older compilers. */
5201 write_toplevel_expr (p
)
5204 struct attr_desc
*attr
;
5207 for (i
= 0; i
< MAX_ATTRS_INDEX
; ++i
)
5208 for (attr
= attrs
[i
]; attr
; attr
= attr
->next
)
5209 if (!attr
->is_const
)
5210 write_expr_attr_cache (p
, attr
);
5212 printf(" register unsigned long accum = 0;\n\n");
5214 while (GET_CODE (p
) == IOR
)
5217 if (GET_CODE (XEXP (p
, 0)) == IOR
)
5218 e
= XEXP (p
, 1), p
= XEXP (p
, 0);
5220 e
= XEXP (p
, 0), p
= XEXP (p
, 1);
5222 printf (" accum |= ");
5223 write_test_expr (e
, 3);
5226 printf (" accum |= ");
5227 write_test_expr (p
, 3);
5231 /* Utilities to write names in various forms. */
5234 write_unit_name (prefix
, num
, suffix
)
5239 struct function_unit
*unit
;
5241 for (unit
= units
; unit
; unit
= unit
->next
)
5242 if (unit
->num
== num
)
5244 printf ("%s%s%s", prefix
, unit
->name
, suffix
);
5248 printf ("%s<unknown>%s", prefix
, suffix
);
5252 write_attr_valueq (attr
, s
)
5253 struct attr_desc
*attr
;
5256 if (attr
->is_numeric
)
5262 /* Make the blockage range values and function units used values easier
5264 if (attr
->func_units_p
)
5267 printf (" /* units: none */");
5269 write_unit_name (" /* units: ", num
, " */");
5273 const char *sep
= " /* units: ";
5274 for (i
= 0, num
= ~num
; num
; i
++, num
>>= 1)
5277 write_unit_name (sep
, i
, (num
== 1) ? " */" : "");
5283 else if (attr
->blockage_p
)
5284 printf (" /* min %d, max %d */", num
>> (HOST_BITS_PER_INT
/ 2),
5285 num
& ((1 << (HOST_BITS_PER_INT
/ 2)) - 1));
5287 else if (num
> 9 || num
< 0)
5288 printf (" /* 0x%x */", num
);
5292 write_upcase (attr
->name
);
5299 write_attr_value (attr
, value
)
5300 struct attr_desc
*attr
;
5305 switch (GET_CODE (value
))
5308 write_attr_valueq (attr
, XSTR (value
, 0));
5312 fputs (XSTR (value
, 0), stdout
);
5317 struct attr_desc
*attr2
= find_attr (XSTR (value
, 0), 0);
5318 printf ("get_attr_%s (%s)", attr2
->name
,
5319 (attr2
->is_const
? "" : "insn"));
5340 write_attr_value (attr
, XEXP (value
, 0));
5344 write_attr_value (attr
, XEXP (value
, 1));
5358 printf ("%c", toupper(*str
++));
5360 printf ("%c", *str
++);
5364 write_indent (indent
)
5367 for (; indent
> 8; indent
-= 8)
5370 for (; indent
; indent
--)
5374 /* Write a subroutine that is given an insn that requires a delay slot, a
5375 delay slot ordinal, and a candidate insn. It returns non-zero if the
5376 candidate can be placed in the specified delay slot of the insn.
5378 We can write as many as three subroutines. `eligible_for_delay'
5379 handles normal delay slots, `eligible_for_annul_true' indicates that
5380 the specified insn can be annulled if the branch is true, and likewise
5381 for `eligible_for_annul_false'.
5383 KIND is a string distinguishing these three cases ("delay", "annul_true",
5384 or "annul_false"). */
5387 write_eligible_delay (kind
)
5390 struct delay_desc
*delay
;
5393 struct attr_desc
*attr
;
5394 struct attr_value
*av
, *common_av
;
5397 /* Compute the maximum number of delay slots required. We use the delay
5398 ordinal times this number plus one, plus the slot number as an index into
5399 the appropriate predicate to test. */
5401 for (delay
= delays
, max_slots
= 0; delay
; delay
= delay
->next
)
5402 if (XVECLEN (delay
->def
, 1) / 3 > max_slots
)
5403 max_slots
= XVECLEN (delay
->def
, 1) / 3;
5405 /* Write function prelude. */
5408 printf ("eligible_for_%s (delay_insn, slot, candidate_insn, flags)\n",
5410 printf (" rtx delay_insn;\n");
5411 printf (" int slot;\n");
5412 printf (" rtx candidate_insn;\n");
5413 printf (" int flags ATTRIBUTE_UNUSED;\n");
5415 printf (" rtx insn;\n");
5417 printf (" if (slot >= %d)\n", max_slots
);
5418 printf (" abort ();\n");
5421 /* If more than one delay type, find out which type the delay insn is. */
5425 attr
= find_attr ("*delay_type", 0);
5426 if (! attr
) abort ();
5427 common_av
= find_most_used (attr
);
5429 printf (" insn = delay_insn;\n");
5430 printf (" switch (recog_memoized (insn))\n");
5433 sprintf (str
, " * %d;\n break;", max_slots
);
5434 for (av
= attr
->first_value
; av
; av
= av
->next
)
5435 if (av
!= common_av
)
5436 write_attr_case (attr
, av
, 1, "slot +=", str
, 4, true_rtx
);
5438 write_attr_case (attr
, common_av
, 0, "slot +=", str
, 4, true_rtx
);
5441 /* Ensure matched. Otherwise, shouldn't have been called. */
5442 printf (" if (slot < %d)\n", max_slots
);
5443 printf (" abort ();\n\n");
5446 /* If just one type of delay slot, write simple switch. */
5447 if (num_delays
== 1 && max_slots
== 1)
5449 printf (" insn = candidate_insn;\n");
5450 printf (" switch (recog_memoized (insn))\n");
5453 attr
= find_attr ("*delay_1_0", 0);
5454 if (! attr
) abort ();
5455 common_av
= find_most_used (attr
);
5457 for (av
= attr
->first_value
; av
; av
= av
->next
)
5458 if (av
!= common_av
)
5459 write_attr_case (attr
, av
, 1, "return", ";", 4, true_rtx
);
5461 write_attr_case (attr
, common_av
, 0, "return", ";", 4, true_rtx
);
5467 /* Write a nested CASE. The first indicates which condition we need to
5468 test, and the inner CASE tests the condition. */
5469 printf (" insn = candidate_insn;\n");
5470 printf (" switch (slot)\n");
5473 for (delay
= delays
; delay
; delay
= delay
->next
)
5474 for (i
= 0; i
< XVECLEN (delay
->def
, 1); i
+= 3)
5476 printf (" case %d:\n",
5477 (i
/ 3) + (num_delays
== 1 ? 0 : delay
->num
* max_slots
));
5478 printf (" switch (recog_memoized (insn))\n");
5481 sprintf (str
, "*%s_%d_%d", kind
, delay
->num
, i
/ 3);
5482 attr
= find_attr (str
, 0);
5483 if (! attr
) abort ();
5484 common_av
= find_most_used (attr
);
5486 for (av
= attr
->first_value
; av
; av
= av
->next
)
5487 if (av
!= common_av
)
5488 write_attr_case (attr
, av
, 1, "return", ";", 8, true_rtx
);
5490 write_attr_case (attr
, common_av
, 0, "return", ";", 8, true_rtx
);
5494 printf (" default:\n");
5495 printf (" abort ();\n");
5502 /* Write routines to compute conflict cost for function units. Then write a
5503 table describing the available function units. */
5506 write_function_unit_info ()
5508 struct function_unit
*unit
;
5511 /* Write out conflict routines for function units. Don't bother writing
5512 one if there is only one issue delay value. */
5514 for (unit
= units
; unit
; unit
= unit
->next
)
5516 if (unit
->needs_blockage_function
)
5517 write_complex_function (unit
, "blockage", "block");
5519 /* If the minimum and maximum conflict costs are the same, there
5520 is only one value, so we don't need a function. */
5521 if (! unit
->needs_conflict_function
)
5523 unit
->default_cost
= make_numeric_value (unit
->issue_delay
.max
);
5527 /* The function first computes the case from the candidate insn. */
5528 unit
->default_cost
= make_numeric_value (0);
5529 write_complex_function (unit
, "conflict_cost", "cost");
5532 /* Now that all functions have been written, write the table describing
5533 the function units. The name is included for documentation purposes
5536 printf ("struct function_unit_desc function_units[] = {\n");
5538 /* Write out the descriptions in numeric order, but don't force that order
5539 on the list. Doing so increases the runtime of genattrtab.c. */
5540 for (i
= 0; i
< num_units
; i
++)
5542 for (unit
= units
; unit
; unit
= unit
->next
)
5546 printf (" {\"%s\", %d, %d, %d, %s, %d, %s_unit_ready_cost, ",
5547 unit
->name
, 1 << unit
->num
, unit
->multiplicity
,
5548 unit
->simultaneity
, XSTR (unit
->default_cost
, 0),
5549 unit
->issue_delay
.max
, unit
->name
);
5551 if (unit
->needs_conflict_function
)
5552 printf ("%s_unit_conflict_cost, ", unit
->name
);
5556 printf ("%d, ", unit
->max_blockage
);
5558 if (unit
->needs_range_function
)
5559 printf ("%s_unit_blockage_range, ", unit
->name
);
5563 if (unit
->needs_blockage_function
)
5564 printf ("%s_unit_blockage", unit
->name
);
5575 write_complex_function (unit
, name
, connection
)
5576 struct function_unit
*unit
;
5577 const char *name
, *connection
;
5579 struct attr_desc
*case_attr
, *attr
;
5580 struct attr_value
*av
, *common_av
;
5586 printf ("static int %s_unit_%s PROTO ((rtx, rtx));\n", unit
->name
, name
);
5587 printf ("static int\n");
5588 printf ("%s_unit_%s (executing_insn, candidate_insn)\n",
5590 printf (" rtx executing_insn;\n");
5591 printf (" rtx candidate_insn;\n");
5593 printf (" rtx insn;\n");
5594 printf (" int casenum;\n\n");
5595 printf (" insn = executing_insn;\n");
5596 printf (" switch (recog_memoized (insn))\n");
5599 /* Write the `switch' statement to get the case value. */
5600 str
= (char *) alloca (strlen (unit
->name
) + strlen (name
) + strlen (connection
) + 10);
5601 sprintf (str
, "*%s_cases", unit
->name
);
5602 case_attr
= find_attr (str
, 0);
5603 if (! case_attr
) abort ();
5604 common_av
= find_most_used (case_attr
);
5606 for (av
= case_attr
->first_value
; av
; av
= av
->next
)
5607 if (av
!= common_av
)
5608 write_attr_case (case_attr
, av
, 1,
5609 "casenum =", ";", 4, unit
->condexp
);
5611 write_attr_case (case_attr
, common_av
, 0,
5612 "casenum =", ";", 4, unit
->condexp
);
5615 /* Now write an outer switch statement on each case. Then write
5616 the tests on the executing function within each. */
5617 printf (" insn = candidate_insn;\n");
5618 printf (" switch (casenum)\n");
5621 for (i
= 0; i
< unit
->num_opclasses
; i
++)
5623 /* Ensure using this case. */
5625 for (av
= case_attr
->first_value
; av
; av
= av
->next
)
5627 && contained_in_p (make_numeric_value (i
), av
->value
))
5633 printf (" case %d:\n", i
);
5634 sprintf (str
, "*%s_%s_%d", unit
->name
, connection
, i
);
5635 attr
= find_attr (str
, 0);
5636 if (! attr
) abort ();
5638 /* If single value, just write it. */
5639 value
= find_single_value (attr
);
5641 write_attr_set (attr
, 6, value
, "return", ";\n", true_rtx
, -2, -2);
5644 common_av
= find_most_used (attr
);
5645 printf (" switch (recog_memoized (insn))\n");
5648 for (av
= attr
->first_value
; av
; av
= av
->next
)
5649 if (av
!= common_av
)
5650 write_attr_case (attr
, av
, 1,
5651 "return", ";", 8, unit
->condexp
);
5653 write_attr_case (attr
, common_av
, 0,
5654 "return", ";", 8, unit
->condexp
);
5659 /* This default case should not be needed, but gcc's analysis is not
5660 good enough to realize that the default case is not needed for the
5661 second switch statement. */
5662 printf (" default:\n abort ();\n");
5663 printf (" }\n}\n\n");
5666 /* This page contains miscellaneous utility routines. */
5668 /* Given a string, return the number of comma-separated elements in it.
5669 Return 0 for the null string. */
5680 for (n
= 1; *s
; s
++)
5687 /* Given a pointer to a (char *), return a malloc'ed string containing the
5688 next comma-separated element. Advance the pointer to after the string
5689 scanned, or the end-of-string. Return NULL if at end of string. */
5692 next_comma_elt (pstr
)
5701 /* Find end of string to compute length. */
5702 for (p
= *pstr
; *p
!= ',' && *p
!= '\0'; p
++)
5705 out_str
= attr_string (*pstr
, p
- *pstr
);
5714 /* Return a `struct attr_desc' pointer for a given named attribute. If CREATE
5715 is non-zero, build a new attribute, if one does not exist. */
5717 static struct attr_desc
*
5718 find_attr (name
, create
)
5722 struct attr_desc
*attr
;
5725 /* Before we resort to using `strcmp', see if the string address matches
5726 anywhere. In most cases, it should have been canonicalized to do so. */
5727 if (name
== alternative_name
)
5730 index
= name
[0] & (MAX_ATTRS_INDEX
- 1);
5731 for (attr
= attrs
[index
]; attr
; attr
= attr
->next
)
5732 if (name
== attr
->name
)
5735 /* Otherwise, do it the slow way. */
5736 for (attr
= attrs
[index
]; attr
; attr
= attr
->next
)
5737 if (name
[0] == attr
->name
[0] && ! strcmp (name
, attr
->name
))
5743 attr
= (struct attr_desc
*) oballoc (sizeof (struct attr_desc
));
5744 attr
->name
= attr_string (name
, strlen (name
));
5745 attr
->first_value
= attr
->default_val
= NULL
;
5746 attr
->is_numeric
= attr
->negative_ok
= attr
->is_const
= attr
->is_special
= 0;
5747 attr
->next
= attrs
[index
];
5748 attrs
[index
] = attr
;
5753 /* Create internal attribute with the given default value. */
5756 make_internal_attr (name
, value
, special
)
5761 struct attr_desc
*attr
;
5763 attr
= find_attr (name
, 1);
5764 if (attr
->default_val
)
5767 attr
->is_numeric
= 1;
5769 attr
->is_special
= (special
& 1) != 0;
5770 attr
->negative_ok
= (special
& 2) != 0;
5771 attr
->unsigned_p
= (special
& 4) != 0;
5772 attr
->func_units_p
= (special
& 8) != 0;
5773 attr
->blockage_p
= (special
& 16) != 0;
5774 attr
->default_val
= get_attr_value (value
, attr
, -2);
5777 /* Find the most used value of an attribute. */
5779 static struct attr_value
*
5780 find_most_used (attr
)
5781 struct attr_desc
*attr
;
5783 struct attr_value
*av
;
5784 struct attr_value
*most_used
;
5790 for (av
= attr
->first_value
; av
; av
= av
->next
)
5791 if (av
->num_insns
> nuses
)
5792 nuses
= av
->num_insns
, most_used
= av
;
5797 /* If an attribute only has a single value used, return it. Otherwise
5801 find_single_value (attr
)
5802 struct attr_desc
*attr
;
5804 struct attr_value
*av
;
5807 unique_value
= NULL
;
5808 for (av
= attr
->first_value
; av
; av
= av
->next
)
5814 unique_value
= av
->value
;
5817 return unique_value
;
5820 /* Return (attr_value "n") */
5823 make_numeric_value (n
)
5826 static rtx int_values
[20];
5833 if (n
< 20 && int_values
[n
])
5834 return int_values
[n
];
5836 p
= attr_printf (MAX_DIGITS
, "%d", n
);
5837 exp
= attr_rtx (CONST_STRING
, p
);
5840 int_values
[n
] = exp
;
5846 extend_range (range
, min
, max
)
5847 struct range
*range
;
5851 if (range
->min
> min
) range
->min
= min
;
5852 if (range
->max
< max
) range
->max
= max
;
5856 xrealloc (old
, size
)
5862 ptr
= (PTR
) realloc (old
, size
);
5864 ptr
= (PTR
) malloc (size
);
5866 fatal ("virtual memory exhausted");
5874 register PTR val
= (PTR
) malloc (size
);
5877 fatal ("virtual memory exhausted");
5882 copy_rtx_unchanging (orig
)
5887 register RTX_CODE code
;
5890 if (RTX_UNCHANGING_P (orig
) || MEM_IN_STRUCT_P (orig
))
5893 MEM_IN_STRUCT_P (orig
) = 1;
5897 code
= GET_CODE (orig
);
5910 copy
= rtx_alloc (code
);
5911 PUT_MODE (copy
, GET_MODE (orig
));
5912 RTX_UNCHANGING_P (copy
) = 1;
5914 bcopy ((char *) &XEXP (orig
, 0), (char *) &XEXP (copy
, 0),
5915 GET_RTX_LENGTH (GET_CODE (copy
)) * sizeof (rtx
));
5920 /* Determine if an insn has a constant number of delay slots, i.e., the
5921 number of delay slots is not a function of the length of the insn. */
5924 write_const_num_delay_slots ()
5926 struct attr_desc
*attr
= find_attr ("*num_delay_slots", 0);
5927 struct attr_value
*av
;
5928 struct insn_ent
*ie
;
5932 printf ("int\nconst_num_delay_slots (insn)\n");
5933 printf (" rtx insn;\n");
5935 printf (" switch (recog_memoized (insn))\n");
5938 for (av
= attr
->first_value
; av
; av
= av
->next
)
5941 walk_attr_value (av
->value
);
5944 for (ie
= av
->first_insn
; ie
; ie
= ie
->next
)
5945 if (ie
->insn_code
!= -1)
5946 printf (" case %d:\n", ie
->insn_code
);
5947 printf (" return 0;\n");
5951 printf (" default:\n");
5952 printf (" return 1;\n");
5953 printf (" }\n}\n\n");
5958 extern int main
PROTO ((int, char **));
5968 struct attr_desc
*attr
;
5969 struct insn_def
*id
;
5973 progname
= "genattrtab";
5975 #if defined (RLIMIT_STACK) && defined (HAVE_GETRLIMIT) && defined (HAVE_SETRLIMIT)
5976 /* Get rid of any avoidable limit on stack size. */
5980 /* Set the stack limit huge so that alloca does not fail. */
5981 getrlimit (RLIMIT_STACK
, &rlim
);
5982 rlim
.rlim_cur
= rlim
.rlim_max
;
5983 setrlimit (RLIMIT_STACK
, &rlim
);
5987 progname
= "genattrtab";
5988 obstack_init (rtl_obstack
);
5989 obstack_init (hash_obstack
);
5990 obstack_init (temp_obstack
);
5993 fatal ("No input file name.");
5995 infile
= fopen (argv
[1], "r");
5999 return (FATAL_EXIT_CODE
);
6002 /* Set up true and false rtx's */
6003 true_rtx
= rtx_alloc (CONST_INT
);
6004 XWINT (true_rtx
, 0) = 1;
6005 false_rtx
= rtx_alloc (CONST_INT
);
6006 XWINT (false_rtx
, 0) = 0;
6007 RTX_UNCHANGING_P (true_rtx
) = RTX_UNCHANGING_P (false_rtx
) = 1;
6008 RTX_INTEGRATED_P (true_rtx
) = RTX_INTEGRATED_P (false_rtx
) = 1;
6010 alternative_name
= attr_string ("alternative", strlen ("alternative"));
6012 printf ("/* Generated automatically by the program `genattrtab'\n\
6013 from the machine description file `md'. */\n\n");
6015 /* Read the machine description. */
6019 c
= read_skip_spaces (infile
);
6024 desc
= read_rtx (infile
);
6025 if (GET_CODE (desc
) == DEFINE_INSN
6026 || GET_CODE (desc
) == DEFINE_PEEPHOLE
6027 || GET_CODE (desc
) == DEFINE_ASM_ATTRIBUTES
)
6030 else if (GET_CODE (desc
) == DEFINE_EXPAND
)
6031 insn_code_number
++, insn_index_number
++;
6033 else if (GET_CODE (desc
) == DEFINE_SPLIT
)
6034 insn_code_number
++, insn_index_number
++;
6036 else if (GET_CODE (desc
) == DEFINE_PEEPHOLE2
)
6037 insn_code_number
++, insn_index_number
++;
6039 else if (GET_CODE (desc
) == DEFINE_ATTR
)
6042 insn_index_number
++;
6045 else if (GET_CODE (desc
) == DEFINE_DELAY
)
6048 insn_index_number
++;
6051 else if (GET_CODE (desc
) == DEFINE_FUNCTION_UNIT
)
6054 insn_index_number
++;
6058 /* If we didn't have a DEFINE_ASM_ATTRIBUTES, make a null one. */
6059 if (! got_define_asm_attributes
)
6061 tem
= rtx_alloc (DEFINE_ASM_ATTRIBUTES
);
6062 XVEC (tem
, 0) = rtvec_alloc (0);
6066 /* Expand DEFINE_DELAY information into new attribute. */
6070 /* Expand DEFINE_FUNCTION_UNIT information into new attributes. */
6074 printf ("#include \"config.h\"\n");
6075 printf ("#include \"system.h\"\n");
6076 printf ("#include \"rtl.h\"\n");
6077 printf ("#include \"insn-config.h\"\n");
6078 printf ("#include \"recog.h\"\n");
6079 printf ("#include \"regs.h\"\n");
6080 printf ("#include \"real.h\"\n");
6081 printf ("#include \"output.h\"\n");
6082 printf ("#include \"insn-attr.h\"\n");
6083 printf ("#include \"toplev.h\"\n");
6085 printf ("#define operands recog_data.operand\n\n");
6087 /* Make `insn_alternatives'. */
6088 insn_alternatives
= (int *) oballoc (insn_code_number
* sizeof (int));
6089 for (id
= defs
; id
; id
= id
->next
)
6090 if (id
->insn_code
>= 0)
6091 insn_alternatives
[id
->insn_code
] = (1 << id
->num_alternatives
) - 1;
6093 /* Make `insn_n_alternatives'. */
6094 insn_n_alternatives
= (int *) oballoc (insn_code_number
* sizeof (int));
6095 for (id
= defs
; id
; id
= id
->next
)
6096 if (id
->insn_code
>= 0)
6097 insn_n_alternatives
[id
->insn_code
] = id
->num_alternatives
;
6099 /* Prepare to write out attribute subroutines by checking everything stored
6100 away and building the attribute cases. */
6103 for (i
= 0; i
< MAX_ATTRS_INDEX
; i
++)
6104 for (attr
= attrs
[i
]; attr
; attr
= attr
->next
)
6106 attr
->default_val
->value
6107 = check_attr_value (attr
->default_val
->value
, attr
);
6111 /* Construct extra attributes for `length'. */
6112 make_length_attrs ();
6114 /* Perform any possible optimizations to speed up compilation. */
6117 /* Now write out all the `gen_attr_...' routines. Do these before the
6118 special routines (specifically before write_function_unit_info), so
6119 that they get defined before they are used. */
6121 for (i
= 0; i
< MAX_ATTRS_INDEX
; i
++)
6122 for (attr
= attrs
[i
]; attr
; attr
= attr
->next
)
6124 if (! attr
->is_special
&& ! attr
->is_const
)
6125 write_attr_get (attr
);
6128 /* Write out delay eligibility information, if DEFINE_DELAY present.
6129 (The function to compute the number of delay slots will be written
6133 write_eligible_delay ("delay");
6134 if (have_annul_true
)
6135 write_eligible_delay ("annul_true");
6136 if (have_annul_false
)
6137 write_eligible_delay ("annul_false");
6140 /* Write out information about function units. */
6142 write_function_unit_info ();
6144 /* Write out constant delay slot info */
6145 write_const_num_delay_slots ();
6147 write_length_unit_log ();
6150 return (ferror (stdout
) != 0 ? FATAL_EXIT_CODE
: SUCCESS_EXIT_CODE
);
6153 /* Define this so we can link with print-rtl.o to get debug_rtx function. */
6155 get_insn_name (code
)
6156 int code ATTRIBUTE_UNUSED
;