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 */
103 #ifdef HAVE_SYS_RESOURCE_H
104 # include <sys/resource.h>
107 /* We must include obstack.h after <sys/time.h>, to avoid lossage with
108 /usr/include/sys/stdtypes.h on Sun OS 4.x. */
111 static struct obstack obstack
, obstack1
, obstack2
;
112 struct obstack
*rtl_obstack
= &obstack
;
113 struct obstack
*hash_obstack
= &obstack1
;
114 struct obstack
*temp_obstack
= &obstack2
;
116 #define obstack_chunk_alloc xmalloc
117 #define obstack_chunk_free free
119 /* Define this so we can link with print-rtl.o to get debug_rtx function. */
120 char **insn_name_ptr
= 0;
122 void fatal
PVPROTO ((const char *, ...))
123 ATTRIBUTE_PRINTF_1 ATTRIBUTE_NORETURN
;
124 void fancy_abort
PROTO((void)) ATTRIBUTE_NORETURN
;
126 /* enough space to reserve for printing out ints */
127 #define MAX_DIGITS (HOST_BITS_PER_INT * 3 / 10 + 3)
129 /* Define structures used to record attributes and values. */
131 /* As each DEFINE_INSN, DEFINE_PEEPHOLE, or DEFINE_ASM_ATTRIBUTES is
132 encountered, we store all the relevant information into a
133 `struct insn_def'. This is done to allow attribute definitions to occur
134 anywhere in the file. */
138 int insn_code
; /* Instruction number. */
139 int insn_index
; /* Expression numer in file, for errors. */
140 struct insn_def
*next
; /* Next insn in chain. */
141 rtx def
; /* The DEFINE_... */
142 int num_alternatives
; /* Number of alternatives. */
143 int vec_idx
; /* Index of attribute vector in `def'. */
146 /* Once everything has been read in, we store in each attribute value a list
147 of insn codes that have that value. Here is the structure used for the
152 int insn_code
; /* Instruction number. */
153 int insn_index
; /* Index of definition in file */
154 struct insn_ent
*next
; /* Next in chain. */
157 /* Each value of an attribute (either constant or computed) is assigned a
158 structure which is used as the listhead of the insns that have that
163 rtx value
; /* Value of attribute. */
164 struct attr_value
*next
; /* Next attribute value in chain. */
165 struct insn_ent
*first_insn
; /* First insn with this value. */
166 int num_insns
; /* Number of insns with this value. */
167 int has_asm_insn
; /* True if this value used for `asm' insns */
170 /* Structure for each attribute. */
174 char *name
; /* Name of attribute. */
175 struct attr_desc
*next
; /* Next attribute. */
176 unsigned is_numeric
: 1; /* Values of this attribute are numeric. */
177 unsigned negative_ok
: 1; /* Allow negative numeric values. */
178 unsigned unsigned_p
: 1; /* Make the output function unsigned int. */
179 unsigned is_const
: 1; /* Attribute value constant for each run. */
180 unsigned is_special
: 1; /* Don't call `write_attr_set'. */
181 unsigned func_units_p
: 1; /* this is the function_units attribute */
182 unsigned blockage_p
: 1; /* this is the blockage range function */
183 struct attr_value
*first_value
; /* First value of this attribute. */
184 struct attr_value
*default_val
; /* Default value for this attribute. */
187 #define NULL_ATTR (struct attr_desc *) NULL
189 /* A range of values. */
197 /* Structure for each DEFINE_DELAY. */
201 rtx def
; /* DEFINE_DELAY expression. */
202 struct delay_desc
*next
; /* Next DEFINE_DELAY. */
203 int num
; /* Number of DEFINE_DELAY, starting at 1. */
206 /* Record information about each DEFINE_FUNCTION_UNIT. */
208 struct function_unit_op
210 rtx condexp
; /* Expression TRUE for applicable insn. */
211 struct function_unit_op
*next
; /* Next operation for this function unit. */
212 int num
; /* Ordinal for this operation type in unit. */
213 int ready
; /* Cost until data is ready. */
214 int issue_delay
; /* Cost until unit can accept another insn. */
215 rtx conflict_exp
; /* Expression TRUE for insns incurring issue delay. */
216 rtx issue_exp
; /* Expression computing issue delay. */
219 /* Record information about each function unit mentioned in a
220 DEFINE_FUNCTION_UNIT. */
224 char *name
; /* Function unit name. */
225 struct function_unit
*next
; /* Next function unit. */
226 int num
; /* Ordinal of this unit type. */
227 int multiplicity
; /* Number of units of this type. */
228 int simultaneity
; /* Maximum number of simultaneous insns
229 on this function unit or 0 if unlimited. */
230 rtx condexp
; /* Expression TRUE for insn needing unit. */
231 int num_opclasses
; /* Number of different operation types. */
232 struct function_unit_op
*ops
; /* Pointer to first operation type. */
233 int needs_conflict_function
; /* Nonzero if a conflict function required. */
234 int needs_blockage_function
; /* Nonzero if a blockage function required. */
235 int needs_range_function
; /* Nonzero if blockage range function needed.*/
236 rtx default_cost
; /* Conflict cost, if constant. */
237 struct range issue_delay
; /* Range of issue delay values. */
238 int max_blockage
; /* Maximum time an insn blocks the unit. */
241 /* Listheads of above structures. */
243 /* This one is indexed by the first character of the attribute name. */
244 #define MAX_ATTRS_INDEX 256
245 static struct attr_desc
*attrs
[MAX_ATTRS_INDEX
];
246 static struct insn_def
*defs
;
247 static struct delay_desc
*delays
;
248 static struct function_unit
*units
;
250 /* An expression where all the unknown terms are EQ_ATTR tests can be
251 rearranged into a COND provided we can enumerate all possible
252 combinations of the unknown values. The set of combinations become the
253 tests of the COND; the value of the expression given that combination is
254 computed and becomes the corresponding value. To do this, we must be
255 able to enumerate all values for each attribute used in the expression
256 (currently, we give up if we find a numeric attribute).
258 If the set of EQ_ATTR tests used in an expression tests the value of N
259 different attributes, the list of all possible combinations can be made
260 by walking the N-dimensional attribute space defined by those
261 attributes. We record each of these as a struct dimension.
263 The algorithm relies on sharing EQ_ATTR nodes: if two nodes in an
264 expression are the same, the will also have the same address. We find
265 all the EQ_ATTR nodes by marking them MEM_VOLATILE_P. This bit later
266 represents the value of an EQ_ATTR node, so once all nodes are marked,
267 they are also given an initial value of FALSE.
269 We then separate the set of EQ_ATTR nodes into dimensions for each
270 attribute and put them on the VALUES list. Terms are added as needed by
271 `add_values_to_cover' so that all possible values of the attribute are
274 Each dimension also has a current value. This is the node that is
275 currently considered to be TRUE. If this is one of the nodes added by
276 `add_values_to_cover', all the EQ_ATTR tests in the original expression
277 will be FALSE. Otherwise, only the CURRENT_VALUE will be true.
279 NUM_VALUES is simply the length of the VALUES list and is there for
282 Once the dimensions are created, the algorithm enumerates all possible
283 values and computes the current value of the given expression. */
287 struct attr_desc
*attr
; /* Attribute for this dimension. */
288 rtx values
; /* List of attribute values used. */
289 rtx current_value
; /* Position in the list for the TRUE value. */
290 int num_values
; /* Length of the values list. */
293 /* Other variables. */
295 static int insn_code_number
;
296 static int insn_index_number
;
297 static int got_define_asm_attributes
;
298 static int must_extract
;
299 static int must_constrain
;
300 static int address_used
;
301 static int length_used
;
302 static int num_delays
;
303 static int have_annul_true
, have_annul_false
;
304 static int num_units
, num_unit_opclasses
;
305 static int num_insn_ents
;
307 /* Used as operand to `operate_exp': */
309 enum operator {PLUS_OP
, MINUS_OP
, POS_MINUS_OP
, EQ_OP
, OR_OP
, ORX_OP
, MAX_OP
, MIN_OP
, RANGE_OP
};
311 /* Stores, for each insn code, the number of constraint alternatives. */
313 static int *insn_n_alternatives
;
315 /* Stores, for each insn code, a bitmap that has bits on for each possible
318 static int *insn_alternatives
;
320 /* If nonzero, assume that the `alternative' attr has this value.
321 This is the hashed, unique string for the numeral
322 whose value is chosen alternative. */
324 static char *current_alternative_string
;
326 /* Used to simplify expressions. */
328 static rtx true_rtx
, false_rtx
;
330 /* Used to reduce calls to `strcmp' */
332 static char *alternative_name
;
334 /* Indicate that REG_DEAD notes are valid if dead_or_set_p is ever
337 int reload_completed
= 0;
339 /* Some machines test `optimize' in macros called from rtlanal.c, so we need
340 to define it here. */
344 /* Simplify an expression. Only call the routine if there is something to
346 #define SIMPLIFY_TEST_EXP(EXP,INSN_CODE,INSN_INDEX) \
347 (RTX_UNCHANGING_P (EXP) || MEM_IN_STRUCT_P (EXP) ? (EXP) \
348 : simplify_test_exp (EXP, INSN_CODE, INSN_INDEX))
350 /* Simplify (eq_attr ("alternative") ...)
351 when we are working with a particular alternative. */
352 #define SIMPLIFY_ALTERNATIVE(EXP) \
353 if (current_alternative_string \
354 && GET_CODE ((EXP)) == EQ_ATTR \
355 && XSTR ((EXP), 0) == alternative_name) \
356 (EXP) = (XSTR ((EXP), 1) == current_alternative_string \
357 ? true_rtx : false_rtx);
359 /* These are referenced by rtlanal.c and hence need to be defined somewhere.
360 They won't actually be used. */
362 struct _global_rtl global_rtl
;
363 rtx pic_offset_table_rtx
;
365 static void attr_hash_add_rtx
PROTO((int, rtx
));
366 static void attr_hash_add_string
PROTO((int, char *));
367 static rtx attr_rtx
PVPROTO((enum rtx_code
, ...));
368 static char *attr_printf
PVPROTO((int, const char *, ...))
370 static char *attr_string
PROTO((const char *, int));
371 static rtx check_attr_test
PROTO((rtx
, int));
372 static rtx check_attr_value
PROTO((rtx
, struct attr_desc
*));
373 static rtx convert_set_attr_alternative
PROTO((rtx
, int, int));
374 static rtx convert_set_attr
PROTO((rtx
, int, int));
375 static void check_defs
PROTO((void));
377 static rtx convert_const_symbol_ref
PROTO((rtx
, struct attr_desc
*));
379 static rtx make_canonical
PROTO((struct attr_desc
*, rtx
));
380 static struct attr_value
*get_attr_value
PROTO((rtx
, struct attr_desc
*, int));
381 static rtx copy_rtx_unchanging
PROTO((rtx
));
382 static rtx copy_boolean
PROTO((rtx
));
383 static void expand_delays
PROTO((void));
384 static rtx operate_exp
PROTO((enum operator, rtx
, rtx
));
385 static void expand_units
PROTO((void));
386 static rtx simplify_knowing
PROTO((rtx
, rtx
));
387 static rtx encode_units_mask
PROTO((rtx
));
388 static void fill_attr
PROTO((struct attr_desc
*));
389 /* dpx2 compiler chokes if we specify the arg types of the args. */
390 static rtx substitute_address
PROTO((rtx
, rtx (*) (), rtx (*) ()));
391 static void make_length_attrs
PROTO((void));
392 static rtx identity_fn
PROTO((rtx
));
393 static rtx zero_fn
PROTO((rtx
));
394 static rtx one_fn
PROTO((rtx
));
395 static rtx max_fn
PROTO((rtx
));
396 static void write_length_unit_log
PROTO ((void));
397 static rtx simplify_cond
PROTO((rtx
, int, int));
399 static rtx simplify_by_alternatives
PROTO((rtx
, int, int));
401 static rtx simplify_by_exploding
PROTO((rtx
));
402 static int find_and_mark_used_attributes
PROTO((rtx
, rtx
*, int *));
403 static void unmark_used_attributes
PROTO((rtx
, struct dimension
*, int));
404 static int add_values_to_cover
PROTO((struct dimension
*));
405 static int increment_current_value
PROTO((struct dimension
*, int));
406 static rtx test_for_current_value
PROTO((struct dimension
*, int));
407 static rtx simplify_with_current_value
PROTO((rtx
, struct dimension
*, int));
408 static rtx simplify_with_current_value_aux
PROTO((rtx
));
409 static void clear_struct_flag
PROTO((rtx
));
410 static int count_sub_rtxs
PROTO((rtx
, int));
411 static void remove_insn_ent
PROTO((struct attr_value
*, struct insn_ent
*));
412 static void insert_insn_ent
PROTO((struct attr_value
*, struct insn_ent
*));
413 static rtx insert_right_side
PROTO((enum rtx_code
, rtx
, rtx
, int, int));
414 static rtx make_alternative_compare
PROTO((int));
415 static int compute_alternative_mask
PROTO((rtx
, enum rtx_code
));
416 static rtx evaluate_eq_attr
PROTO((rtx
, rtx
, int, int));
417 static rtx simplify_and_tree
PROTO((rtx
, rtx
*, int, int));
418 static rtx simplify_or_tree
PROTO((rtx
, rtx
*, int, int));
419 static rtx simplify_test_exp
PROTO((rtx
, int, int));
420 static void optimize_attrs
PROTO((void));
421 static void gen_attr
PROTO((rtx
));
422 static int count_alternatives
PROTO((rtx
));
423 static int compares_alternatives_p
PROTO((rtx
));
424 static int contained_in_p
PROTO((rtx
, rtx
));
425 static void gen_insn
PROTO((rtx
));
426 static void gen_delay
PROTO((rtx
));
427 static void gen_unit
PROTO((rtx
));
428 static void write_test_expr
PROTO((rtx
, int));
429 static int max_attr_value
PROTO((rtx
, int*));
430 static int or_attr_value
PROTO((rtx
, int*));
431 static void walk_attr_value
PROTO((rtx
));
432 static void write_attr_get
PROTO((struct attr_desc
*));
433 static rtx eliminate_known_true
PROTO((rtx
, rtx
, int, int));
434 static void write_attr_set
PROTO((struct attr_desc
*, int, rtx
,
435 const char *, const char *, rtx
,
437 static void write_attr_case
PROTO((struct attr_desc
*, struct attr_value
*,
438 int, const char *, const char *, int, rtx
));
439 static void write_unit_name
PROTO((const char *, int, const char *));
440 static void write_attr_valueq
PROTO((struct attr_desc
*, char *));
441 static void write_attr_value
PROTO((struct attr_desc
*, rtx
));
442 static void write_upcase
PROTO((char *));
443 static void write_indent
PROTO((int));
444 static void write_eligible_delay
PROTO((const char *));
445 static void write_function_unit_info
PROTO((void));
446 static void write_complex_function
PROTO((struct function_unit
*, const char *,
448 static int write_expr_attr_cache
PROTO((rtx
, struct attr_desc
*));
449 static void write_toplevel_expr
PROTO((rtx
));
450 static int n_comma_elts
PROTO((char *));
451 static char *next_comma_elt
PROTO((char **));
452 static struct attr_desc
*find_attr
PROTO((const char *, int));
453 static void make_internal_attr
PROTO((const char *, rtx
, int));
454 static struct attr_value
*find_most_used
PROTO((struct attr_desc
*));
455 static rtx find_single_value
PROTO((struct attr_desc
*));
456 static rtx make_numeric_value
PROTO((int));
457 static void extend_range
PROTO((struct range
*, int, int));
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 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 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
++)
1357 if (*p
>= 'a' && *p
<= 'z')
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. */
1727 obstack_free (rtl_obstack
, newexp
);
1728 return operate_exp (op
, left
, XEXP (right
, 1));
1731 /* If the result is the same as the RIGHT operand,
1733 if (rtx_equal_p (newexp
, right
))
1735 obstack_free (rtl_obstack
, newexp
);
1742 fatal ("Badly formed attribute value");
1745 /* A hack to prevent expand_units from completely blowing up: ORX_OP does
1746 not associate through IF_THEN_ELSE. */
1747 else if (op
== ORX_OP
&& GET_CODE (right
) == IF_THEN_ELSE
)
1749 return attr_rtx (IOR
, left
, right
);
1752 /* Otherwise, do recursion the other way. */
1753 else if (GET_CODE (left
) == IF_THEN_ELSE
)
1755 rtx newleft
= operate_exp (op
, XEXP (left
, 1), right
);
1756 rtx newright
= operate_exp (op
, XEXP (left
, 2), right
);
1757 if (rtx_equal_p (newleft
, newright
))
1759 return attr_rtx (IF_THEN_ELSE
, XEXP (left
, 0), newleft
, newright
);
1761 else if (GET_CODE (left
) == COND
)
1766 newexp
= rtx_alloc (COND
);
1767 XVEC (newexp
, 0) = rtvec_alloc (XVECLEN (left
, 0));
1768 defval
= XEXP (newexp
, 1) = operate_exp (op
, XEXP (left
, 1), right
);
1770 for (i
= 0; i
< XVECLEN (left
, 0); i
+= 2)
1772 XVECEXP (newexp
, 0, i
) = XVECEXP (left
, 0, i
);
1773 XVECEXP (newexp
, 0, i
+ 1)
1774 = operate_exp (op
, XVECEXP (left
, 0, i
+ 1), right
);
1775 if (! rtx_equal_p (XVECEXP (newexp
, 0, i
+ 1),
1780 /* If the cond is trivial (all alternatives give the same value),
1781 optimize it away. */
1784 obstack_free (rtl_obstack
, newexp
);
1785 return operate_exp (op
, XEXP (left
, 1), right
);
1788 /* If the result is the same as the LEFT operand,
1790 if (rtx_equal_p (newexp
, left
))
1792 obstack_free (rtl_obstack
, newexp
);
1800 fatal ("Badly formed attribute value.");
1805 /* Once all attributes and DEFINE_FUNCTION_UNITs have been read, we
1806 construct a number of attributes.
1808 The first produces a function `function_units_used' which is given an
1809 insn and produces an encoding showing which function units are required
1810 for the execution of that insn. If the value is non-negative, the insn
1811 uses that unit; otherwise, the value is a one's compliment mask of units
1814 The second produces a function `result_ready_cost' which is used to
1815 determine the time that the result of an insn will be ready and hence
1816 a worst-case schedule.
1818 Both of these produce quite complex expressions which are then set as the
1819 default value of internal attributes. Normal attribute simplification
1820 should produce reasonable expressions.
1822 For each unit, a `<name>_unit_ready_cost' function will take an
1823 insn and give the delay until that unit will be ready with the result
1824 and a `<name>_unit_conflict_cost' function is given an insn already
1825 executing on the unit and a candidate to execute and will give the
1826 cost from the time the executing insn started until the candidate
1827 can start (ignore limitations on the number of simultaneous insns).
1829 For each unit, a `<name>_unit_blockage' function is given an insn
1830 already executing on the unit and a candidate to execute and will
1831 give the delay incurred due to function unit conflicts. The range of
1832 blockage cost values for a given executing insn is given by the
1833 `<name>_unit_blockage_range' function. These values are encoded in
1834 an int where the upper half gives the minimum value and the lower
1835 half gives the maximum value. */
1840 struct function_unit
*unit
, **unit_num
;
1841 struct function_unit_op
*op
, **op_array
, ***unit_ops
;
1846 int i
, j
, u
, num
, nvalues
;
1848 /* Rebuild the condition for the unit to share the RTL expressions.
1849 Sharing is required by simplify_by_exploding. Build the issue delay
1850 expressions. Validate the expressions we were given for the conditions
1851 and conflict vector. Then make attributes for use in the conflict
1854 for (unit
= units
; unit
; unit
= unit
->next
)
1856 unit
->condexp
= check_attr_test (unit
->condexp
, 0);
1858 for (op
= unit
->ops
; op
; op
= op
->next
)
1860 rtx issue_delay
= make_numeric_value (op
->issue_delay
);
1861 rtx issue_exp
= issue_delay
;
1863 /* Build, validate, and simplify the issue delay expression. */
1864 if (op
->conflict_exp
!= true_rtx
)
1865 issue_exp
= attr_rtx (IF_THEN_ELSE
, op
->conflict_exp
,
1866 issue_exp
, make_numeric_value (0));
1867 issue_exp
= check_attr_value (make_canonical (NULL_ATTR
,
1870 issue_exp
= simplify_knowing (issue_exp
, unit
->condexp
);
1871 op
->issue_exp
= issue_exp
;
1873 /* Make an attribute for use in the conflict function if needed. */
1874 unit
->needs_conflict_function
= (unit
->issue_delay
.min
1875 != unit
->issue_delay
.max
);
1876 if (unit
->needs_conflict_function
)
1878 str
= attr_printf (strlen (unit
->name
) + sizeof ("*_cost_") + MAX_DIGITS
,
1879 "*%s_cost_%d", unit
->name
, op
->num
);
1880 make_internal_attr (str
, issue_exp
, 1);
1883 /* Validate the condition. */
1884 op
->condexp
= check_attr_test (op
->condexp
, 0);
1888 /* Compute the mask of function units used. Initially, the unitsmask is
1889 zero. Set up a conditional to compute each unit's contribution. */
1890 unitsmask
= make_numeric_value (0);
1891 newexp
= rtx_alloc (IF_THEN_ELSE
);
1892 XEXP (newexp
, 2) = make_numeric_value (0);
1894 /* If we have just a few units, we may be all right expanding the whole
1895 thing. But the expansion is 2**N in space on the number of opclasses,
1896 so we can't do this for very long -- Alpha and MIPS in particular have
1897 problems with this. So in that situation, we fall back on an alternate
1898 implementation method. */
1899 #define NUM_UNITOP_CUTOFF 20
1901 if (num_unit_opclasses
< NUM_UNITOP_CUTOFF
)
1903 /* Merge each function unit into the unit mask attributes. */
1904 for (unit
= units
; unit
; unit
= unit
->next
)
1906 XEXP (newexp
, 0) = unit
->condexp
;
1907 XEXP (newexp
, 1) = make_numeric_value (1 << unit
->num
);
1908 unitsmask
= operate_exp (OR_OP
, unitsmask
, newexp
);
1913 /* Merge each function unit into the unit mask attributes. */
1914 for (unit
= units
; unit
; unit
= unit
->next
)
1916 XEXP (newexp
, 0) = unit
->condexp
;
1917 XEXP (newexp
, 1) = make_numeric_value (1 << unit
->num
);
1918 unitsmask
= operate_exp (ORX_OP
, unitsmask
, attr_copy_rtx (newexp
));
1922 /* Simplify the unit mask expression, encode it, and make an attribute
1923 for the function_units_used function. */
1924 unitsmask
= simplify_by_exploding (unitsmask
);
1926 if (num_unit_opclasses
< NUM_UNITOP_CUTOFF
)
1927 unitsmask
= encode_units_mask (unitsmask
);
1930 /* We can no longer encode unitsmask at compile time, so emit code to
1931 calculate it at runtime. Rather, put a marker for where we'd do
1932 the code, and actually output it in write_attr_get(). */
1933 unitsmask
= attr_rtx (FFS
, unitsmask
);
1936 make_internal_attr ("*function_units_used", unitsmask
, 10);
1938 /* Create an array of ops for each unit. Add an extra unit for the
1939 result_ready_cost function that has the ops of all other units. */
1940 unit_ops
= (struct function_unit_op
***)
1941 alloca ((num_units
+ 1) * sizeof (struct function_unit_op
**));
1942 unit_num
= (struct function_unit
**)
1943 alloca ((num_units
+ 1) * sizeof (struct function_unit
*));
1945 unit_num
[num_units
] = unit
= (struct function_unit
*)
1946 alloca (sizeof (struct function_unit
));
1947 unit
->num
= num_units
;
1948 unit
->num_opclasses
= 0;
1950 for (unit
= units
; unit
; unit
= unit
->next
)
1952 unit_num
[num_units
]->num_opclasses
+= unit
->num_opclasses
;
1953 unit_num
[unit
->num
] = unit
;
1954 unit_ops
[unit
->num
] = op_array
= (struct function_unit_op
**)
1955 alloca (unit
->num_opclasses
* sizeof (struct function_unit_op
*));
1957 for (op
= unit
->ops
; op
; op
= op
->next
)
1958 op_array
[op
->num
] = op
;
1961 /* Compose the array of ops for the extra unit. */
1962 unit_ops
[num_units
] = op_array
= (struct function_unit_op
**)
1963 alloca (unit_num
[num_units
]->num_opclasses
1964 * sizeof (struct function_unit_op
*));
1966 for (unit
= units
, i
= 0; unit
; i
+= unit
->num_opclasses
, unit
= unit
->next
)
1967 bcopy ((char *) unit_ops
[unit
->num
], (char *) &op_array
[i
],
1968 unit
->num_opclasses
* sizeof (struct function_unit_op
*));
1970 /* Compute the ready cost function for each unit by computing the
1971 condition for each non-default value. */
1972 for (u
= 0; u
<= num_units
; u
++)
1978 op_array
= unit_ops
[unit
->num
];
1979 num
= unit
->num_opclasses
;
1981 /* Sort the array of ops into increasing ready cost order. */
1982 for (i
= 0; i
< num
; i
++)
1983 for (j
= num
- 1; j
> i
; j
--)
1984 if (op_array
[j
-1]->ready
< op_array
[j
]->ready
)
1987 op_array
[j
] = op_array
[j
-1];
1991 /* Determine how many distinct non-default ready cost values there
1992 are. We use a default ready cost value of 1. */
1993 nvalues
= 0; value
= 1;
1994 for (i
= num
- 1; i
>= 0; i
--)
1995 if (op_array
[i
]->ready
> value
)
1997 value
= op_array
[i
]->ready
;
2002 readycost
= make_numeric_value (1);
2005 /* Construct the ready cost expression as a COND of each value from
2006 the largest to the smallest. */
2007 readycost
= rtx_alloc (COND
);
2008 XVEC (readycost
, 0) = rtvec_alloc (nvalues
* 2);
2009 XEXP (readycost
, 1) = make_numeric_value (1);
2011 nvalues
= 0; orexp
= false_rtx
; value
= op_array
[0]->ready
;
2012 for (i
= 0; i
< num
; i
++)
2017 else if (op
->ready
== value
)
2018 orexp
= insert_right_side (IOR
, orexp
, op
->condexp
, -2, -2);
2021 XVECEXP (readycost
, 0, nvalues
* 2) = orexp
;
2022 XVECEXP (readycost
, 0, nvalues
* 2 + 1)
2023 = make_numeric_value (value
);
2026 orexp
= op
->condexp
;
2029 XVECEXP (readycost
, 0, nvalues
* 2) = orexp
;
2030 XVECEXP (readycost
, 0, nvalues
* 2 + 1) = make_numeric_value (value
);
2035 rtx max_blockage
= 0, min_blockage
= 0;
2037 /* Simplify the readycost expression by only considering insns
2038 that use the unit. */
2039 readycost
= simplify_knowing (readycost
, unit
->condexp
);
2041 /* Determine the blockage cost the executing insn (E) given
2042 the candidate insn (C). This is the maximum of the issue
2043 delay, the pipeline delay, and the simultaneity constraint.
2044 Each function_unit_op represents the characteristics of the
2045 candidate insn, so in the expressions below, C is a known
2046 term and E is an unknown term.
2048 We compute the blockage cost for each E for every possible C.
2049 Thus OP represents E, and READYCOST is a list of values for
2052 The issue delay function for C is op->issue_exp and is used to
2053 write the `<name>_unit_conflict_cost' function. Symbolicly
2054 this is "ISSUE-DELAY (E,C)".
2056 The pipeline delay results form the FIFO constraint on the
2057 function unit and is "READY-COST (E) + 1 - READY-COST (C)".
2059 The simultaneity constraint is based on how long it takes to
2060 fill the unit given the minimum issue delay. FILL-TIME is the
2061 constant "MIN (ISSUE-DELAY (*,*)) * (SIMULTANEITY - 1)", and
2062 the simultaneity constraint is "READY-COST (E) - FILL-TIME"
2063 if SIMULTANEITY is non-zero and zero otherwise.
2065 Thus, BLOCKAGE (E,C) when SIMULTANEITY is zero is
2067 MAX (ISSUE-DELAY (E,C),
2068 READY-COST (E) - (READY-COST (C) - 1))
2072 MAX (ISSUE-DELAY (E,C),
2073 READY-COST (E) - (READY-COST (C) - 1),
2074 READY-COST (E) - FILL-TIME)
2076 The `<name>_unit_blockage' function is computed by determining
2077 this value for each candidate insn. As these values are
2078 computed, we also compute the upper and lower bounds for
2079 BLOCKAGE (E,*). These are combined to form the function
2080 `<name>_unit_blockage_range'. Finally, the maximum blockage
2081 cost, MAX (BLOCKAGE (*,*)), is computed. */
2083 for (op
= unit
->ops
; op
; op
= op
->next
)
2086 rtx blockage
= op
->issue_exp
;
2088 rtx blockage
= operate_exp (POS_MINUS_OP
, readycost
,
2089 make_numeric_value (1));
2091 if (unit
->simultaneity
!= 0)
2093 rtx filltime
= make_numeric_value ((unit
->simultaneity
- 1)
2094 * unit
->issue_delay
.min
);
2095 blockage
= operate_exp (MIN_OP
, blockage
, filltime
);
2098 blockage
= operate_exp (POS_MINUS_OP
,
2099 make_numeric_value (op
->ready
),
2102 blockage
= operate_exp (MAX_OP
, blockage
, op
->issue_exp
);
2104 blockage
= simplify_knowing (blockage
, unit
->condexp
);
2106 /* Add this op's contribution to MAX (BLOCKAGE (E,*)) and
2107 MIN (BLOCKAGE (E,*)). */
2108 if (max_blockage
== 0)
2109 max_blockage
= min_blockage
= blockage
;
2113 = simplify_knowing (operate_exp (MAX_OP
, max_blockage
,
2117 = simplify_knowing (operate_exp (MIN_OP
, min_blockage
,
2122 /* Make an attribute for use in the blockage function. */
2123 str
= attr_printf (strlen (unit
->name
) + sizeof ("*_block_") + MAX_DIGITS
,
2124 "*%s_block_%d", unit
->name
, op
->num
);
2125 make_internal_attr (str
, blockage
, 1);
2128 /* Record MAX (BLOCKAGE (*,*)). */
2131 unit
->max_blockage
= max_attr_value (max_blockage
, &unknown
);
2134 /* See if the upper and lower bounds of BLOCKAGE (E,*) are the
2135 same. If so, the blockage function carries no additional
2136 information and is not written. */
2137 newexp
= operate_exp (EQ_OP
, max_blockage
, min_blockage
);
2138 newexp
= simplify_knowing (newexp
, unit
->condexp
);
2139 unit
->needs_blockage_function
2140 = (GET_CODE (newexp
) != CONST_STRING
2141 || atoi (XSTR (newexp
, 0)) != 1);
2143 /* If the all values of BLOCKAGE (E,C) have the same value,
2144 neither blockage function is written. */
2145 unit
->needs_range_function
2146 = (unit
->needs_blockage_function
2147 || GET_CODE (max_blockage
) != CONST_STRING
);
2149 if (unit
->needs_range_function
)
2151 /* Compute the blockage range function and make an attribute
2152 for writing its value. */
2153 newexp
= operate_exp (RANGE_OP
, min_blockage
, max_blockage
);
2154 newexp
= simplify_knowing (newexp
, unit
->condexp
);
2156 str
= attr_printf (strlen (unit
->name
) + sizeof ("*_unit_blockage_range"),
2157 "*%s_unit_blockage_range", unit
->name
);
2158 make_internal_attr (str
, newexp
, 20);
2161 str
= attr_printf (strlen (unit
->name
) + sizeof ("*_unit_ready_cost"),
2162 "*%s_unit_ready_cost", unit
->name
);
2165 str
= "*result_ready_cost";
2167 /* Make an attribute for the ready_cost function. Simplifying
2168 further with simplify_by_exploding doesn't win. */
2169 make_internal_attr (str
, readycost
, 0);
2172 /* For each unit that requires a conflict cost function, make an attribute
2173 that maps insns to the operation number. */
2174 for (unit
= units
; unit
; unit
= unit
->next
)
2178 if (! unit
->needs_conflict_function
2179 && ! unit
->needs_blockage_function
)
2182 caseexp
= rtx_alloc (COND
);
2183 XVEC (caseexp
, 0) = rtvec_alloc ((unit
->num_opclasses
- 1) * 2);
2185 for (op
= unit
->ops
; op
; op
= op
->next
)
2187 /* Make our adjustment to the COND being computed. If we are the
2188 last operation class, place our values into the default of the
2190 if (op
->num
== unit
->num_opclasses
- 1)
2192 XEXP (caseexp
, 1) = make_numeric_value (op
->num
);
2196 XVECEXP (caseexp
, 0, op
->num
* 2) = op
->condexp
;
2197 XVECEXP (caseexp
, 0, op
->num
* 2 + 1)
2198 = make_numeric_value (op
->num
);
2202 /* Simplifying caseexp with simplify_by_exploding doesn't win. */
2203 str
= attr_printf (strlen (unit
->name
) + sizeof ("*_cases"),
2204 "*%s_cases", unit
->name
);
2205 make_internal_attr (str
, caseexp
, 1);
2209 /* Simplify EXP given KNOWN_TRUE. */
2212 simplify_knowing (exp
, known_true
)
2213 rtx exp
, known_true
;
2215 if (GET_CODE (exp
) != CONST_STRING
)
2217 int unknown
= 0, max
;
2218 max
= max_attr_value (exp
, &unknown
);
2221 exp
= attr_rtx (IF_THEN_ELSE
, known_true
, exp
,
2222 make_numeric_value (max
));
2223 exp
= simplify_by_exploding (exp
);
2229 /* Translate the CONST_STRING expressions in X to change the encoding of
2230 value. On input, the value is a bitmask with a one bit for each unit
2231 used; on output, the value is the unit number (zero based) if one
2232 and only one unit is used or the one's compliment of the bitmask. */
2235 encode_units_mask (x
)
2240 register enum rtx_code code
;
2243 code
= GET_CODE (x
);
2248 i
= atoi (XSTR (x
, 0));
2250 abort (); /* The sign bit encodes a one's compliment mask. */
2251 else if (i
!= 0 && i
== (i
& -i
))
2252 /* Only one bit is set, so yield that unit number. */
2253 for (j
= 0; (i
>>= 1) != 0; j
++)
2257 return attr_rtx (CONST_STRING
, attr_printf (MAX_DIGITS
, "%d", j
));
2274 /* Compare the elements. If any pair of corresponding elements
2275 fail to match, return 0 for the whole things. */
2277 fmt
= GET_RTX_FORMAT (code
);
2278 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
2284 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
2285 XVECEXP (x
, i
, j
) = encode_units_mask (XVECEXP (x
, i
, j
));
2289 XEXP (x
, i
) = encode_units_mask (XEXP (x
, i
));
2296 /* Once all attributes and insns have been read and checked, we construct for
2297 each attribute value a list of all the insns that have that value for
2302 struct attr_desc
*attr
;
2304 struct attr_value
*av
;
2305 struct insn_ent
*ie
;
2306 struct insn_def
*id
;
2310 /* Don't fill constant attributes. The value is independent of
2311 any particular insn. */
2315 for (id
= defs
; id
; id
= id
->next
)
2317 /* If no value is specified for this insn for this attribute, use the
2320 if (XVEC (id
->def
, id
->vec_idx
))
2321 for (i
= 0; i
< XVECLEN (id
->def
, id
->vec_idx
); i
++)
2322 if (! strcmp (XSTR (XEXP (XVECEXP (id
->def
, id
->vec_idx
, i
), 0), 0),
2324 value
= XEXP (XVECEXP (id
->def
, id
->vec_idx
, i
), 1);
2327 av
= attr
->default_val
;
2329 av
= get_attr_value (value
, attr
, id
->insn_code
);
2331 ie
= (struct insn_ent
*) oballoc (sizeof (struct insn_ent
));
2332 ie
->insn_code
= id
->insn_code
;
2333 ie
->insn_index
= id
->insn_code
;
2334 insert_insn_ent (av
, ie
);
2338 /* Given an expression EXP, see if it is a COND or IF_THEN_ELSE that has a
2339 test that checks relative positions of insns (uses MATCH_DUP or PC).
2340 If so, replace it with what is obtained by passing the expression to
2341 ADDRESS_FN. If not but it is a COND or IF_THEN_ELSE, call this routine
2342 recursively on each value (including the default value). Otherwise,
2343 return the value returned by NO_ADDRESS_FN applied to EXP. */
2346 substitute_address (exp
, no_address_fn
, address_fn
)
2348 rtx (*no_address_fn
) ();
2349 rtx (*address_fn
) ();
2354 if (GET_CODE (exp
) == COND
)
2356 /* See if any tests use addresses. */
2358 for (i
= 0; i
< XVECLEN (exp
, 0); i
+= 2)
2359 walk_attr_value (XVECEXP (exp
, 0, i
));
2362 return (*address_fn
) (exp
);
2364 /* Make a new copy of this COND, replacing each element. */
2365 newexp
= rtx_alloc (COND
);
2366 XVEC (newexp
, 0) = rtvec_alloc (XVECLEN (exp
, 0));
2367 for (i
= 0; i
< XVECLEN (exp
, 0); i
+= 2)
2369 XVECEXP (newexp
, 0, i
) = XVECEXP (exp
, 0, i
);
2370 XVECEXP (newexp
, 0, i
+ 1)
2371 = substitute_address (XVECEXP (exp
, 0, i
+ 1),
2372 no_address_fn
, address_fn
);
2375 XEXP (newexp
, 1) = substitute_address (XEXP (exp
, 1),
2376 no_address_fn
, address_fn
);
2381 else if (GET_CODE (exp
) == IF_THEN_ELSE
)
2384 walk_attr_value (XEXP (exp
, 0));
2386 return (*address_fn
) (exp
);
2388 return attr_rtx (IF_THEN_ELSE
,
2389 substitute_address (XEXP (exp
, 0),
2390 no_address_fn
, address_fn
),
2391 substitute_address (XEXP (exp
, 1),
2392 no_address_fn
, address_fn
),
2393 substitute_address (XEXP (exp
, 2),
2394 no_address_fn
, address_fn
));
2397 return (*no_address_fn
) (exp
);
2400 /* Make new attributes from the `length' attribute. The following are made,
2401 each corresponding to a function called from `shorten_branches' or
2404 *insn_default_length This is the length of the insn to be returned
2405 by `get_attr_length' before `shorten_branches'
2406 has been called. In each case where the length
2407 depends on relative addresses, the largest
2408 possible is used. This routine is also used
2409 to compute the initial size of the insn.
2411 *insn_variable_length_p This returns 1 if the insn's length depends
2412 on relative addresses, zero otherwise.
2414 *insn_current_length This is only called when it is known that the
2415 insn has a variable length and returns the
2416 current length, based on relative addresses.
2420 make_length_attrs ()
2422 static const char *new_names
[] = {"*insn_default_length",
2423 "*insn_variable_length_p",
2424 "*insn_current_length"};
2425 static rtx (*no_address_fn
[]) PROTO((rtx
)) = {identity_fn
, zero_fn
, zero_fn
};
2426 static rtx (*address_fn
[]) PROTO((rtx
)) = {max_fn
, one_fn
, identity_fn
};
2428 struct attr_desc
*length_attr
, *new_attr
;
2429 struct attr_value
*av
, *new_av
;
2430 struct insn_ent
*ie
, *new_ie
;
2432 /* See if length attribute is defined. If so, it must be numeric. Make
2433 it special so we don't output anything for it. */
2434 length_attr
= find_attr ("length", 0);
2435 if (length_attr
== 0)
2438 if (! length_attr
->is_numeric
)
2439 fatal ("length attribute must be numeric.");
2441 length_attr
->is_const
= 0;
2442 length_attr
->is_special
= 1;
2444 /* Make each new attribute, in turn. */
2445 for (i
= 0; i
< sizeof new_names
/ sizeof new_names
[0]; i
++)
2447 make_internal_attr (new_names
[i
],
2448 substitute_address (length_attr
->default_val
->value
,
2449 no_address_fn
[i
], address_fn
[i
]),
2451 new_attr
= find_attr (new_names
[i
], 0);
2452 for (av
= length_attr
->first_value
; av
; av
= av
->next
)
2453 for (ie
= av
->first_insn
; ie
; ie
= ie
->next
)
2455 new_av
= get_attr_value (substitute_address (av
->value
,
2458 new_attr
, ie
->insn_code
);
2459 new_ie
= (struct insn_ent
*) oballoc (sizeof (struct insn_ent
));
2460 new_ie
->insn_code
= ie
->insn_code
;
2461 new_ie
->insn_index
= ie
->insn_index
;
2462 insert_insn_ent (new_av
, new_ie
);
2467 /* Utility functions called from above routine. */
2478 rtx exp ATTRIBUTE_UNUSED
;
2480 return make_numeric_value (0);
2485 rtx exp ATTRIBUTE_UNUSED
;
2487 return make_numeric_value (1);
2495 return make_numeric_value (max_attr_value (exp
, &unknown
));
2499 write_length_unit_log ()
2501 struct attr_desc
*length_attr
= find_attr ("length", 0);
2502 struct attr_value
*av
;
2503 struct insn_ent
*ie
;
2504 unsigned int length_unit_log
, length_or
;
2507 if (length_attr
== 0)
2509 length_or
= or_attr_value (length_attr
->default_val
->value
, &unknown
);
2510 for (av
= length_attr
->first_value
; av
; av
= av
->next
)
2511 for (ie
= av
->first_insn
; ie
; ie
= ie
->next
)
2512 length_or
|= or_attr_value (av
->value
, &unknown
);
2515 length_unit_log
= 0;
2518 length_or
= ~length_or
;
2519 for (length_unit_log
= 0; length_or
& 1; length_or
>>= 1)
2522 printf ("int length_unit_log = %u;\n", length_unit_log
);
2525 /* Take a COND expression and see if any of the conditions in it can be
2526 simplified. If any are known true or known false for the particular insn
2527 code, the COND can be further simplified.
2529 Also call ourselves on any COND operations that are values of this COND.
2531 We do not modify EXP; rather, we make and return a new rtx. */
2534 simplify_cond (exp
, insn_code
, insn_index
)
2536 int insn_code
, insn_index
;
2539 /* We store the desired contents here,
2540 then build a new expression if they don't match EXP. */
2541 rtx defval
= XEXP (exp
, 1);
2542 rtx new_defval
= XEXP (exp
, 1);
2543 int len
= XVECLEN (exp
, 0);
2544 rtunion
*tests
= (rtunion
*) alloca (len
* sizeof (rtunion
));
2548 /* This lets us free all storage allocated below, if appropriate. */
2549 first_spacer
= (char *) obstack_finish (rtl_obstack
);
2551 bcopy ((char *) XVEC (exp
, 0)->elem
, (char *) tests
, len
* sizeof (rtunion
));
2553 /* See if default value needs simplification. */
2554 if (GET_CODE (defval
) == COND
)
2555 new_defval
= simplify_cond (defval
, insn_code
, insn_index
);
2557 /* Simplify the subexpressions, and see what tests we can get rid of. */
2559 for (i
= 0; i
< len
; i
+= 2)
2561 rtx newtest
, newval
;
2563 /* Simplify this test. */
2564 newtest
= SIMPLIFY_TEST_EXP (tests
[i
].rtx
, insn_code
, insn_index
);
2565 tests
[i
].rtx
= newtest
;
2567 newval
= tests
[i
+ 1].rtx
;
2568 /* See if this value may need simplification. */
2569 if (GET_CODE (newval
) == COND
)
2570 newval
= simplify_cond (newval
, insn_code
, insn_index
);
2572 /* Look for ways to delete or combine this test. */
2573 if (newtest
== true_rtx
)
2575 /* If test is true, make this value the default
2576 and discard this + any following tests. */
2578 defval
= tests
[i
+ 1].rtx
;
2579 new_defval
= newval
;
2582 else if (newtest
== false_rtx
)
2584 /* If test is false, discard it and its value. */
2585 for (j
= i
; j
< len
- 2; j
++)
2586 tests
[j
].rtx
= tests
[j
+ 2].rtx
;
2590 else if (i
> 0 && attr_equal_p (newval
, tests
[i
- 1].rtx
))
2592 /* If this value and the value for the prev test are the same,
2596 = insert_right_side (IOR
, tests
[i
- 2].rtx
, newtest
,
2597 insn_code
, insn_index
);
2599 /* Delete this test/value. */
2600 for (j
= i
; j
< len
- 2; j
++)
2601 tests
[j
].rtx
= tests
[j
+ 2].rtx
;
2606 tests
[i
+ 1].rtx
= newval
;
2609 /* If the last test in a COND has the same value
2610 as the default value, that test isn't needed. */
2612 while (len
> 0 && attr_equal_p (tests
[len
- 1].rtx
, new_defval
))
2615 /* See if we changed anything. */
2616 if (len
!= XVECLEN (exp
, 0) || new_defval
!= XEXP (exp
, 1))
2619 for (i
= 0; i
< len
; i
++)
2620 if (! attr_equal_p (tests
[i
].rtx
, XVECEXP (exp
, 0, i
)))
2628 obstack_free (rtl_obstack
, first_spacer
);
2629 if (GET_CODE (defval
) == COND
)
2630 return simplify_cond (defval
, insn_code
, insn_index
);
2635 obstack_free (rtl_obstack
, first_spacer
);
2640 rtx newexp
= rtx_alloc (COND
);
2642 XVEC (newexp
, 0) = rtvec_alloc (len
);
2643 bcopy ((char *) tests
, (char *) XVEC (newexp
, 0)->elem
,
2644 len
* sizeof (rtunion
));
2645 XEXP (newexp
, 1) = new_defval
;
2650 /* Remove an insn entry from an attribute value. */
2653 remove_insn_ent (av
, ie
)
2654 struct attr_value
*av
;
2655 struct insn_ent
*ie
;
2657 struct insn_ent
*previe
;
2659 if (av
->first_insn
== ie
)
2660 av
->first_insn
= ie
->next
;
2663 for (previe
= av
->first_insn
; previe
->next
!= ie
; previe
= previe
->next
)
2665 previe
->next
= ie
->next
;
2669 if (ie
->insn_code
== -1)
2670 av
->has_asm_insn
= 0;
2675 /* Insert an insn entry in an attribute value list. */
2678 insert_insn_ent (av
, ie
)
2679 struct attr_value
*av
;
2680 struct insn_ent
*ie
;
2682 ie
->next
= av
->first_insn
;
2683 av
->first_insn
= ie
;
2685 if (ie
->insn_code
== -1)
2686 av
->has_asm_insn
= 1;
2691 /* This is a utility routine to take an expression that is a tree of either
2692 AND or IOR expressions and insert a new term. The new term will be
2693 inserted at the right side of the first node whose code does not match
2694 the root. A new node will be created with the root's code. Its left
2695 side will be the old right side and its right side will be the new
2698 If the `term' is itself a tree, all its leaves will be inserted. */
2701 insert_right_side (code
, exp
, term
, insn_code
, insn_index
)
2705 int insn_code
, insn_index
;
2709 /* Avoid consing in some special cases. */
2710 if (code
== AND
&& term
== true_rtx
)
2712 if (code
== AND
&& term
== false_rtx
)
2714 if (code
== AND
&& exp
== true_rtx
)
2716 if (code
== AND
&& exp
== false_rtx
)
2718 if (code
== IOR
&& term
== true_rtx
)
2720 if (code
== IOR
&& term
== false_rtx
)
2722 if (code
== IOR
&& exp
== true_rtx
)
2724 if (code
== IOR
&& exp
== false_rtx
)
2726 if (attr_equal_p (exp
, term
))
2729 if (GET_CODE (term
) == code
)
2731 exp
= insert_right_side (code
, exp
, XEXP (term
, 0),
2732 insn_code
, insn_index
);
2733 exp
= insert_right_side (code
, exp
, XEXP (term
, 1),
2734 insn_code
, insn_index
);
2739 if (GET_CODE (exp
) == code
)
2741 rtx
new = insert_right_side (code
, XEXP (exp
, 1),
2742 term
, insn_code
, insn_index
);
2743 if (new != XEXP (exp
, 1))
2744 /* Make a copy of this expression and call recursively. */
2745 newexp
= attr_rtx (code
, XEXP (exp
, 0), new);
2751 /* Insert the new term. */
2752 newexp
= attr_rtx (code
, exp
, term
);
2755 return SIMPLIFY_TEST_EXP (newexp
, insn_code
, insn_index
);
2758 /* If we have an expression which AND's a bunch of
2759 (not (eq_attrq "alternative" "n"))
2760 terms, we may have covered all or all but one of the possible alternatives.
2761 If so, we can optimize. Similarly for IOR's of EQ_ATTR.
2763 This routine is passed an expression and either AND or IOR. It returns a
2764 bitmask indicating which alternatives are mentioned within EXP. */
2767 compute_alternative_mask (exp
, code
)
2772 if (GET_CODE (exp
) == code
)
2773 return compute_alternative_mask (XEXP (exp
, 0), code
)
2774 | compute_alternative_mask (XEXP (exp
, 1), code
);
2776 else if (code
== AND
&& GET_CODE (exp
) == NOT
2777 && GET_CODE (XEXP (exp
, 0)) == EQ_ATTR
2778 && XSTR (XEXP (exp
, 0), 0) == alternative_name
)
2779 string
= XSTR (XEXP (exp
, 0), 1);
2781 else if (code
== IOR
&& GET_CODE (exp
) == EQ_ATTR
2782 && XSTR (exp
, 0) == alternative_name
)
2783 string
= XSTR (exp
, 1);
2789 return 1 << (string
[0] - '0');
2790 return 1 << atoi (string
);
2793 /* Given I, a single-bit mask, return RTX to compare the `alternative'
2794 attribute with the value represented by that bit. */
2797 make_alternative_compare (mask
)
2804 for (i
= 0; (mask
& (1 << i
)) == 0; i
++)
2807 newexp
= attr_rtx (EQ_ATTR
, alternative_name
, attr_numeral (i
));
2808 RTX_UNCHANGING_P (newexp
) = 1;
2813 /* If we are processing an (eq_attr "attr" "value") test, we find the value
2814 of "attr" for this insn code. From that value, we can compute a test
2815 showing when the EQ_ATTR will be true. This routine performs that
2816 computation. If a test condition involves an address, we leave the EQ_ATTR
2817 intact because addresses are only valid for the `length' attribute.
2819 EXP is the EQ_ATTR expression and VALUE is the value of that attribute
2820 for the insn corresponding to INSN_CODE and INSN_INDEX. */
2823 evaluate_eq_attr (exp
, value
, insn_code
, insn_index
)
2826 int insn_code
, insn_index
;
2833 if (GET_CODE (value
) == CONST_STRING
)
2835 if (! strcmp (XSTR (value
, 0), XSTR (exp
, 1)))
2840 else if (GET_CODE (value
) == SYMBOL_REF
)
2844 if (GET_CODE (exp
) != EQ_ATTR
)
2847 string
= (char *) alloca (2 + strlen (XSTR (exp
, 0))
2848 + strlen (XSTR (exp
, 1)));
2849 strcpy (string
, XSTR (exp
, 0));
2850 strcat (string
, "_");
2851 strcat (string
, XSTR (exp
, 1));
2852 for (p
= string
; *p
; p
++)
2853 if (*p
>= 'a' && *p
<= 'z')
2856 newexp
= attr_rtx (EQ
, value
,
2857 attr_rtx (SYMBOL_REF
,
2858 attr_string(string
, strlen(string
))));
2860 else if (GET_CODE (value
) == COND
)
2862 /* We construct an IOR of all the cases for which the requested attribute
2863 value is present. Since we start with FALSE, if it is not present,
2864 FALSE will be returned.
2866 Each case is the AND of the NOT's of the previous conditions with the
2867 current condition; in the default case the current condition is TRUE.
2869 For each possible COND value, call ourselves recursively.
2871 The extra TRUE and FALSE expressions will be eliminated by another
2872 call to the simplification routine. */
2877 if (current_alternative_string
)
2878 clear_struct_flag (value
);
2880 for (i
= 0; i
< XVECLEN (value
, 0); i
+= 2)
2882 rtx
this = SIMPLIFY_TEST_EXP (XVECEXP (value
, 0, i
),
2883 insn_code
, insn_index
);
2885 SIMPLIFY_ALTERNATIVE (this);
2887 right
= insert_right_side (AND
, andexp
, this,
2888 insn_code
, insn_index
);
2889 right
= insert_right_side (AND
, right
,
2890 evaluate_eq_attr (exp
,
2893 insn_code
, insn_index
),
2894 insn_code
, insn_index
);
2895 orexp
= insert_right_side (IOR
, orexp
, right
,
2896 insn_code
, insn_index
);
2898 /* Add this condition into the AND expression. */
2899 newexp
= attr_rtx (NOT
, this);
2900 andexp
= insert_right_side (AND
, andexp
, newexp
,
2901 insn_code
, insn_index
);
2904 /* Handle the default case. */
2905 right
= insert_right_side (AND
, andexp
,
2906 evaluate_eq_attr (exp
, XEXP (value
, 1),
2907 insn_code
, insn_index
),
2908 insn_code
, insn_index
);
2909 newexp
= insert_right_side (IOR
, orexp
, right
, insn_code
, insn_index
);
2914 /* If uses an address, must return original expression. But set the
2915 RTX_UNCHANGING_P bit so we don't try to simplify it again. */
2918 walk_attr_value (newexp
);
2922 /* This had `&& current_alternative_string', which seems to be wrong. */
2923 if (! RTX_UNCHANGING_P (exp
))
2924 return copy_rtx_unchanging (exp
);
2931 /* This routine is called when an AND of a term with a tree of AND's is
2932 encountered. If the term or its complement is present in the tree, it
2933 can be replaced with TRUE or FALSE, respectively.
2935 Note that (eq_attr "att" "v1") and (eq_attr "att" "v2") cannot both
2936 be true and hence are complementary.
2938 There is one special case: If we see
2939 (and (not (eq_attr "att" "v1"))
2940 (eq_attr "att" "v2"))
2941 this can be replaced by (eq_attr "att" "v2"). To do this we need to
2942 replace the term, not anything in the AND tree. So we pass a pointer to
2946 simplify_and_tree (exp
, pterm
, insn_code
, insn_index
)
2949 int insn_code
, insn_index
;
2954 int left_eliminates_term
, right_eliminates_term
;
2956 if (GET_CODE (exp
) == AND
)
2958 left
= simplify_and_tree (XEXP (exp
, 0), pterm
, insn_code
, insn_index
);
2959 right
= simplify_and_tree (XEXP (exp
, 1), pterm
, insn_code
, insn_index
);
2960 if (left
!= XEXP (exp
, 0) || right
!= XEXP (exp
, 1))
2962 newexp
= attr_rtx (GET_CODE (exp
), left
, right
);
2964 exp
= SIMPLIFY_TEST_EXP (newexp
, insn_code
, insn_index
);
2968 else if (GET_CODE (exp
) == IOR
)
2970 /* For the IOR case, we do the same as above, except that we can
2971 only eliminate `term' if both sides of the IOR would do so. */
2973 left
= simplify_and_tree (XEXP (exp
, 0), &temp
, insn_code
, insn_index
);
2974 left_eliminates_term
= (temp
== true_rtx
);
2977 right
= simplify_and_tree (XEXP (exp
, 1), &temp
, insn_code
, insn_index
);
2978 right_eliminates_term
= (temp
== true_rtx
);
2980 if (left_eliminates_term
&& right_eliminates_term
)
2983 if (left
!= XEXP (exp
, 0) || right
!= XEXP (exp
, 1))
2985 newexp
= attr_rtx (GET_CODE (exp
), left
, right
);
2987 exp
= SIMPLIFY_TEST_EXP (newexp
, insn_code
, insn_index
);
2991 /* Check for simplifications. Do some extra checking here since this
2992 routine is called so many times. */
2997 else if (GET_CODE (exp
) == NOT
&& XEXP (exp
, 0) == *pterm
)
3000 else if (GET_CODE (*pterm
) == NOT
&& exp
== XEXP (*pterm
, 0))
3003 else if (GET_CODE (exp
) == EQ_ATTR
&& GET_CODE (*pterm
) == EQ_ATTR
)
3005 if (XSTR (exp
, 0) != XSTR (*pterm
, 0))
3008 if (! strcmp (XSTR (exp
, 1), XSTR (*pterm
, 1)))
3014 else if (GET_CODE (*pterm
) == EQ_ATTR
&& GET_CODE (exp
) == NOT
3015 && GET_CODE (XEXP (exp
, 0)) == EQ_ATTR
)
3017 if (XSTR (*pterm
, 0) != XSTR (XEXP (exp
, 0), 0))
3020 if (! strcmp (XSTR (*pterm
, 1), XSTR (XEXP (exp
, 0), 1)))
3026 else if (GET_CODE (exp
) == EQ_ATTR
&& GET_CODE (*pterm
) == NOT
3027 && GET_CODE (XEXP (*pterm
, 0)) == EQ_ATTR
)
3029 if (XSTR (exp
, 0) != XSTR (XEXP (*pterm
, 0), 0))
3032 if (! strcmp (XSTR (exp
, 1), XSTR (XEXP (*pterm
, 0), 1)))
3038 else if (GET_CODE (exp
) == NOT
&& GET_CODE (*pterm
) == NOT
)
3040 if (attr_equal_p (XEXP (exp
, 0), XEXP (*pterm
, 0)))
3044 else if (GET_CODE (exp
) == NOT
)
3046 if (attr_equal_p (XEXP (exp
, 0), *pterm
))
3050 else if (GET_CODE (*pterm
) == NOT
)
3052 if (attr_equal_p (XEXP (*pterm
, 0), exp
))
3056 else if (attr_equal_p (exp
, *pterm
))
3062 /* Similar to `simplify_and_tree', but for IOR trees. */
3065 simplify_or_tree (exp
, pterm
, insn_code
, insn_index
)
3068 int insn_code
, insn_index
;
3073 int left_eliminates_term
, right_eliminates_term
;
3075 if (GET_CODE (exp
) == IOR
)
3077 left
= simplify_or_tree (XEXP (exp
, 0), pterm
, insn_code
, insn_index
);
3078 right
= simplify_or_tree (XEXP (exp
, 1), pterm
, insn_code
, insn_index
);
3079 if (left
!= XEXP (exp
, 0) || right
!= XEXP (exp
, 1))
3081 newexp
= attr_rtx (GET_CODE (exp
), left
, right
);
3083 exp
= SIMPLIFY_TEST_EXP (newexp
, insn_code
, insn_index
);
3087 else if (GET_CODE (exp
) == AND
)
3089 /* For the AND case, we do the same as above, except that we can
3090 only eliminate `term' if both sides of the AND would do so. */
3092 left
= simplify_or_tree (XEXP (exp
, 0), &temp
, insn_code
, insn_index
);
3093 left_eliminates_term
= (temp
== false_rtx
);
3096 right
= simplify_or_tree (XEXP (exp
, 1), &temp
, insn_code
, insn_index
);
3097 right_eliminates_term
= (temp
== false_rtx
);
3099 if (left_eliminates_term
&& right_eliminates_term
)
3102 if (left
!= XEXP (exp
, 0) || right
!= XEXP (exp
, 1))
3104 newexp
= attr_rtx (GET_CODE (exp
), left
, right
);
3106 exp
= SIMPLIFY_TEST_EXP (newexp
, insn_code
, insn_index
);
3110 if (attr_equal_p (exp
, *pterm
))
3113 else if (GET_CODE (exp
) == NOT
&& attr_equal_p (XEXP (exp
, 0), *pterm
))
3116 else if (GET_CODE (*pterm
) == NOT
&& attr_equal_p (XEXP (*pterm
, 0), exp
))
3119 else if (GET_CODE (*pterm
) == EQ_ATTR
&& GET_CODE (exp
) == NOT
3120 && GET_CODE (XEXP (exp
, 0)) == EQ_ATTR
3121 && XSTR (*pterm
, 0) == XSTR (XEXP (exp
, 0), 0))
3124 else if (GET_CODE (exp
) == EQ_ATTR
&& GET_CODE (*pterm
) == NOT
3125 && GET_CODE (XEXP (*pterm
, 0)) == EQ_ATTR
3126 && XSTR (exp
, 0) == XSTR (XEXP (*pterm
, 0), 0))
3132 /* Given an expression, see if it can be simplified for a particular insn
3133 code based on the values of other attributes being tested. This can
3134 eliminate nested get_attr_... calls.
3136 Note that if an endless recursion is specified in the patterns, the
3137 optimization will loop. However, it will do so in precisely the cases where
3138 an infinite recursion loop could occur during compilation. It's better that
3142 simplify_test_exp (exp
, insn_code
, insn_index
)
3144 int insn_code
, insn_index
;
3147 struct attr_desc
*attr
;
3148 struct attr_value
*av
;
3149 struct insn_ent
*ie
;
3152 char *spacer
= (char *) obstack_finish (rtl_obstack
);
3154 /* Don't re-simplify something we already simplified. */
3155 if (RTX_UNCHANGING_P (exp
) || MEM_IN_STRUCT_P (exp
))
3158 switch (GET_CODE (exp
))
3161 left
= SIMPLIFY_TEST_EXP (XEXP (exp
, 0), insn_code
, insn_index
);
3162 SIMPLIFY_ALTERNATIVE (left
);
3163 if (left
== false_rtx
)
3165 obstack_free (rtl_obstack
, spacer
);
3168 right
= SIMPLIFY_TEST_EXP (XEXP (exp
, 1), insn_code
, insn_index
);
3169 SIMPLIFY_ALTERNATIVE (right
);
3170 if (left
== false_rtx
)
3172 obstack_free (rtl_obstack
, spacer
);
3176 /* If either side is an IOR and we have (eq_attr "alternative" ..")
3177 present on both sides, apply the distributive law since this will
3178 yield simplifications. */
3179 if ((GET_CODE (left
) == IOR
|| GET_CODE (right
) == IOR
)
3180 && compute_alternative_mask (left
, IOR
)
3181 && compute_alternative_mask (right
, IOR
))
3183 if (GET_CODE (left
) == IOR
)
3190 newexp
= attr_rtx (IOR
,
3191 attr_rtx (AND
, left
, XEXP (right
, 0)),
3192 attr_rtx (AND
, left
, XEXP (right
, 1)));
3194 return SIMPLIFY_TEST_EXP (newexp
, insn_code
, insn_index
);
3197 /* Try with the term on both sides. */
3198 right
= simplify_and_tree (right
, &left
, insn_code
, insn_index
);
3199 if (left
== XEXP (exp
, 0) && right
== XEXP (exp
, 1))
3200 left
= simplify_and_tree (left
, &right
, insn_code
, insn_index
);
3202 if (left
== false_rtx
|| right
== false_rtx
)
3204 obstack_free (rtl_obstack
, spacer
);
3207 else if (left
== true_rtx
)
3211 else if (right
== true_rtx
)
3215 /* See if all or all but one of the insn's alternatives are specified
3216 in this tree. Optimize if so. */
3218 else if (insn_code
>= 0
3219 && (GET_CODE (left
) == AND
3220 || (GET_CODE (left
) == NOT
3221 && GET_CODE (XEXP (left
, 0)) == EQ_ATTR
3222 && XSTR (XEXP (left
, 0), 0) == alternative_name
)
3223 || GET_CODE (right
) == AND
3224 || (GET_CODE (right
) == NOT
3225 && GET_CODE (XEXP (right
, 0)) == EQ_ATTR
3226 && XSTR (XEXP (right
, 0), 0) == alternative_name
)))
3228 i
= compute_alternative_mask (exp
, AND
);
3229 if (i
& ~insn_alternatives
[insn_code
])
3230 fatal ("Invalid alternative specified for pattern number %d",
3233 /* If all alternatives are excluded, this is false. */
3234 i
^= insn_alternatives
[insn_code
];
3237 else if ((i
& (i
- 1)) == 0 && insn_alternatives
[insn_code
] > 1)
3239 /* If just one excluded, AND a comparison with that one to the
3240 front of the tree. The others will be eliminated by
3241 optimization. We do not want to do this if the insn has one
3242 alternative and we have tested none of them! */
3243 left
= make_alternative_compare (i
);
3244 right
= simplify_and_tree (exp
, &left
, insn_code
, insn_index
);
3245 newexp
= attr_rtx (AND
, left
, right
);
3247 return SIMPLIFY_TEST_EXP (newexp
, insn_code
, insn_index
);
3251 if (left
!= XEXP (exp
, 0) || right
!= XEXP (exp
, 1))
3253 newexp
= attr_rtx (AND
, left
, right
);
3254 return SIMPLIFY_TEST_EXP (newexp
, insn_code
, insn_index
);
3259 left
= SIMPLIFY_TEST_EXP (XEXP (exp
, 0), insn_code
, insn_index
);
3260 SIMPLIFY_ALTERNATIVE (left
);
3261 if (left
== true_rtx
)
3263 obstack_free (rtl_obstack
, spacer
);
3266 right
= SIMPLIFY_TEST_EXP (XEXP (exp
, 1), insn_code
, insn_index
);
3267 SIMPLIFY_ALTERNATIVE (right
);
3268 if (right
== true_rtx
)
3270 obstack_free (rtl_obstack
, spacer
);
3274 right
= simplify_or_tree (right
, &left
, insn_code
, insn_index
);
3275 if (left
== XEXP (exp
, 0) && right
== XEXP (exp
, 1))
3276 left
= simplify_or_tree (left
, &right
, insn_code
, insn_index
);
3278 if (right
== true_rtx
|| left
== true_rtx
)
3280 obstack_free (rtl_obstack
, spacer
);
3283 else if (left
== false_rtx
)
3287 else if (right
== false_rtx
)
3292 /* Test for simple cases where the distributive law is useful. I.e.,
3293 convert (ior (and (x) (y))
3299 else if (GET_CODE (left
) == AND
&& GET_CODE (right
) == AND
3300 && attr_equal_p (XEXP (left
, 0), XEXP (right
, 0)))
3302 newexp
= attr_rtx (IOR
, XEXP (left
, 1), XEXP (right
, 1));
3304 left
= XEXP (left
, 0);
3306 newexp
= attr_rtx (AND
, left
, right
);
3307 return SIMPLIFY_TEST_EXP (newexp
, insn_code
, insn_index
);
3310 /* See if all or all but one of the insn's alternatives are specified
3311 in this tree. Optimize if so. */
3313 else if (insn_code
>= 0
3314 && (GET_CODE (left
) == IOR
3315 || (GET_CODE (left
) == EQ_ATTR
3316 && XSTR (left
, 0) == alternative_name
)
3317 || GET_CODE (right
) == IOR
3318 || (GET_CODE (right
) == EQ_ATTR
3319 && XSTR (right
, 0) == alternative_name
)))
3321 i
= compute_alternative_mask (exp
, IOR
);
3322 if (i
& ~insn_alternatives
[insn_code
])
3323 fatal ("Invalid alternative specified for pattern number %d",
3326 /* If all alternatives are included, this is true. */
3327 i
^= insn_alternatives
[insn_code
];
3330 else if ((i
& (i
- 1)) == 0 && insn_alternatives
[insn_code
] > 1)
3332 /* If just one excluded, IOR a comparison with that one to the
3333 front of the tree. The others will be eliminated by
3334 optimization. We do not want to do this if the insn has one
3335 alternative and we have tested none of them! */
3336 left
= make_alternative_compare (i
);
3337 right
= simplify_and_tree (exp
, &left
, insn_code
, insn_index
);
3338 newexp
= attr_rtx (IOR
, attr_rtx (NOT
, left
), right
);
3340 return SIMPLIFY_TEST_EXP (newexp
, insn_code
, insn_index
);
3344 if (left
!= XEXP (exp
, 0) || right
!= XEXP (exp
, 1))
3346 newexp
= attr_rtx (IOR
, left
, right
);
3347 return SIMPLIFY_TEST_EXP (newexp
, insn_code
, insn_index
);
3352 if (GET_CODE (XEXP (exp
, 0)) == NOT
)
3354 left
= SIMPLIFY_TEST_EXP (XEXP (XEXP (exp
, 0), 0),
3355 insn_code
, insn_index
);
3356 SIMPLIFY_ALTERNATIVE (left
);
3360 left
= SIMPLIFY_TEST_EXP (XEXP (exp
, 0), insn_code
, insn_index
);
3361 SIMPLIFY_ALTERNATIVE (left
);
3362 if (GET_CODE (left
) == NOT
)
3363 return XEXP (left
, 0);
3365 if (left
== false_rtx
)
3367 obstack_free (rtl_obstack
, spacer
);
3370 else if (left
== true_rtx
)
3372 obstack_free (rtl_obstack
, spacer
);
3376 /* Try to apply De`Morgan's laws. */
3377 else if (GET_CODE (left
) == IOR
)
3379 newexp
= attr_rtx (AND
,
3380 attr_rtx (NOT
, XEXP (left
, 0)),
3381 attr_rtx (NOT
, XEXP (left
, 1)));
3383 newexp
= SIMPLIFY_TEST_EXP (newexp
, insn_code
, insn_index
);
3385 else if (GET_CODE (left
) == AND
)
3387 newexp
= attr_rtx (IOR
,
3388 attr_rtx (NOT
, XEXP (left
, 0)),
3389 attr_rtx (NOT
, XEXP (left
, 1)));
3391 newexp
= SIMPLIFY_TEST_EXP (newexp
, insn_code
, insn_index
);
3393 else if (left
!= XEXP (exp
, 0))
3395 newexp
= attr_rtx (NOT
, left
);
3400 if (current_alternative_string
&& XSTR (exp
, 0) == alternative_name
)
3401 return (XSTR (exp
, 1) == current_alternative_string
3402 ? true_rtx
: false_rtx
);
3404 /* Look at the value for this insn code in the specified attribute.
3405 We normally can replace this comparison with the condition that
3406 would give this insn the values being tested for. */
3407 if (XSTR (exp
, 0) != alternative_name
3408 && (attr
= find_attr (XSTR (exp
, 0), 0)) != NULL
)
3409 for (av
= attr
->first_value
; av
; av
= av
->next
)
3410 for (ie
= av
->first_insn
; ie
; ie
= ie
->next
)
3411 if (ie
->insn_code
== insn_code
)
3412 return evaluate_eq_attr (exp
, av
->value
, insn_code
, insn_index
);
3419 /* We have already simplified this expression. Simplifying it again
3420 won't buy anything unless we weren't given a valid insn code
3421 to process (i.e., we are canonicalizing something.). */
3422 if (insn_code
!= -2 /* Seems wrong: && current_alternative_string. */
3423 && ! RTX_UNCHANGING_P (newexp
))
3424 return copy_rtx_unchanging (newexp
);
3429 /* Optimize the attribute lists by seeing if we can determine conditional
3430 values from the known values of other attributes. This will save subroutine
3431 calls during the compilation. */
3436 struct attr_desc
*attr
;
3437 struct attr_value
*av
;
3438 struct insn_ent
*ie
;
3440 int something_changed
= 1;
3442 struct attr_value_list
{ struct attr_value
*av
;
3443 struct insn_ent
*ie
;
3444 struct attr_desc
* attr
;
3445 struct attr_value_list
*next
; };
3446 struct attr_value_list
**insn_code_values
;
3447 struct attr_value_list
*ivbuf
;
3448 struct attr_value_list
*iv
;
3450 /* For each insn code, make a list of all the insn_ent's for it,
3451 for all values for all attributes. */
3453 if (num_insn_ents
== 0)
3456 /* Make 2 extra elements, for "code" values -2 and -1. */
3458 = (struct attr_value_list
**) alloca ((insn_code_number
+ 2)
3459 * sizeof (struct attr_value_list
*));
3460 bzero ((char *) insn_code_values
,
3461 (insn_code_number
+ 2) * sizeof (struct attr_value_list
*));
3463 /* Offset the table address so we can index by -2 or -1. */
3464 insn_code_values
+= 2;
3466 /* Allocate the attr_value_list structures using xmalloc rather than
3467 alloca, because using alloca can overflow the maximum permitted
3468 stack limit on SPARC Lynx. */
3469 iv
= ivbuf
= ((struct attr_value_list
*)
3470 xmalloc (num_insn_ents
* sizeof (struct attr_value_list
)));
3472 for (i
= 0; i
< MAX_ATTRS_INDEX
; i
++)
3473 for (attr
= attrs
[i
]; attr
; attr
= attr
->next
)
3474 for (av
= attr
->first_value
; av
; av
= av
->next
)
3475 for (ie
= av
->first_insn
; ie
; ie
= ie
->next
)
3480 iv
->next
= insn_code_values
[ie
->insn_code
];
3481 insn_code_values
[ie
->insn_code
] = iv
;
3485 /* Sanity check on num_insn_ents. */
3486 if (iv
!= ivbuf
+ num_insn_ents
)
3489 /* Process one insn code at a time. */
3490 for (i
= -2; i
< insn_code_number
; i
++)
3492 /* Clear the MEM_IN_STRUCT_P flag everywhere relevant.
3493 We use it to mean "already simplified for this insn". */
3494 for (iv
= insn_code_values
[i
]; iv
; iv
= iv
->next
)
3495 clear_struct_flag (iv
->av
->value
);
3497 /* Loop until nothing changes for one iteration. */
3498 something_changed
= 1;
3499 while (something_changed
)
3501 something_changed
= 0;
3502 for (iv
= insn_code_values
[i
]; iv
; iv
= iv
->next
)
3504 struct obstack
*old
= rtl_obstack
;
3505 char *spacer
= (char *) obstack_finish (temp_obstack
);
3510 if (GET_CODE (av
->value
) != COND
)
3513 rtl_obstack
= temp_obstack
;
3514 #if 0 /* This was intended as a speed up, but it was slower. */
3515 if (insn_n_alternatives
[ie
->insn_code
] > 6
3516 && count_sub_rtxs (av
->value
, 200) >= 200)
3517 newexp
= simplify_by_alternatives (av
->value
, ie
->insn_code
,
3521 newexp
= simplify_cond (av
->value
, ie
->insn_code
,
3525 if (newexp
!= av
->value
)
3527 newexp
= attr_copy_rtx (newexp
);
3528 remove_insn_ent (av
, ie
);
3529 av
= get_attr_value (newexp
, attr
, ie
->insn_code
);
3531 insert_insn_ent (av
, ie
);
3532 something_changed
= 1;
3534 obstack_free (temp_obstack
, spacer
);
3544 simplify_by_alternatives (exp
, insn_code
, insn_index
)
3546 int insn_code
, insn_index
;
3549 int len
= insn_n_alternatives
[insn_code
];
3550 rtx newexp
= rtx_alloc (COND
);
3554 XVEC (newexp
, 0) = rtvec_alloc (len
* 2);
3556 /* It will not matter what value we use as the default value
3557 of the new COND, since that default will never be used.
3558 Choose something of the right type. */
3559 for (ultimate
= exp
; GET_CODE (ultimate
) == COND
;)
3560 ultimate
= XEXP (ultimate
, 1);
3561 XEXP (newexp
, 1) = ultimate
;
3563 for (i
= 0; i
< insn_n_alternatives
[insn_code
]; i
++)
3565 current_alternative_string
= attr_numeral (i
);
3566 XVECEXP (newexp
, 0, i
* 2) = make_alternative_compare (1 << i
);
3567 XVECEXP (newexp
, 0, i
* 2 + 1)
3568 = simplify_cond (exp
, insn_code
, insn_index
);
3571 current_alternative_string
= 0;
3572 return simplify_cond (newexp
, insn_code
, insn_index
);
3576 /* If EXP is a suitable expression, reorganize it by constructing an
3577 equivalent expression that is a COND with the tests being all combinations
3578 of attribute values and the values being simple constants. */
3581 simplify_by_exploding (exp
)
3584 rtx list
= 0, link
, condexp
, defval
= NULL_RTX
;
3585 struct dimension
*space
;
3586 rtx
*condtest
, *condval
;
3587 int i
, j
, total
, ndim
= 0;
3588 int most_tests
, num_marks
, new_marks
;
3590 /* Locate all the EQ_ATTR expressions. */
3591 if (! find_and_mark_used_attributes (exp
, &list
, &ndim
) || ndim
== 0)
3593 unmark_used_attributes (list
, 0, 0);
3597 /* Create an attribute space from the list of used attributes. For each
3598 dimension in the attribute space, record the attribute, list of values
3599 used, and number of values used. Add members to the list of values to
3600 cover the domain of the attribute. This makes the expanded COND form
3601 order independent. */
3603 space
= (struct dimension
*) alloca (ndim
* sizeof (struct dimension
));
3606 for (ndim
= 0; list
; ndim
++)
3608 /* Pull the first attribute value from the list and record that
3609 attribute as another dimension in the attribute space. */
3610 char *name
= XSTR (XEXP (list
, 0), 0);
3613 if ((space
[ndim
].attr
= find_attr (name
, 0)) == 0
3614 || space
[ndim
].attr
->is_numeric
)
3616 unmark_used_attributes (list
, space
, ndim
);
3620 /* Add all remaining attribute values that refer to this attribute. */
3621 space
[ndim
].num_values
= 0;
3622 space
[ndim
].values
= 0;
3624 for (link
= list
; link
; link
= *prev
)
3625 if (! strcmp (XSTR (XEXP (link
, 0), 0), name
))
3627 space
[ndim
].num_values
++;
3628 *prev
= XEXP (link
, 1);
3629 XEXP (link
, 1) = space
[ndim
].values
;
3630 space
[ndim
].values
= link
;
3633 prev
= &XEXP (link
, 1);
3635 /* Add sufficient members to the list of values to make the list
3636 mutually exclusive and record the total size of the attribute
3638 total
*= add_values_to_cover (&space
[ndim
]);
3641 /* Sort the attribute space so that the attributes go from non-constant
3642 to constant and from most values to least values. */
3643 for (i
= 0; i
< ndim
; i
++)
3644 for (j
= ndim
- 1; j
> i
; j
--)
3645 if ((space
[j
-1].attr
->is_const
&& !space
[j
].attr
->is_const
)
3646 || space
[j
-1].num_values
< space
[j
].num_values
)
3648 struct dimension tmp
;
3650 space
[j
] = space
[j
-1];
3654 /* Establish the initial current value. */
3655 for (i
= 0; i
< ndim
; i
++)
3656 space
[i
].current_value
= space
[i
].values
;
3658 condtest
= (rtx
*) alloca (total
* sizeof (rtx
));
3659 condval
= (rtx
*) alloca (total
* sizeof (rtx
));
3661 /* Expand the tests and values by iterating over all values in the
3665 condtest
[i
] = test_for_current_value (space
, ndim
);
3666 condval
[i
] = simplify_with_current_value (exp
, space
, ndim
);
3667 if (! increment_current_value (space
, ndim
))
3673 /* We are now finished with the original expression. */
3674 unmark_used_attributes (0, space
, ndim
);
3676 /* Find the most used constant value and make that the default. */
3678 for (i
= num_marks
= 0; i
< total
; i
++)
3679 if (GET_CODE (condval
[i
]) == CONST_STRING
3680 && ! MEM_VOLATILE_P (condval
[i
]))
3682 /* Mark the unmarked constant value and count how many are marked. */
3683 MEM_VOLATILE_P (condval
[i
]) = 1;
3684 for (j
= new_marks
= 0; j
< total
; j
++)
3685 if (GET_CODE (condval
[j
]) == CONST_STRING
3686 && MEM_VOLATILE_P (condval
[j
]))
3688 if (new_marks
- num_marks
> most_tests
)
3690 most_tests
= new_marks
- num_marks
;
3691 defval
= condval
[i
];
3693 num_marks
= new_marks
;
3695 /* Clear all the marks. */
3696 for (i
= 0; i
< total
; i
++)
3697 MEM_VOLATILE_P (condval
[i
]) = 0;
3699 /* Give up if nothing is constant. */
3703 /* If all values are the default, use that. */
3704 if (total
== most_tests
)
3707 /* Make a COND with the most common constant value the default. (A more
3708 complex method where tests with the same value were combined didn't
3709 seem to improve things.) */
3710 condexp
= rtx_alloc (COND
);
3711 XVEC (condexp
, 0) = rtvec_alloc ((total
- most_tests
) * 2);
3712 XEXP (condexp
, 1) = defval
;
3713 for (i
= j
= 0; i
< total
; i
++)
3714 if (condval
[i
] != defval
)
3716 XVECEXP (condexp
, 0, 2 * j
) = condtest
[i
];
3717 XVECEXP (condexp
, 0, 2 * j
+ 1) = condval
[i
];
3724 /* Set the MEM_VOLATILE_P flag for all EQ_ATTR expressions in EXP and
3725 verify that EXP can be simplified to a constant term if all the EQ_ATTR
3726 tests have known value. */
3729 find_and_mark_used_attributes (exp
, terms
, nterms
)
3735 switch (GET_CODE (exp
))
3738 if (! MEM_VOLATILE_P (exp
))
3740 rtx link
= rtx_alloc (EXPR_LIST
);
3741 XEXP (link
, 0) = exp
;
3742 XEXP (link
, 1) = *terms
;
3745 MEM_VOLATILE_P (exp
) = 1;
3754 if (! find_and_mark_used_attributes (XEXP (exp
, 2), terms
, nterms
))
3758 if (! find_and_mark_used_attributes (XEXP (exp
, 1), terms
, nterms
))
3761 if (! find_and_mark_used_attributes (XEXP (exp
, 0), terms
, nterms
))
3766 for (i
= 0; i
< XVECLEN (exp
, 0); i
++)
3767 if (! find_and_mark_used_attributes (XVECEXP (exp
, 0, i
), terms
, nterms
))
3769 if (! find_and_mark_used_attributes (XEXP (exp
, 1), terms
, nterms
))
3778 /* Clear the MEM_VOLATILE_P flag in all EQ_ATTR expressions on LIST and
3779 in the values of the NDIM-dimensional attribute space SPACE. */
3782 unmark_used_attributes (list
, space
, ndim
)
3784 struct dimension
*space
;
3790 for (i
= 0; i
< ndim
; i
++)
3791 unmark_used_attributes (space
[i
].values
, 0, 0);
3793 for (link
= list
; link
; link
= XEXP (link
, 1))
3795 exp
= XEXP (link
, 0);
3796 if (GET_CODE (exp
) == EQ_ATTR
)
3797 MEM_VOLATILE_P (exp
) = 0;
3801 /* Update the attribute dimension DIM so that all values of the attribute
3802 are tested. Return the updated number of values. */
3805 add_values_to_cover (dim
)
3806 struct dimension
*dim
;
3808 struct attr_value
*av
;
3809 rtx exp
, link
, *prev
;
3812 for (av
= dim
->attr
->first_value
; av
; av
= av
->next
)
3813 if (GET_CODE (av
->value
) == CONST_STRING
)
3816 if (nalt
< dim
->num_values
)
3818 else if (nalt
== dim
->num_values
)
3820 else if (nalt
* 2 < dim
->num_values
* 3)
3822 /* Most all the values of the attribute are used, so add all the unused
3824 prev
= &dim
->values
;
3825 for (link
= dim
->values
; link
; link
= *prev
)
3826 prev
= &XEXP (link
, 1);
3828 for (av
= dim
->attr
->first_value
; av
; av
= av
->next
)
3829 if (GET_CODE (av
->value
) == CONST_STRING
)
3831 exp
= attr_eq (dim
->attr
->name
, XSTR (av
->value
, 0));
3832 if (MEM_VOLATILE_P (exp
))
3835 link
= rtx_alloc (EXPR_LIST
);
3836 XEXP (link
, 0) = exp
;
3839 prev
= &XEXP (link
, 1);
3841 dim
->num_values
= nalt
;
3845 rtx orexp
= false_rtx
;
3847 /* Very few values are used, so compute a mutually exclusive
3848 expression. (We could do this for numeric values if that becomes
3850 prev
= &dim
->values
;
3851 for (link
= dim
->values
; link
; link
= *prev
)
3853 orexp
= insert_right_side (IOR
, orexp
, XEXP (link
, 0), -2, -2);
3854 prev
= &XEXP (link
, 1);
3856 link
= rtx_alloc (EXPR_LIST
);
3857 XEXP (link
, 0) = attr_rtx (NOT
, orexp
);
3862 return dim
->num_values
;
3865 /* Increment the current value for the NDIM-dimensional attribute space SPACE
3866 and return FALSE if the increment overflowed. */
3869 increment_current_value (space
, ndim
)
3870 struct dimension
*space
;
3875 for (i
= ndim
- 1; i
>= 0; i
--)
3877 if ((space
[i
].current_value
= XEXP (space
[i
].current_value
, 1)) == 0)
3878 space
[i
].current_value
= space
[i
].values
;
3885 /* Construct an expression corresponding to the current value for the
3886 NDIM-dimensional attribute space SPACE. */
3889 test_for_current_value (space
, ndim
)
3890 struct dimension
*space
;
3896 for (i
= 0; i
< ndim
; i
++)
3897 exp
= insert_right_side (AND
, exp
, XEXP (space
[i
].current_value
, 0),
3903 /* Given the current value of the NDIM-dimensional attribute space SPACE,
3904 set the corresponding EQ_ATTR expressions to that value and reduce
3905 the expression EXP as much as possible. On input [and output], all
3906 known EQ_ATTR expressions are set to FALSE. */
3909 simplify_with_current_value (exp
, space
, ndim
)
3911 struct dimension
*space
;
3917 /* Mark each current value as TRUE. */
3918 for (i
= 0; i
< ndim
; i
++)
3920 x
= XEXP (space
[i
].current_value
, 0);
3921 if (GET_CODE (x
) == EQ_ATTR
)
3922 MEM_VOLATILE_P (x
) = 0;
3925 exp
= simplify_with_current_value_aux (exp
);
3927 /* Change each current value back to FALSE. */
3928 for (i
= 0; i
< ndim
; i
++)
3930 x
= XEXP (space
[i
].current_value
, 0);
3931 if (GET_CODE (x
) == EQ_ATTR
)
3932 MEM_VOLATILE_P (x
) = 1;
3938 /* Reduce the expression EXP based on the MEM_VOLATILE_P settings of
3939 all EQ_ATTR expressions. */
3942 simplify_with_current_value_aux (exp
)
3948 switch (GET_CODE (exp
))
3951 if (MEM_VOLATILE_P (exp
))
3960 cond
= simplify_with_current_value_aux (XEXP (exp
, 0));
3961 if (cond
== true_rtx
)
3962 return simplify_with_current_value_aux (XEXP (exp
, 1));
3963 else if (cond
== false_rtx
)
3964 return simplify_with_current_value_aux (XEXP (exp
, 2));
3966 return attr_rtx (IF_THEN_ELSE
, cond
,
3967 simplify_with_current_value_aux (XEXP (exp
, 1)),
3968 simplify_with_current_value_aux (XEXP (exp
, 2)));
3971 cond
= simplify_with_current_value_aux (XEXP (exp
, 1));
3972 if (cond
== true_rtx
)
3974 else if (cond
== false_rtx
)
3975 return simplify_with_current_value_aux (XEXP (exp
, 0));
3977 return attr_rtx (IOR
, cond
,
3978 simplify_with_current_value_aux (XEXP (exp
, 0)));
3981 cond
= simplify_with_current_value_aux (XEXP (exp
, 1));
3982 if (cond
== true_rtx
)
3983 return simplify_with_current_value_aux (XEXP (exp
, 0));
3984 else if (cond
== false_rtx
)
3987 return attr_rtx (AND
, cond
,
3988 simplify_with_current_value_aux (XEXP (exp
, 0)));
3991 cond
= simplify_with_current_value_aux (XEXP (exp
, 0));
3992 if (cond
== true_rtx
)
3994 else if (cond
== false_rtx
)
3997 return attr_rtx (NOT
, cond
);
4000 for (i
= 0; i
< XVECLEN (exp
, 0); i
+= 2)
4002 cond
= simplify_with_current_value_aux (XVECEXP (exp
, 0, i
));
4003 if (cond
== true_rtx
)
4004 return simplify_with_current_value_aux (XVECEXP (exp
, 0, i
+ 1));
4005 else if (cond
== false_rtx
)
4008 abort (); /* With all EQ_ATTR's of known value, a case should
4009 have been selected. */
4011 return simplify_with_current_value_aux (XEXP (exp
, 1));
4018 /* Clear the MEM_IN_STRUCT_P flag in EXP and its subexpressions. */
4021 clear_struct_flag (x
)
4026 register enum rtx_code code
;
4029 MEM_IN_STRUCT_P (x
) = 0;
4030 if (RTX_UNCHANGING_P (x
))
4033 code
= GET_CODE (x
);
4053 /* Compare the elements. If any pair of corresponding elements
4054 fail to match, return 0 for the whole things. */
4056 fmt
= GET_RTX_FORMAT (code
);
4057 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
4063 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
4064 clear_struct_flag (XVECEXP (x
, i
, j
));
4068 clear_struct_flag (XEXP (x
, i
));
4074 /* Return the number of RTX objects making up the expression X.
4075 But if we count more than MAX objects, stop counting. */
4078 count_sub_rtxs (x
, max
)
4084 register enum rtx_code code
;
4088 code
= GET_CODE (x
);
4108 /* Compare the elements. If any pair of corresponding elements
4109 fail to match, return 0 for the whole things. */
4111 fmt
= GET_RTX_FORMAT (code
);
4112 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
4121 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
4122 total
+= count_sub_rtxs (XVECEXP (x
, i
, j
), max
);
4126 total
+= count_sub_rtxs (XEXP (x
, i
), max
);
4134 /* Create table entries for DEFINE_ATTR. */
4140 struct attr_desc
*attr
;
4141 struct attr_value
*av
;
4145 /* Make a new attribute structure. Check for duplicate by looking at
4146 attr->default_val, since it is initialized by this routine. */
4147 attr
= find_attr (XSTR (exp
, 0), 1);
4148 if (attr
->default_val
)
4149 fatal ("Duplicate definition for `%s' attribute", attr
->name
);
4151 if (*XSTR (exp
, 1) == '\0')
4152 attr
->is_numeric
= 1;
4155 name_ptr
= XSTR (exp
, 1);
4156 while ((p
= next_comma_elt (&name_ptr
)) != NULL
)
4158 av
= (struct attr_value
*) oballoc (sizeof (struct attr_value
));
4159 av
->value
= attr_rtx (CONST_STRING
, p
);
4160 av
->next
= attr
->first_value
;
4161 attr
->first_value
= av
;
4162 av
->first_insn
= NULL
;
4164 av
->has_asm_insn
= 0;
4168 if (GET_CODE (XEXP (exp
, 2)) == CONST
)
4171 if (attr
->is_numeric
)
4172 fatal ("Constant attributes may not take numeric values");
4173 /* Get rid of the CONST node. It is allowed only at top-level. */
4174 XEXP (exp
, 2) = XEXP (XEXP (exp
, 2), 0);
4177 if (! strcmp (attr
->name
, "length") && ! attr
->is_numeric
)
4178 fatal ("`length' attribute must take numeric values");
4180 /* Set up the default value. */
4181 XEXP (exp
, 2) = check_attr_value (XEXP (exp
, 2), attr
);
4182 attr
->default_val
= get_attr_value (XEXP (exp
, 2), attr
, -2);
4185 /* Given a pattern for DEFINE_PEEPHOLE or DEFINE_INSN, return the number of
4186 alternatives in the constraints. Assume all MATCH_OPERANDs have the same
4187 number of alternatives as this should be checked elsewhere. */
4190 count_alternatives (exp
)
4196 if (GET_CODE (exp
) == MATCH_OPERAND
)
4197 return n_comma_elts (XSTR (exp
, 2));
4199 for (i
= 0, fmt
= GET_RTX_FORMAT (GET_CODE (exp
));
4200 i
< GET_RTX_LENGTH (GET_CODE (exp
)); i
++)
4205 n
= count_alternatives (XEXP (exp
, i
));
4212 if (XVEC (exp
, i
) != NULL
)
4213 for (j
= 0; j
< XVECLEN (exp
, i
); j
++)
4215 n
= count_alternatives (XVECEXP (exp
, i
, j
));
4224 /* Returns non-zero if the given expression contains an EQ_ATTR with the
4225 `alternative' attribute. */
4228 compares_alternatives_p (exp
)
4234 if (GET_CODE (exp
) == EQ_ATTR
&& XSTR (exp
, 0) == alternative_name
)
4237 for (i
= 0, fmt
= GET_RTX_FORMAT (GET_CODE (exp
));
4238 i
< GET_RTX_LENGTH (GET_CODE (exp
)); i
++)
4243 if (compares_alternatives_p (XEXP (exp
, i
)))
4248 for (j
= 0; j
< XVECLEN (exp
, i
); j
++)
4249 if (compares_alternatives_p (XVECEXP (exp
, i
, j
)))
4257 /* Returns non-zero is INNER is contained in EXP. */
4260 contained_in_p (inner
, exp
)
4267 if (rtx_equal_p (inner
, exp
))
4270 for (i
= 0, fmt
= GET_RTX_FORMAT (GET_CODE (exp
));
4271 i
< GET_RTX_LENGTH (GET_CODE (exp
)); i
++)
4276 if (contained_in_p (inner
, XEXP (exp
, i
)))
4281 for (j
= 0; j
< XVECLEN (exp
, i
); j
++)
4282 if (contained_in_p (inner
, XVECEXP (exp
, i
, j
)))
4290 /* Process DEFINE_PEEPHOLE, DEFINE_INSN, and DEFINE_ASM_ATTRIBUTES. */
4296 struct insn_def
*id
;
4298 id
= (struct insn_def
*) oballoc (sizeof (struct insn_def
));
4303 switch (GET_CODE (exp
))
4306 id
->insn_code
= insn_code_number
++;
4307 id
->insn_index
= insn_index_number
++;
4308 id
->num_alternatives
= count_alternatives (exp
);
4309 if (id
->num_alternatives
== 0)
4310 id
->num_alternatives
= 1;
4314 case DEFINE_PEEPHOLE
:
4315 id
->insn_code
= insn_code_number
++;
4316 id
->insn_index
= insn_index_number
++;
4317 id
->num_alternatives
= count_alternatives (exp
);
4318 if (id
->num_alternatives
== 0)
4319 id
->num_alternatives
= 1;
4323 case DEFINE_ASM_ATTRIBUTES
:
4325 id
->insn_index
= -1;
4326 id
->num_alternatives
= 1;
4328 got_define_asm_attributes
= 1;
4336 /* Process a DEFINE_DELAY. Validate the vector length, check if annul
4337 true or annul false is specified, and make a `struct delay_desc'. */
4343 struct delay_desc
*delay
;
4346 if (XVECLEN (def
, 1) % 3 != 0)
4347 fatal ("Number of elements in DEFINE_DELAY must be multiple of three.");
4349 for (i
= 0; i
< XVECLEN (def
, 1); i
+= 3)
4351 if (XVECEXP (def
, 1, i
+ 1))
4352 have_annul_true
= 1;
4353 if (XVECEXP (def
, 1, i
+ 2))
4354 have_annul_false
= 1;
4357 delay
= (struct delay_desc
*) oballoc (sizeof (struct delay_desc
));
4359 delay
->num
= ++num_delays
;
4360 delay
->next
= delays
;
4364 /* Process a DEFINE_FUNCTION_UNIT.
4366 This gives information about a function unit contained in the CPU.
4367 We fill in a `struct function_unit_op' and a `struct function_unit'
4368 with information used later by `expand_unit'. */
4374 struct function_unit
*unit
;
4375 struct function_unit_op
*op
;
4376 char *name
= XSTR (def
, 0);
4377 int multiplicity
= XINT (def
, 1);
4378 int simultaneity
= XINT (def
, 2);
4379 rtx condexp
= XEXP (def
, 3);
4380 int ready_cost
= MAX (XINT (def
, 4), 1);
4381 int issue_delay
= MAX (XINT (def
, 5), 1);
4383 /* See if we have already seen this function unit. If so, check that
4384 the multiplicity and simultaneity values are the same. If not, make
4385 a structure for this function unit. */
4386 for (unit
= units
; unit
; unit
= unit
->next
)
4387 if (! strcmp (unit
->name
, name
))
4389 if (unit
->multiplicity
!= multiplicity
4390 || unit
->simultaneity
!= simultaneity
)
4391 fatal ("Differing specifications given for `%s' function unit.",
4398 unit
= (struct function_unit
*) oballoc (sizeof (struct function_unit
));
4400 unit
->multiplicity
= multiplicity
;
4401 unit
->simultaneity
= simultaneity
;
4402 unit
->issue_delay
.min
= unit
->issue_delay
.max
= issue_delay
;
4403 unit
->num
= num_units
++;
4404 unit
->num_opclasses
= 0;
4405 unit
->condexp
= false_rtx
;
4411 /* Make a new operation class structure entry and initialize it. */
4412 op
= (struct function_unit_op
*) oballoc (sizeof (struct function_unit_op
));
4413 op
->condexp
= condexp
;
4414 op
->num
= unit
->num_opclasses
++;
4415 op
->ready
= ready_cost
;
4416 op
->issue_delay
= issue_delay
;
4417 op
->next
= unit
->ops
;
4419 num_unit_opclasses
++;
4421 /* Set our issue expression based on whether or not an optional conflict
4422 vector was specified. */
4425 /* Compute the IOR of all the specified expressions. */
4426 rtx orexp
= false_rtx
;
4429 for (i
= 0; i
< XVECLEN (def
, 6); i
++)
4430 orexp
= insert_right_side (IOR
, orexp
, XVECEXP (def
, 6, i
), -2, -2);
4432 op
->conflict_exp
= orexp
;
4433 extend_range (&unit
->issue_delay
, 1, issue_delay
);
4437 op
->conflict_exp
= true_rtx
;
4438 extend_range (&unit
->issue_delay
, issue_delay
, issue_delay
);
4441 /* Merge our conditional into that of the function unit so we can determine
4442 which insns are used by the function unit. */
4443 unit
->condexp
= insert_right_side (IOR
, unit
->condexp
, op
->condexp
, -2, -2);
4446 /* Given a piece of RTX, print a C expression to test its truth value.
4447 We use AND and IOR both for logical and bit-wise operations, so
4448 interpret them as logical unless they are inside a comparison expression.
4449 The first bit of FLAGS will be non-zero in that case.
4451 Set the second bit of FLAGS to make references to attribute values use
4452 a cached local variable instead of calling a function. */
4455 write_test_expr (exp
, flags
)
4459 int comparison_operator
= 0;
4461 struct attr_desc
*attr
;
4463 /* In order not to worry about operator precedence, surround our part of
4464 the expression with parentheses. */
4467 code
= GET_CODE (exp
);
4470 /* Binary operators. */
4472 case GE
: case GT
: case GEU
: case GTU
:
4473 case LE
: case LT
: case LEU
: case LTU
:
4474 comparison_operator
= 1;
4476 case PLUS
: case MINUS
: case MULT
: case DIV
: case MOD
:
4477 case AND
: case IOR
: case XOR
:
4478 case ASHIFT
: case LSHIFTRT
: case ASHIFTRT
:
4479 write_test_expr (XEXP (exp
, 0), flags
| comparison_operator
);
4495 printf (" >= (unsigned) ");
4498 printf (" > (unsigned) ");
4507 printf (" <= (unsigned) ");
4510 printf (" < (unsigned) ");
4553 write_test_expr (XEXP (exp
, 1), flags
| comparison_operator
);
4557 /* Special-case (not (eq_attrq "alternative" "x")) */
4558 if (! (flags
& 1) && GET_CODE (XEXP (exp
, 0)) == EQ_ATTR
4559 && XSTR (XEXP (exp
, 0), 0) == alternative_name
)
4561 printf ("which_alternative != %s", XSTR (XEXP (exp
, 0), 1));
4565 /* Otherwise, fall through to normal unary operator. */
4567 /* Unary operators. */
4587 write_test_expr (XEXP (exp
, 0), flags
);
4590 /* Comparison test of an attribute with a value. Most of these will
4591 have been removed by optimization. Handle "alternative"
4592 specially and give error if EQ_ATTR present inside a comparison. */
4595 fatal ("EQ_ATTR not valid inside comparison");
4597 if (XSTR (exp
, 0) == alternative_name
)
4599 printf ("which_alternative == %s", XSTR (exp
, 1));
4603 attr
= find_attr (XSTR (exp
, 0), 0);
4604 if (! attr
) abort ();
4606 /* Now is the time to expand the value of a constant attribute. */
4609 write_test_expr (evaluate_eq_attr (exp
, attr
->default_val
->value
,
4616 printf ("attr_%s", attr
->name
);
4618 printf ("get_attr_%s (insn)", attr
->name
);
4620 write_attr_valueq (attr
, XSTR (exp
, 1));
4624 /* Comparison test of flags for define_delays. */
4627 fatal ("ATTR_FLAG not valid inside comparison");
4628 printf ("(flags & ATTR_FLAG_%s) != 0", XSTR (exp
, 0));
4631 /* See if an operand matches a predicate. */
4633 /* If only a mode is given, just ensure the mode matches the operand.
4634 If neither a mode nor predicate is given, error. */
4635 if (XSTR (exp
, 1) == NULL
|| *XSTR (exp
, 1) == '\0')
4637 if (GET_MODE (exp
) == VOIDmode
)
4638 fatal ("Null MATCH_OPERAND specified as test");
4640 printf ("GET_MODE (operands[%d]) == %smode",
4641 XINT (exp
, 0), GET_MODE_NAME (GET_MODE (exp
)));
4644 printf ("%s (operands[%d], %smode)",
4645 XSTR (exp
, 1), XINT (exp
, 0), GET_MODE_NAME (GET_MODE (exp
)));
4649 printf ("%s (insn)", XSTR (exp
, 0));
4652 /* Constant integer. */
4654 printf (HOST_WIDE_INT_PRINT_DEC
, XWINT (exp
, 0));
4657 /* A random C expression. */
4659 printf ("%s", XSTR (exp
, 0));
4662 /* The address of the branch target. */
4664 printf ("insn_addresses[INSN_UID (GET_CODE (operands[%d]) == LABEL_REF ? XEXP (operands[%d], 0) : operands[%d])]",
4665 XINT (exp
, 0), XINT (exp
, 0), XINT (exp
, 0));
4669 /* The address of the current insn. We implement this actually as the
4670 address of the current insn for backward branches, but the last
4671 address of the next insn for forward branches, and both with
4672 adjustments that account for the worst-case possible stretching of
4673 intervening alignments between this insn and its destination. */
4674 printf("insn_current_reference_address (insn)");
4678 printf ("%s", XSTR (exp
, 0));
4682 write_test_expr (XEXP (exp
, 0), flags
& 2);
4684 write_test_expr (XEXP (exp
, 1), flags
| 1);
4686 write_test_expr (XEXP (exp
, 2), flags
| 1);
4690 fatal ("bad RTX code `%s' in attribute calculation\n",
4691 GET_RTX_NAME (code
));
4697 /* Given an attribute value, return the maximum CONST_STRING argument
4698 encountered. Set *UNKNOWNP and return INT_MAX if the value is unknown. */
4701 max_attr_value (exp
, unknownp
)
4708 switch (GET_CODE (exp
))
4711 current_max
= atoi (XSTR (exp
, 0));
4715 current_max
= max_attr_value (XEXP (exp
, 1), unknownp
);
4716 for (i
= 0; i
< XVECLEN (exp
, 0); i
+= 2)
4718 n
= max_attr_value (XVECEXP (exp
, 0, i
+ 1), unknownp
);
4719 if (n
> current_max
)
4725 current_max
= max_attr_value (XEXP (exp
, 1), unknownp
);
4726 n
= max_attr_value (XEXP (exp
, 2), unknownp
);
4727 if (n
> current_max
)
4733 current_max
= INT_MAX
;
4740 /* Given an attribute value, return the result of ORing together all
4741 CONST_STRING arguments encountered. Set *UNKNOWNP and return -1
4742 if the numeric value is not known. */
4745 or_attr_value (exp
, unknownp
)
4752 switch (GET_CODE (exp
))
4755 current_or
= atoi (XSTR (exp
, 0));
4759 current_or
= or_attr_value (XEXP (exp
, 1), unknownp
);
4760 for (i
= 0; i
< XVECLEN (exp
, 0); i
+= 2)
4761 current_or
|= or_attr_value (XVECEXP (exp
, 0, i
+ 1), unknownp
);
4765 current_or
= or_attr_value (XEXP (exp
, 1), unknownp
);
4766 current_or
|= or_attr_value (XEXP (exp
, 2), unknownp
);
4778 /* Scan an attribute value, possibly a conditional, and record what actions
4779 will be required to do any conditional tests in it.
4782 `must_extract' if we need to extract the insn operands
4783 `must_constrain' if we must compute `which_alternative'
4784 `address_used' if an address expression was used
4785 `length_used' if an (eq_attr "length" ...) was used
4789 walk_attr_value (exp
)
4799 code
= GET_CODE (exp
);
4803 if (! RTX_UNCHANGING_P (exp
))
4804 /* Since this is an arbitrary expression, it can look at anything.
4805 However, constant expressions do not depend on any particular
4807 must_extract
= must_constrain
= 1;
4815 if (XSTR (exp
, 0) == alternative_name
)
4816 must_extract
= must_constrain
= 1;
4817 else if (strcmp (XSTR (exp
, 0), "length") == 0)
4837 for (i
= 0, fmt
= GET_RTX_FORMAT (code
); i
< GET_RTX_LENGTH (code
); i
++)
4842 walk_attr_value (XEXP (exp
, i
));
4846 if (XVEC (exp
, i
) != NULL
)
4847 for (j
= 0; j
< XVECLEN (exp
, i
); j
++)
4848 walk_attr_value (XVECEXP (exp
, i
, j
));
4853 /* Write out a function to obtain the attribute for a given INSN. */
4856 write_attr_get (attr
)
4857 struct attr_desc
*attr
;
4859 struct attr_value
*av
, *common_av
;
4861 /* Find the most used attribute value. Handle that as the `default' of the
4862 switch we will generate. */
4863 common_av
= find_most_used (attr
);
4865 /* Write out start of function, then all values with explicit `case' lines,
4866 then a `default', then the value with the most uses. */
4867 if (!attr
->is_numeric
)
4868 printf ("enum attr_%s\n", attr
->name
);
4869 else if (attr
->unsigned_p
)
4870 printf ("unsigned int\n");
4874 /* If the attribute name starts with a star, the remainder is the name of
4875 the subroutine to use, instead of `get_attr_...'. */
4876 if (attr
->name
[0] == '*')
4877 printf ("%s (insn)\n", &attr
->name
[1]);
4878 else if (attr
->is_const
== 0)
4879 printf ("get_attr_%s (insn)\n", attr
->name
);
4882 printf ("get_attr_%s ()\n", attr
->name
);
4885 for (av
= attr
->first_value
; av
; av
= av
->next
)
4886 if (av
->num_insns
!= 0)
4887 write_attr_set (attr
, 2, av
->value
, "return", ";",
4888 true_rtx
, av
->first_insn
->insn_code
,
4889 av
->first_insn
->insn_index
);
4895 printf (" rtx insn;\n");
4898 if (GET_CODE (common_av
->value
) == FFS
)
4900 rtx p
= XEXP (common_av
->value
, 0);
4902 /* No need to emit code to abort if the insn is unrecognized; the
4903 other get_attr_foo functions will do that when we call them. */
4905 write_toplevel_expr (p
);
4907 printf ("\n if (accum && accum == (accum & -accum))\n");
4909 printf (" int i;\n");
4910 printf (" for (i = 0; accum >>= 1; ++i) continue;\n");
4911 printf (" accum = i;\n");
4912 printf (" }\n else\n");
4913 printf (" accum = ~accum;\n");
4914 printf (" return accum;\n}\n\n");
4918 printf (" switch (recog_memoized (insn))\n");
4921 for (av
= attr
->first_value
; av
; av
= av
->next
)
4922 if (av
!= common_av
)
4923 write_attr_case (attr
, av
, 1, "return", ";", 4, true_rtx
);
4925 write_attr_case (attr
, common_av
, 0, "return", ";", 4, true_rtx
);
4926 printf (" }\n}\n\n");
4930 /* Given an AND tree of known true terms (because we are inside an `if' with
4931 that as the condition or are in an `else' clause) and an expression,
4932 replace any known true terms with TRUE. Use `simplify_and_tree' to do
4933 the bulk of the work. */
4936 eliminate_known_true (known_true
, exp
, insn_code
, insn_index
)
4939 int insn_code
, insn_index
;
4943 known_true
= SIMPLIFY_TEST_EXP (known_true
, insn_code
, insn_index
);
4945 if (GET_CODE (known_true
) == AND
)
4947 exp
= eliminate_known_true (XEXP (known_true
, 0), exp
,
4948 insn_code
, insn_index
);
4949 exp
= eliminate_known_true (XEXP (known_true
, 1), exp
,
4950 insn_code
, insn_index
);
4955 exp
= simplify_and_tree (exp
, &term
, insn_code
, insn_index
);
4961 /* Write out a series of tests and assignment statements to perform tests and
4962 sets of an attribute value. We are passed an indentation amount and prefix
4963 and suffix strings to write around each attribute value (e.g., "return"
4967 write_attr_set (attr
, indent
, value
, prefix
, suffix
, known_true
,
4968 insn_code
, insn_index
)
4969 struct attr_desc
*attr
;
4975 int insn_code
, insn_index
;
4977 if (GET_CODE (value
) == COND
)
4979 /* Assume the default value will be the default of the COND unless we
4980 find an always true expression. */
4981 rtx default_val
= XEXP (value
, 1);
4982 rtx our_known_true
= known_true
;
4987 for (i
= 0; i
< XVECLEN (value
, 0); i
+= 2)
4992 testexp
= eliminate_known_true (our_known_true
,
4993 XVECEXP (value
, 0, i
),
4994 insn_code
, insn_index
);
4995 newexp
= attr_rtx (NOT
, testexp
);
4996 newexp
= insert_right_side (AND
, our_known_true
, newexp
,
4997 insn_code
, insn_index
);
4999 /* If the test expression is always true or if the next `known_true'
5000 expression is always false, this is the last case, so break
5001 out and let this value be the `else' case. */
5002 if (testexp
== true_rtx
|| newexp
== false_rtx
)
5004 default_val
= XVECEXP (value
, 0, i
+ 1);
5008 /* Compute the expression to pass to our recursive call as being
5010 inner_true
= insert_right_side (AND
, our_known_true
,
5011 testexp
, insn_code
, insn_index
);
5013 /* If this is always false, skip it. */
5014 if (inner_true
== false_rtx
)
5017 write_indent (indent
);
5018 printf ("%sif ", first_if
? "" : "else ");
5020 write_test_expr (testexp
, 0);
5022 write_indent (indent
+ 2);
5025 write_attr_set (attr
, indent
+ 4,
5026 XVECEXP (value
, 0, i
+ 1), prefix
, suffix
,
5027 inner_true
, insn_code
, insn_index
);
5028 write_indent (indent
+ 2);
5030 our_known_true
= newexp
;
5035 write_indent (indent
);
5037 write_indent (indent
+ 2);
5041 write_attr_set (attr
, first_if
? indent
: indent
+ 4, default_val
,
5042 prefix
, suffix
, our_known_true
, insn_code
, insn_index
);
5046 write_indent (indent
+ 2);
5052 write_indent (indent
);
5053 printf ("%s ", prefix
);
5054 write_attr_value (attr
, value
);
5055 printf ("%s\n", suffix
);
5059 /* Write out the computation for one attribute value. */
5062 write_attr_case (attr
, av
, write_case_lines
, prefix
, suffix
, indent
,
5064 struct attr_desc
*attr
;
5065 struct attr_value
*av
;
5066 int write_case_lines
;
5067 const char *prefix
, *suffix
;
5071 struct insn_ent
*ie
;
5073 if (av
->num_insns
== 0)
5076 if (av
->has_asm_insn
)
5078 write_indent (indent
);
5079 printf ("case -1:\n");
5080 write_indent (indent
+ 2);
5081 printf ("if (GET_CODE (PATTERN (insn)) != ASM_INPUT\n");
5082 write_indent (indent
+ 2);
5083 printf (" && asm_noperands (PATTERN (insn)) < 0)\n");
5084 write_indent (indent
+ 2);
5085 printf (" fatal_insn_not_found (insn);\n");
5088 if (write_case_lines
)
5090 for (ie
= av
->first_insn
; ie
; ie
= ie
->next
)
5091 if (ie
->insn_code
!= -1)
5093 write_indent (indent
);
5094 printf ("case %d:\n", ie
->insn_code
);
5099 write_indent (indent
);
5100 printf ("default:\n");
5103 /* See what we have to do to output this value. */
5104 must_extract
= must_constrain
= address_used
= 0;
5105 walk_attr_value (av
->value
);
5109 write_indent (indent
+ 2);
5110 printf ("extract_insn (insn);\n");
5115 #ifdef REGISTER_CONSTRAINTS
5116 write_indent (indent
+ 2);
5117 printf ("if (! constrain_operands (reload_completed))\n");
5118 write_indent (indent
+ 2);
5119 printf (" fatal_insn_not_found (insn);\n");
5123 write_attr_set (attr
, indent
+ 2, av
->value
, prefix
, suffix
,
5124 known_true
, av
->first_insn
->insn_code
,
5125 av
->first_insn
->insn_index
);
5127 if (strncmp (prefix
, "return", 6))
5129 write_indent (indent
+ 2);
5130 printf ("break;\n");
5135 /* Search for uses of non-const attributes and write code to cache them. */
5138 write_expr_attr_cache (p
, attr
)
5140 struct attr_desc
*attr
;
5145 if (GET_CODE (p
) == EQ_ATTR
)
5147 if (XSTR (p
, 0) != attr
->name
)
5150 if (!attr
->is_numeric
)
5151 printf (" register enum attr_%s ", attr
->name
);
5152 else if (attr
->unsigned_p
)
5153 printf (" register unsigned int ");
5155 printf (" register int ");
5157 printf ("attr_%s = get_attr_%s (insn);\n", attr
->name
, attr
->name
);
5161 fmt
= GET_RTX_FORMAT (GET_CODE (p
));
5162 ie
= GET_RTX_LENGTH (GET_CODE (p
));
5163 for (i
= 0; i
< ie
; i
++)
5168 if (write_expr_attr_cache (XEXP (p
, i
), attr
))
5173 je
= XVECLEN (p
, i
);
5174 for (j
= 0; j
< je
; ++j
)
5175 if (write_expr_attr_cache (XVECEXP (p
, i
, j
), attr
))
5184 /* Evaluate an expression at top level. A front end to write_test_expr,
5185 in which we cache attribute values and break up excessively large
5186 expressions to cater to older compilers. */
5189 write_toplevel_expr (p
)
5192 struct attr_desc
*attr
;
5195 for (i
= 0; i
< MAX_ATTRS_INDEX
; ++i
)
5196 for (attr
= attrs
[i
]; attr
; attr
= attr
->next
)
5197 if (!attr
->is_const
)
5198 write_expr_attr_cache (p
, attr
);
5200 printf(" register unsigned long accum = 0;\n\n");
5202 while (GET_CODE (p
) == IOR
)
5205 if (GET_CODE (XEXP (p
, 0)) == IOR
)
5206 e
= XEXP (p
, 1), p
= XEXP (p
, 0);
5208 e
= XEXP (p
, 0), p
= XEXP (p
, 1);
5210 printf (" accum |= ");
5211 write_test_expr (e
, 3);
5214 printf (" accum |= ");
5215 write_test_expr (p
, 3);
5219 /* Utilities to write names in various forms. */
5222 write_unit_name (prefix
, num
, suffix
)
5227 struct function_unit
*unit
;
5229 for (unit
= units
; unit
; unit
= unit
->next
)
5230 if (unit
->num
== num
)
5232 printf ("%s%s%s", prefix
, unit
->name
, suffix
);
5236 printf ("%s<unknown>%s", prefix
, suffix
);
5240 write_attr_valueq (attr
, s
)
5241 struct attr_desc
*attr
;
5244 if (attr
->is_numeric
)
5250 /* Make the blockage range values and function units used values easier
5252 if (attr
->func_units_p
)
5255 printf (" /* units: none */");
5257 write_unit_name (" /* units: ", num
, " */");
5261 const char *sep
= " /* units: ";
5262 for (i
= 0, num
= ~num
; num
; i
++, num
>>= 1)
5265 write_unit_name (sep
, i
, (num
== 1) ? " */" : "");
5271 else if (attr
->blockage_p
)
5272 printf (" /* min %d, max %d */", num
>> (HOST_BITS_PER_INT
/ 2),
5273 num
& ((1 << (HOST_BITS_PER_INT
/ 2)) - 1));
5275 else if (num
> 9 || num
< 0)
5276 printf (" /* 0x%x */", num
);
5280 write_upcase (attr
->name
);
5287 write_attr_value (attr
, value
)
5288 struct attr_desc
*attr
;
5293 switch (GET_CODE (value
))
5296 write_attr_valueq (attr
, XSTR (value
, 0));
5300 fputs (XSTR (value
, 0), stdout
);
5305 struct attr_desc
*attr2
= find_attr (XSTR (value
, 0), 0);
5306 printf ("get_attr_%s (%s)", attr2
->name
,
5307 (attr2
->is_const
? "" : "insn"));
5328 write_attr_value (attr
, XEXP (value
, 0));
5332 write_attr_value (attr
, XEXP (value
, 1));
5345 if (*str
< 'a' || *str
> 'z')
5346 printf ("%c", *str
++);
5348 printf ("%c", *str
++ - 'a' + 'A');
5352 write_indent (indent
)
5355 for (; indent
> 8; indent
-= 8)
5358 for (; indent
; indent
--)
5362 /* Write a subroutine that is given an insn that requires a delay slot, a
5363 delay slot ordinal, and a candidate insn. It returns non-zero if the
5364 candidate can be placed in the specified delay slot of the insn.
5366 We can write as many as three subroutines. `eligible_for_delay'
5367 handles normal delay slots, `eligible_for_annul_true' indicates that
5368 the specified insn can be annulled if the branch is true, and likewise
5369 for `eligible_for_annul_false'.
5371 KIND is a string distinguishing these three cases ("delay", "annul_true",
5372 or "annul_false"). */
5375 write_eligible_delay (kind
)
5378 struct delay_desc
*delay
;
5381 struct attr_desc
*attr
;
5382 struct attr_value
*av
, *common_av
;
5385 /* Compute the maximum number of delay slots required. We use the delay
5386 ordinal times this number plus one, plus the slot number as an index into
5387 the appropriate predicate to test. */
5389 for (delay
= delays
, max_slots
= 0; delay
; delay
= delay
->next
)
5390 if (XVECLEN (delay
->def
, 1) / 3 > max_slots
)
5391 max_slots
= XVECLEN (delay
->def
, 1) / 3;
5393 /* Write function prelude. */
5396 printf ("eligible_for_%s (delay_insn, slot, candidate_insn, flags)\n",
5398 printf (" rtx delay_insn;\n");
5399 printf (" int slot;\n");
5400 printf (" rtx candidate_insn;\n");
5401 printf (" int flags;\n");
5403 printf (" rtx insn;\n");
5405 printf (" if (slot >= %d)\n", max_slots
);
5406 printf (" abort ();\n");
5409 /* If more than one delay type, find out which type the delay insn is. */
5413 attr
= find_attr ("*delay_type", 0);
5414 if (! attr
) abort ();
5415 common_av
= find_most_used (attr
);
5417 printf (" insn = delay_insn;\n");
5418 printf (" switch (recog_memoized (insn))\n");
5421 sprintf (str
, " * %d;\n break;", max_slots
);
5422 for (av
= attr
->first_value
; av
; av
= av
->next
)
5423 if (av
!= common_av
)
5424 write_attr_case (attr
, av
, 1, "slot +=", str
, 4, true_rtx
);
5426 write_attr_case (attr
, common_av
, 0, "slot +=", str
, 4, true_rtx
);
5429 /* Ensure matched. Otherwise, shouldn't have been called. */
5430 printf (" if (slot < %d)\n", max_slots
);
5431 printf (" abort ();\n\n");
5434 /* If just one type of delay slot, write simple switch. */
5435 if (num_delays
== 1 && max_slots
== 1)
5437 printf (" insn = candidate_insn;\n");
5438 printf (" switch (recog_memoized (insn))\n");
5441 attr
= find_attr ("*delay_1_0", 0);
5442 if (! attr
) abort ();
5443 common_av
= find_most_used (attr
);
5445 for (av
= attr
->first_value
; av
; av
= av
->next
)
5446 if (av
!= common_av
)
5447 write_attr_case (attr
, av
, 1, "return", ";", 4, true_rtx
);
5449 write_attr_case (attr
, common_av
, 0, "return", ";", 4, true_rtx
);
5455 /* Write a nested CASE. The first indicates which condition we need to
5456 test, and the inner CASE tests the condition. */
5457 printf (" insn = candidate_insn;\n");
5458 printf (" switch (slot)\n");
5461 for (delay
= delays
; delay
; delay
= delay
->next
)
5462 for (i
= 0; i
< XVECLEN (delay
->def
, 1); i
+= 3)
5464 printf (" case %d:\n",
5465 (i
/ 3) + (num_delays
== 1 ? 0 : delay
->num
* max_slots
));
5466 printf (" switch (recog_memoized (insn))\n");
5469 sprintf (str
, "*%s_%d_%d", kind
, delay
->num
, i
/ 3);
5470 attr
= find_attr (str
, 0);
5471 if (! attr
) abort ();
5472 common_av
= find_most_used (attr
);
5474 for (av
= attr
->first_value
; av
; av
= av
->next
)
5475 if (av
!= common_av
)
5476 write_attr_case (attr
, av
, 1, "return", ";", 8, true_rtx
);
5478 write_attr_case (attr
, common_av
, 0, "return", ";", 8, true_rtx
);
5482 printf (" default:\n");
5483 printf (" abort ();\n");
5490 /* Write routines to compute conflict cost for function units. Then write a
5491 table describing the available function units. */
5494 write_function_unit_info ()
5496 struct function_unit
*unit
;
5499 /* Write out conflict routines for function units. Don't bother writing
5500 one if there is only one issue delay value. */
5502 for (unit
= units
; unit
; unit
= unit
->next
)
5504 if (unit
->needs_blockage_function
)
5505 write_complex_function (unit
, "blockage", "block");
5507 /* If the minimum and maximum conflict costs are the same, there
5508 is only one value, so we don't need a function. */
5509 if (! unit
->needs_conflict_function
)
5511 unit
->default_cost
= make_numeric_value (unit
->issue_delay
.max
);
5515 /* The function first computes the case from the candidate insn. */
5516 unit
->default_cost
= make_numeric_value (0);
5517 write_complex_function (unit
, "conflict_cost", "cost");
5520 /* Now that all functions have been written, write the table describing
5521 the function units. The name is included for documentation purposes
5524 printf ("struct function_unit_desc function_units[] = {\n");
5526 /* Write out the descriptions in numeric order, but don't force that order
5527 on the list. Doing so increases the runtime of genattrtab.c. */
5528 for (i
= 0; i
< num_units
; i
++)
5530 for (unit
= units
; unit
; unit
= unit
->next
)
5534 printf (" {\"%s\", %d, %d, %d, %s, %d, %s_unit_ready_cost, ",
5535 unit
->name
, 1 << unit
->num
, unit
->multiplicity
,
5536 unit
->simultaneity
, XSTR (unit
->default_cost
, 0),
5537 unit
->issue_delay
.max
, unit
->name
);
5539 if (unit
->needs_conflict_function
)
5540 printf ("%s_unit_conflict_cost, ", unit
->name
);
5544 printf ("%d, ", unit
->max_blockage
);
5546 if (unit
->needs_range_function
)
5547 printf ("%s_unit_blockage_range, ", unit
->name
);
5551 if (unit
->needs_blockage_function
)
5552 printf ("%s_unit_blockage", unit
->name
);
5563 write_complex_function (unit
, name
, connection
)
5564 struct function_unit
*unit
;
5565 const char *name
, *connection
;
5567 struct attr_desc
*case_attr
, *attr
;
5568 struct attr_value
*av
, *common_av
;
5574 printf ("static int\n");
5575 printf ("%s_unit_%s (executing_insn, candidate_insn)\n",
5577 printf (" rtx executing_insn;\n");
5578 printf (" rtx candidate_insn;\n");
5580 printf (" rtx insn;\n");
5581 printf (" int casenum;\n\n");
5582 printf (" insn = executing_insn;\n");
5583 printf (" switch (recog_memoized (insn))\n");
5586 /* Write the `switch' statement to get the case value. */
5587 str
= (char *) alloca (strlen (unit
->name
) + strlen (name
) + strlen (connection
) + 10);
5588 sprintf (str
, "*%s_cases", unit
->name
);
5589 case_attr
= find_attr (str
, 0);
5590 if (! case_attr
) abort ();
5591 common_av
= find_most_used (case_attr
);
5593 for (av
= case_attr
->first_value
; av
; av
= av
->next
)
5594 if (av
!= common_av
)
5595 write_attr_case (case_attr
, av
, 1,
5596 "casenum =", ";", 4, unit
->condexp
);
5598 write_attr_case (case_attr
, common_av
, 0,
5599 "casenum =", ";", 4, unit
->condexp
);
5602 /* Now write an outer switch statement on each case. Then write
5603 the tests on the executing function within each. */
5604 printf (" insn = candidate_insn;\n");
5605 printf (" switch (casenum)\n");
5608 for (i
= 0; i
< unit
->num_opclasses
; i
++)
5610 /* Ensure using this case. */
5612 for (av
= case_attr
->first_value
; av
; av
= av
->next
)
5614 && contained_in_p (make_numeric_value (i
), av
->value
))
5620 printf (" case %d:\n", i
);
5621 sprintf (str
, "*%s_%s_%d", unit
->name
, connection
, i
);
5622 attr
= find_attr (str
, 0);
5623 if (! attr
) abort ();
5625 /* If single value, just write it. */
5626 value
= find_single_value (attr
);
5628 write_attr_set (attr
, 6, value
, "return", ";\n", true_rtx
, -2, -2);
5631 common_av
= find_most_used (attr
);
5632 printf (" switch (recog_memoized (insn))\n");
5635 for (av
= attr
->first_value
; av
; av
= av
->next
)
5636 if (av
!= common_av
)
5637 write_attr_case (attr
, av
, 1,
5638 "return", ";", 8, unit
->condexp
);
5640 write_attr_case (attr
, common_av
, 0,
5641 "return", ";", 8, unit
->condexp
);
5646 /* This default case should not be needed, but gcc's analysis is not
5647 good enough to realize that the default case is not needed for the
5648 second switch statement. */
5649 printf (" default:\n abort ();\n");
5650 printf (" }\n}\n\n");
5653 /* This page contains miscellaneous utility routines. */
5655 /* Given a string, return the number of comma-separated elements in it.
5656 Return 0 for the null string. */
5667 for (n
= 1; *s
; s
++)
5674 /* Given a pointer to a (char *), return a malloc'ed string containing the
5675 next comma-separated element. Advance the pointer to after the string
5676 scanned, or the end-of-string. Return NULL if at end of string. */
5679 next_comma_elt (pstr
)
5688 /* Find end of string to compute length. */
5689 for (p
= *pstr
; *p
!= ',' && *p
!= '\0'; p
++)
5692 out_str
= attr_string (*pstr
, p
- *pstr
);
5701 /* Return a `struct attr_desc' pointer for a given named attribute. If CREATE
5702 is non-zero, build a new attribute, if one does not exist. */
5704 static struct attr_desc
*
5705 find_attr (name
, create
)
5709 struct attr_desc
*attr
;
5712 /* Before we resort to using `strcmp', see if the string address matches
5713 anywhere. In most cases, it should have been canonicalized to do so. */
5714 if (name
== alternative_name
)
5717 index
= name
[0] & (MAX_ATTRS_INDEX
- 1);
5718 for (attr
= attrs
[index
]; attr
; attr
= attr
->next
)
5719 if (name
== attr
->name
)
5722 /* Otherwise, do it the slow way. */
5723 for (attr
= attrs
[index
]; attr
; attr
= attr
->next
)
5724 if (name
[0] == attr
->name
[0] && ! strcmp (name
, attr
->name
))
5730 attr
= (struct attr_desc
*) oballoc (sizeof (struct attr_desc
));
5731 attr
->name
= attr_string (name
, strlen (name
));
5732 attr
->first_value
= attr
->default_val
= NULL
;
5733 attr
->is_numeric
= attr
->negative_ok
= attr
->is_const
= attr
->is_special
= 0;
5734 attr
->next
= attrs
[index
];
5735 attrs
[index
] = attr
;
5740 /* Create internal attribute with the given default value. */
5743 make_internal_attr (name
, value
, special
)
5748 struct attr_desc
*attr
;
5750 attr
= find_attr (name
, 1);
5751 if (attr
->default_val
)
5754 attr
->is_numeric
= 1;
5756 attr
->is_special
= (special
& 1) != 0;
5757 attr
->negative_ok
= (special
& 2) != 0;
5758 attr
->unsigned_p
= (special
& 4) != 0;
5759 attr
->func_units_p
= (special
& 8) != 0;
5760 attr
->blockage_p
= (special
& 16) != 0;
5761 attr
->default_val
= get_attr_value (value
, attr
, -2);
5764 /* Find the most used value of an attribute. */
5766 static struct attr_value
*
5767 find_most_used (attr
)
5768 struct attr_desc
*attr
;
5770 struct attr_value
*av
;
5771 struct attr_value
*most_used
;
5777 for (av
= attr
->first_value
; av
; av
= av
->next
)
5778 if (av
->num_insns
> nuses
)
5779 nuses
= av
->num_insns
, most_used
= av
;
5784 /* If an attribute only has a single value used, return it. Otherwise
5788 find_single_value (attr
)
5789 struct attr_desc
*attr
;
5791 struct attr_value
*av
;
5794 unique_value
= NULL
;
5795 for (av
= attr
->first_value
; av
; av
= av
->next
)
5801 unique_value
= av
->value
;
5804 return unique_value
;
5807 /* Return (attr_value "n") */
5810 make_numeric_value (n
)
5813 static rtx int_values
[20];
5820 if (n
< 20 && int_values
[n
])
5821 return int_values
[n
];
5823 p
= attr_printf (MAX_DIGITS
, "%d", n
);
5824 exp
= attr_rtx (CONST_STRING
, p
);
5827 int_values
[n
] = exp
;
5833 extend_range (range
, min
, max
)
5834 struct range
*range
;
5838 if (range
->min
> min
) range
->min
= min
;
5839 if (range
->max
< max
) range
->max
= max
;
5843 xrealloc (old
, size
)
5849 ptr
= (PTR
) realloc (old
, size
);
5851 ptr
= (PTR
) malloc (size
);
5853 fatal ("virtual memory exhausted");
5861 register PTR val
= (PTR
) malloc (size
);
5864 fatal ("virtual memory exhausted");
5869 copy_rtx_unchanging (orig
)
5874 register RTX_CODE code
;
5877 if (RTX_UNCHANGING_P (orig
) || MEM_IN_STRUCT_P (orig
))
5880 MEM_IN_STRUCT_P (orig
) = 1;
5884 code
= GET_CODE (orig
);
5897 copy
= rtx_alloc (code
);
5898 PUT_MODE (copy
, GET_MODE (orig
));
5899 RTX_UNCHANGING_P (copy
) = 1;
5901 bcopy ((char *) &XEXP (orig
, 0), (char *) &XEXP (copy
, 0),
5902 GET_RTX_LENGTH (GET_CODE (copy
)) * sizeof (rtx
));
5908 fatal
VPROTO ((const char *format
, ...))
5910 #ifndef ANSI_PROTOTYPES
5915 VA_START (ap
, format
);
5917 #ifndef ANSI_PROTOTYPES
5918 format
= va_arg (ap
, const char *);
5921 fprintf (stderr
, "genattrtab: ");
5922 vfprintf (stderr
, format
, ap
);
5924 fprintf (stderr
, "\n");
5925 exit (FATAL_EXIT_CODE
);
5928 /* More 'friendly' abort that prints the line and file.
5929 config.h can #define abort fancy_abort if you like that sort of thing. */
5934 fatal ("Internal gcc abort.");
5937 /* Determine if an insn has a constant number of delay slots, i.e., the
5938 number of delay slots is not a function of the length of the insn. */
5941 write_const_num_delay_slots ()
5943 struct attr_desc
*attr
= find_attr ("*num_delay_slots", 0);
5944 struct attr_value
*av
;
5945 struct insn_ent
*ie
;
5949 printf ("int\nconst_num_delay_slots (insn)\n");
5950 printf (" rtx insn;\n");
5952 printf (" switch (recog_memoized (insn))\n");
5955 for (av
= attr
->first_value
; av
; av
= av
->next
)
5958 walk_attr_value (av
->value
);
5961 for (ie
= av
->first_insn
; ie
; ie
= ie
->next
)
5962 if (ie
->insn_code
!= -1)
5963 printf (" case %d:\n", ie
->insn_code
);
5964 printf (" return 0;\n");
5968 printf (" default:\n");
5969 printf (" return 1;\n");
5970 printf (" }\n}\n\n");
5983 struct attr_desc
*attr
;
5984 struct insn_def
*id
;
5988 #if defined (RLIMIT_STACK) && defined (HAVE_GETRLIMIT) && defined (HAVE_SETRLIMIT)
5989 /* Get rid of any avoidable limit on stack size. */
5993 /* Set the stack limit huge so that alloca does not fail. */
5994 getrlimit (RLIMIT_STACK
, &rlim
);
5995 rlim
.rlim_cur
= rlim
.rlim_max
;
5996 setrlimit (RLIMIT_STACK
, &rlim
);
6000 obstack_init (rtl_obstack
);
6001 obstack_init (hash_obstack
);
6002 obstack_init (temp_obstack
);
6005 fatal ("No input file name.");
6007 infile
= fopen (argv
[1], "r");
6011 exit (FATAL_EXIT_CODE
);
6016 /* Set up true and false rtx's */
6017 true_rtx
= rtx_alloc (CONST_INT
);
6018 XWINT (true_rtx
, 0) = 1;
6019 false_rtx
= rtx_alloc (CONST_INT
);
6020 XWINT (false_rtx
, 0) = 0;
6021 RTX_UNCHANGING_P (true_rtx
) = RTX_UNCHANGING_P (false_rtx
) = 1;
6022 RTX_INTEGRATED_P (true_rtx
) = RTX_INTEGRATED_P (false_rtx
) = 1;
6024 alternative_name
= attr_string ("alternative", strlen ("alternative"));
6026 printf ("/* Generated automatically by the program `genattrtab'\n\
6027 from the machine description file `md'. */\n\n");
6029 /* Read the machine description. */
6033 c
= read_skip_spaces (infile
);
6038 desc
= read_rtx (infile
);
6039 if (GET_CODE (desc
) == DEFINE_INSN
6040 || GET_CODE (desc
) == DEFINE_PEEPHOLE
6041 || GET_CODE (desc
) == DEFINE_ASM_ATTRIBUTES
)
6044 else if (GET_CODE (desc
) == DEFINE_EXPAND
)
6045 insn_code_number
++, insn_index_number
++;
6047 else if (GET_CODE (desc
) == DEFINE_SPLIT
)
6048 insn_code_number
++, insn_index_number
++;
6050 else if (GET_CODE (desc
) == DEFINE_ATTR
)
6053 insn_index_number
++;
6056 else if (GET_CODE (desc
) == DEFINE_DELAY
)
6059 insn_index_number
++;
6062 else if (GET_CODE (desc
) == DEFINE_FUNCTION_UNIT
)
6065 insn_index_number
++;
6069 /* If we didn't have a DEFINE_ASM_ATTRIBUTES, make a null one. */
6070 if (! got_define_asm_attributes
)
6072 tem
= rtx_alloc (DEFINE_ASM_ATTRIBUTES
);
6073 XVEC (tem
, 0) = rtvec_alloc (0);
6077 /* Expand DEFINE_DELAY information into new attribute. */
6081 /* Expand DEFINE_FUNCTION_UNIT information into new attributes. */
6085 printf ("#include \"config.h\"\n");
6086 printf ("#include \"system.h\"\n");
6087 printf ("#include \"rtl.h\"\n");
6088 printf ("#include \"insn-config.h\"\n");
6089 printf ("#include \"recog.h\"\n");
6090 printf ("#include \"regs.h\"\n");
6091 printf ("#include \"real.h\"\n");
6092 printf ("#include \"output.h\"\n");
6093 printf ("#include \"insn-attr.h\"\n");
6094 printf ("#include \"toplev.h\"\n");
6096 printf ("#define operands recog_operand\n\n");
6098 /* Make `insn_alternatives'. */
6099 insn_alternatives
= (int *) oballoc (insn_code_number
* sizeof (int));
6100 for (id
= defs
; id
; id
= id
->next
)
6101 if (id
->insn_code
>= 0)
6102 insn_alternatives
[id
->insn_code
] = (1 << id
->num_alternatives
) - 1;
6104 /* Make `insn_n_alternatives'. */
6105 insn_n_alternatives
= (int *) oballoc (insn_code_number
* sizeof (int));
6106 for (id
= defs
; id
; id
= id
->next
)
6107 if (id
->insn_code
>= 0)
6108 insn_n_alternatives
[id
->insn_code
] = id
->num_alternatives
;
6110 /* Prepare to write out attribute subroutines by checking everything stored
6111 away and building the attribute cases. */
6114 for (i
= 0; i
< MAX_ATTRS_INDEX
; i
++)
6115 for (attr
= attrs
[i
]; attr
; attr
= attr
->next
)
6117 attr
->default_val
->value
6118 = check_attr_value (attr
->default_val
->value
, attr
);
6122 /* Construct extra attributes for `length'. */
6123 make_length_attrs ();
6125 /* Perform any possible optimizations to speed up compilation. */
6128 /* Now write out all the `gen_attr_...' routines. Do these before the
6129 special routines (specifically before write_function_unit_info), so
6130 that they get defined before they are used. */
6132 for (i
= 0; i
< MAX_ATTRS_INDEX
; i
++)
6133 for (attr
= attrs
[i
]; attr
; attr
= attr
->next
)
6135 if (! attr
->is_special
&& ! attr
->is_const
)
6136 write_attr_get (attr
);
6139 /* Write out delay eligibility information, if DEFINE_DELAY present.
6140 (The function to compute the number of delay slots will be written
6144 write_eligible_delay ("delay");
6145 if (have_annul_true
)
6146 write_eligible_delay ("annul_true");
6147 if (have_annul_false
)
6148 write_eligible_delay ("annul_false");
6151 /* Write out information about function units. */
6153 write_function_unit_info ();
6155 /* Write out constant delay slot info */
6156 write_const_num_delay_slots ();
6158 write_length_unit_log ();
6161 exit (ferror (stdout
) != 0 ? FATAL_EXIT_CODE
: SUCCESS_EXIT_CODE
);