1 /* Generate code from machine description to compute values of attributes.
2 Copyright (C) 1991, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000, 2002, 2003 Free Software Foundation, Inc.
4 Contributed by Richard Kenner (kenner@vlsi1.ultra.nyu.edu)
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 2, or (at your option) any later
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING. If not, write to the Free
20 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
23 /* This program handles insn attributes and the DEFINE_DELAY and
24 DEFINE_FUNCTION_UNIT definitions.
26 It produces a series of functions named `get_attr_...', one for each insn
27 attribute. Each of these is given the rtx for an insn and returns a member
28 of the enum for the attribute.
30 These subroutines have the form of a `switch' on the INSN_CODE (via
31 `recog_memoized'). Each case either returns a constant attribute value
32 or a value that depends on tests on other attributes, the form of
33 operands, or some random C expression (encoded with a SYMBOL_REF
36 If the attribute `alternative', or a random C expression is present,
37 `constrain_operands' is called. If either of these cases of a reference to
38 an operand is found, `extract_insn' is called.
40 The special attribute `length' is also recognized. For this operand,
41 expressions involving the address of an operand or the current insn,
42 (address (pc)), are valid. In this case, an initial pass is made to
43 set all lengths that do not depend on address. Those that do are set to
44 the maximum length. Then each insn that depends on an address is checked
45 and possibly has its length changed. The process repeats until no further
46 changed are made. The resulting lengths are saved for use by
49 A special form of DEFINE_ATTR, where the expression for default value is a
50 CONST expression, indicates an attribute that is constant for a given run
51 of the compiler. The subroutine generated for these attributes has no
52 parameters as it does not depend on any particular insn. Constant
53 attributes are typically used to specify which variety of processor is
56 Internal attributes are defined to handle DEFINE_DELAY and
57 DEFINE_FUNCTION_UNIT. Special routines are output for these cases.
59 This program works by keeping a list of possible values for each attribute.
60 These include the basic attribute choices, default values for attribute, and
61 all derived quantities.
63 As the description file is read, the definition for each insn is saved in a
64 `struct insn_def'. When the file reading is complete, a `struct insn_ent'
65 is created for each insn and chained to the corresponding attribute value,
66 either that specified, or the default.
68 An optimization phase is then run. This simplifies expressions for each
69 insn. EQ_ATTR tests are resolved, whenever possible, to a test that
70 indicates when the attribute has the specified value for the insn. This
71 avoids recursive calls during compilation.
73 The strategy used when processing DEFINE_DELAY and DEFINE_FUNCTION_UNIT
74 definitions is to create arbitrarily complex expressions and have the
75 optimization simplify them.
77 Once optimization is complete, any required routines and definitions
80 An optimization that is not yet implemented is to hoist the constant
81 expressions entirely out of the routines and definitions that are written.
82 A way to do this is to iterate over all possible combinations of values
83 for constant attributes and generate a set of functions for that given
84 combination. An initialization function would be written that evaluates
85 the attributes and installs the corresponding set of routines and
86 definitions (each would be accessed through a pointer).
88 We use the flags in an RTX as follows:
89 `unchanging' (ATTR_IND_SIMPLIFIED_P): This rtx is fully simplified
90 independent of the insn code.
91 `in_struct' (ATTR_CURR_SIMPLIFIED_P): This rtx is fully simplified
92 for the insn code currently being processed (see optimize_attrs).
93 `integrated' (ATTR_PERMANENT_P): This rtx is permanent and unique
95 `volatil' (ATTR_EQ_ATTR_P): During simplify_by_exploding the value of an
96 EQ_ATTR rtx is true if !volatil and false if volatil. */
98 #define ATTR_IND_SIMPLIFIED_P(RTX) (RTX_FLAG((RTX), unchanging))
99 #define ATTR_CURR_SIMPLIFIED_P(RTX) (RTX_FLAG((RTX), in_struct))
100 #define ATTR_PERMANENT_P(RTX) (RTX_FLAG((RTX), integrated))
101 #define ATTR_EQ_ATTR_P(RTX) (RTX_FLAG((RTX), volatil))
105 #include "coretypes.h"
109 #include "gensupport.h"
111 #ifdef HAVE_SYS_RESOURCE_H
112 # include <sys/resource.h>
115 /* We must include obstack.h after <sys/time.h>, to avoid lossage with
116 /usr/include/sys/stdtypes.h on Sun OS 4.x. */
120 #include "genattrtab.h"
122 static struct obstack obstack1
, obstack2
;
123 struct obstack
*hash_obstack
= &obstack1
;
124 struct obstack
*temp_obstack
= &obstack2
;
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 struct insn_def
*next
; /* Next insn in chain. */
139 rtx def
; /* The DEFINE_... */
140 int insn_code
; /* Instruction number. */
141 int insn_index
; /* Expression numer in file, for errors. */
142 int lineno
; /* Line number. */
143 int num_alternatives
; /* Number of alternatives. */
144 int vec_idx
; /* Index of attribute vector in `def'. */
147 /* Once everything has been read in, we store in each attribute value a list
148 of insn codes that have that value. Here is the structure used for the
153 struct insn_ent
*next
; /* Next in chain. */
154 int insn_code
; /* Instruction number. */
155 int insn_index
; /* Index of definition in file */
156 int lineno
; /* Line number. */
159 /* Each value of an attribute (either constant or computed) is assigned a
160 structure which is used as the listhead of the insns that have that
165 rtx value
; /* Value of attribute. */
166 struct attr_value
*next
; /* Next attribute value in chain. */
167 struct insn_ent
*first_insn
; /* First insn with this value. */
168 int num_insns
; /* Number of insns with this value. */
169 int has_asm_insn
; /* True if this value used for `asm' insns */
172 /* Structure for each attribute. */
176 char *name
; /* Name of attribute. */
177 struct attr_desc
*next
; /* Next attribute. */
178 unsigned is_numeric
: 1; /* Values of this attribute are numeric. */
179 unsigned negative_ok
: 1; /* Allow negative numeric values. */
180 unsigned unsigned_p
: 1; /* Make the output function unsigned int. */
181 unsigned is_const
: 1; /* Attribute value constant for each run. */
182 unsigned is_special
: 1; /* Don't call `write_attr_set'. */
183 unsigned func_units_p
: 1; /* this is the function_units attribute */
184 unsigned blockage_p
: 1; /* this is the blockage range function */
185 struct attr_value
*first_value
; /* First value of this attribute. */
186 struct attr_value
*default_val
; /* Default value for this attribute. */
187 int lineno
; /* Line number. */
190 #define NULL_ATTR (struct attr_desc *) NULL
192 /* A range of values. */
200 /* Structure for each DEFINE_DELAY. */
204 rtx def
; /* DEFINE_DELAY expression. */
205 struct delay_desc
*next
; /* Next DEFINE_DELAY. */
206 int num
; /* Number of DEFINE_DELAY, starting at 1. */
207 int lineno
; /* Line number. */
210 /* Record information about each DEFINE_FUNCTION_UNIT. */
212 struct function_unit_op
214 rtx condexp
; /* Expression TRUE for applicable insn. */
215 struct function_unit_op
*next
; /* Next operation for this function unit. */
216 int num
; /* Ordinal for this operation type in unit. */
217 int ready
; /* Cost until data is ready. */
218 int issue_delay
; /* Cost until unit can accept another insn. */
219 rtx conflict_exp
; /* Expression TRUE for insns incurring issue delay. */
220 rtx issue_exp
; /* Expression computing issue delay. */
221 int lineno
; /* Line number. */
224 /* Record information about each function unit mentioned in a
225 DEFINE_FUNCTION_UNIT. */
229 const char *name
; /* Function unit name. */
230 struct function_unit
*next
; /* Next function unit. */
231 int num
; /* Ordinal of this unit type. */
232 int multiplicity
; /* Number of units of this type. */
233 int simultaneity
; /* Maximum number of simultaneous insns
234 on this function unit or 0 if unlimited. */
235 rtx condexp
; /* Expression TRUE for insn needing unit. */
236 int num_opclasses
; /* Number of different operation types. */
237 struct function_unit_op
*ops
; /* Pointer to first operation type. */
238 int needs_conflict_function
; /* Nonzero if a conflict function required. */
239 int needs_blockage_function
; /* Nonzero if a blockage function required. */
240 int needs_range_function
; /* Nonzero if blockage range function needed. */
241 rtx default_cost
; /* Conflict cost, if constant. */
242 struct range issue_delay
; /* Range of issue delay values. */
243 int max_blockage
; /* Maximum time an insn blocks the unit. */
244 int first_lineno
; /* First seen line number. */
247 /* Listheads of above structures. */
249 /* This one is indexed by the first character of the attribute name. */
250 #define MAX_ATTRS_INDEX 256
251 static struct attr_desc
*attrs
[MAX_ATTRS_INDEX
];
252 static struct insn_def
*defs
;
253 static struct delay_desc
*delays
;
254 static struct function_unit
*units
;
256 /* An expression where all the unknown terms are EQ_ATTR tests can be
257 rearranged into a COND provided we can enumerate all possible
258 combinations of the unknown values. The set of combinations become the
259 tests of the COND; the value of the expression given that combination is
260 computed and becomes the corresponding value. To do this, we must be
261 able to enumerate all values for each attribute used in the expression
262 (currently, we give up if we find a numeric attribute).
264 If the set of EQ_ATTR tests used in an expression tests the value of N
265 different attributes, the list of all possible combinations can be made
266 by walking the N-dimensional attribute space defined by those
267 attributes. We record each of these as a struct dimension.
269 The algorithm relies on sharing EQ_ATTR nodes: if two nodes in an
270 expression are the same, the will also have the same address. We find
271 all the EQ_ATTR nodes by marking them ATTR_EQ_ATTR_P. This bit later
272 represents the value of an EQ_ATTR node, so once all nodes are marked,
273 they are also given an initial value of FALSE.
275 We then separate the set of EQ_ATTR nodes into dimensions for each
276 attribute and put them on the VALUES list. Terms are added as needed by
277 `add_values_to_cover' so that all possible values of the attribute are
280 Each dimension also has a current value. This is the node that is
281 currently considered to be TRUE. If this is one of the nodes added by
282 `add_values_to_cover', all the EQ_ATTR tests in the original expression
283 will be FALSE. Otherwise, only the CURRENT_VALUE will be true.
285 NUM_VALUES is simply the length of the VALUES list and is there for
288 Once the dimensions are created, the algorithm enumerates all possible
289 values and computes the current value of the given expression. */
293 struct attr_desc
*attr
; /* Attribute for this dimension. */
294 rtx values
; /* List of attribute values used. */
295 rtx current_value
; /* Position in the list for the TRUE value. */
296 int num_values
; /* Length of the values list. */
299 /* Other variables. */
301 static int insn_code_number
;
302 static int insn_index_number
;
303 static int got_define_asm_attributes
;
304 static int must_extract
;
305 static int must_constrain
;
306 static int address_used
;
307 static int length_used
;
308 static int num_delays
;
309 static int have_annul_true
, have_annul_false
;
310 static int num_units
, num_unit_opclasses
;
311 static int num_insn_ents
;
315 /* Used as operand to `operate_exp': */
317 enum operator {PLUS_OP
, MINUS_OP
, POS_MINUS_OP
, EQ_OP
, OR_OP
, ORX_OP
, MAX_OP
, MIN_OP
, RANGE_OP
};
319 /* Stores, for each insn code, the number of constraint alternatives. */
321 static int *insn_n_alternatives
;
323 /* Stores, for each insn code, a bitmap that has bits on for each possible
326 static int *insn_alternatives
;
328 /* If nonzero, assume that the `alternative' attr has this value.
329 This is the hashed, unique string for the numeral
330 whose value is chosen alternative. */
332 static const char *current_alternative_string
;
334 /* Used to simplify expressions. */
336 static rtx true_rtx
, false_rtx
;
338 /* Used to reduce calls to `strcmp' */
340 static char *alternative_name
;
342 /* Indicate that REG_DEAD notes are valid if dead_or_set_p is ever
345 int reload_completed
= 0;
347 /* Some machines test `optimize' in macros called from rtlanal.c, so we need
348 to define it here. */
352 /* Simplify an expression. Only call the routine if there is something to
354 #define SIMPLIFY_TEST_EXP(EXP,INSN_CODE,INSN_INDEX) \
355 (ATTR_IND_SIMPLIFIED_P (EXP) || ATTR_CURR_SIMPLIFIED_P (EXP) ? (EXP) \
356 : simplify_test_exp (EXP, INSN_CODE, INSN_INDEX))
358 /* Simplify (eq_attr ("alternative") ...)
359 when we are working with a particular alternative. */
360 #define SIMPLIFY_ALTERNATIVE(EXP) \
361 if (current_alternative_string \
362 && GET_CODE ((EXP)) == EQ_ATTR \
363 && XSTR ((EXP), 0) == alternative_name) \
364 (EXP) = (XSTR ((EXP), 1) == current_alternative_string \
365 ? true_rtx : false_rtx);
367 /* These are referenced by rtlanal.c and hence need to be defined somewhere.
368 They won't actually be used. */
370 rtx global_rtl
[GR_MAX
];
371 rtx pic_offset_table_rtx
;
373 static void attr_hash_add_rtx (int, rtx
);
374 static void attr_hash_add_string (int, char *);
375 static rtx
attr_rtx (enum rtx_code
, ...);
376 static rtx
attr_rtx_1 (enum rtx_code
, va_list);
377 static char *attr_string (const char *, int);
378 static rtx
check_attr_value (rtx
, struct attr_desc
*);
379 static rtx
convert_set_attr_alternative (rtx
, struct insn_def
*);
380 static rtx
convert_set_attr (rtx
, struct insn_def
*);
381 static void check_defs (void);
382 static rtx
make_canonical (struct attr_desc
*, rtx
);
383 static struct attr_value
*get_attr_value (rtx
, struct attr_desc
*, int);
384 static rtx
copy_rtx_unchanging (rtx
);
385 static rtx
copy_boolean (rtx
);
386 static void expand_delays (void);
387 static rtx
operate_exp (enum operator, rtx
, rtx
);
388 static void expand_units (void);
389 static rtx
simplify_knowing (rtx
, rtx
);
390 static rtx
encode_units_mask (rtx
);
391 static void fill_attr (struct attr_desc
*);
392 static rtx
substitute_address (rtx
, rtx (*) (rtx
), rtx (*) (rtx
));
393 static void make_length_attrs (void);
394 static rtx
identity_fn (rtx
);
395 static rtx
zero_fn (rtx
);
396 static rtx
one_fn (rtx
);
397 static rtx
max_fn (rtx
);
398 static void write_length_unit_log (void);
399 static rtx
simplify_cond (rtx
, int, int);
400 static rtx
simplify_by_exploding (rtx
);
401 static int find_and_mark_used_attributes (rtx
, rtx
*, int *);
402 static void unmark_used_attributes (rtx
, struct dimension
*, int);
403 static int add_values_to_cover (struct dimension
*);
404 static int increment_current_value (struct dimension
*, int);
405 static rtx
test_for_current_value (struct dimension
*, int);
406 static rtx
simplify_with_current_value (rtx
, struct dimension
*, int);
407 static rtx
simplify_with_current_value_aux (rtx
);
408 static void clear_struct_flag (rtx
);
409 static int count_sub_rtxs (rtx
, int);
410 static void remove_insn_ent (struct attr_value
*, struct insn_ent
*);
411 static void insert_insn_ent (struct attr_value
*, struct insn_ent
*);
412 static rtx
insert_right_side (enum rtx_code
, rtx
, rtx
, int, int);
413 static rtx
make_alternative_compare (int);
414 static int compute_alternative_mask (rtx
, enum rtx_code
);
415 static rtx
evaluate_eq_attr (rtx
, rtx
, int, int);
416 static rtx
simplify_and_tree (rtx
, rtx
*, int, int);
417 static rtx
simplify_or_tree (rtx
, rtx
*, int, int);
418 static rtx
simplify_test_exp (rtx
, int, int);
419 static rtx
simplify_test_exp_in_temp (rtx
, int, int);
420 static void optimize_attrs (void);
421 static void gen_attr (rtx
, int);
422 static int count_alternatives (rtx
);
423 static int compares_alternatives_p (rtx
);
424 static int contained_in_p (rtx
, rtx
);
425 static void gen_insn (rtx
, int);
426 static void gen_delay (rtx
, int);
427 static void gen_unit (rtx
, int);
428 static void write_test_expr (rtx
, int);
429 static int max_attr_value (rtx
, int*);
430 static int or_attr_value (rtx
, int*);
431 static void walk_attr_value (rtx
);
432 static void write_attr_get (struct attr_desc
*);
433 static rtx
eliminate_known_true (rtx
, rtx
, int, int);
434 static void write_attr_set (struct attr_desc
*, int, rtx
,
435 const char *, const char *, rtx
,
437 static void write_attr_case (struct attr_desc
*, struct attr_value
*,
438 int, const char *, const char *, int, rtx
);
439 static void write_unit_name (const char *, int, const char *);
440 static void write_attr_valueq (struct attr_desc
*, const char *);
441 static void write_attr_value (struct attr_desc
*, rtx
);
442 static void write_upcase (const char *);
443 static void write_indent (int);
444 static void write_eligible_delay (const char *);
445 static void write_function_unit_info (void);
446 static void write_complex_function (struct function_unit
*, const char *,
448 static int write_expr_attr_cache (rtx
, struct attr_desc
*);
449 static void write_toplevel_expr (rtx
);
450 static void write_const_num_delay_slots (void);
451 static char *next_comma_elt (const char **);
452 static struct attr_desc
*find_attr (const char *, int);
453 static struct attr_value
*find_most_used (struct attr_desc
*);
454 static rtx
find_single_value (struct attr_desc
*);
455 static void extend_range (struct range
*, int, int);
456 static rtx
attr_eq (const char *, const char *);
457 static const char *attr_numeral (int);
458 static int attr_equal_p (rtx
, rtx
);
459 static rtx
attr_copy_rtx (rtx
);
460 static int attr_rtx_cost (rtx
);
462 #define oballoc(size) obstack_alloc (hash_obstack, size)
464 /* Hash table for sharing RTL and strings. */
466 /* Each hash table slot is a bucket containing a chain of these structures.
467 Strings are given negative hash codes; RTL expressions are given positive
472 struct attr_hash
*next
; /* Next structure in the bucket. */
473 int hashcode
; /* Hash code of this rtx or string. */
476 char *str
; /* The string (negative hash codes) */
477 rtx rtl
; /* or the RTL recorded here. */
481 /* Now here is the hash table. When recording an RTL, it is added to
482 the slot whose index is the hash code mod the table size. Note
483 that the hash table is used for several kinds of RTL (see attr_rtx)
484 and for strings. While all these live in the same table, they are
485 completely independent, and the hash code is computed differently
488 #define RTL_HASH_SIZE 4093
489 struct attr_hash
*attr_hash_table
[RTL_HASH_SIZE
];
491 /* Here is how primitive or already-shared RTL's hash
493 #define RTL_HASH(RTL) ((long) (RTL) & 0777777)
495 /* Add an entry to the hash table for RTL with hash code HASHCODE. */
498 attr_hash_add_rtx (int hashcode
, rtx rtl
)
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 (int hashcode
, char *str
)
517 h
= (struct attr_hash
*) obstack_alloc (hash_obstack
,
518 sizeof (struct attr_hash
));
519 h
->hashcode
= -hashcode
;
521 h
->next
= attr_hash_table
[hashcode
% RTL_HASH_SIZE
];
522 attr_hash_table
[hashcode
% RTL_HASH_SIZE
] = h
;
525 /* Generate an RTL expression, but avoid duplicates.
526 Set the ATTR_PERMANENT_P flag for these permanent objects.
528 In some cases we cannot uniquify; then we return an ordinary
529 impermanent rtx with ATTR_PERMANENT_P clear.
531 Args are like gen_rtx, but without the mode:
533 rtx attr_rtx (code, [element1, ..., elementn]) */
536 attr_rtx_1 (enum rtx_code code
, va_list p
)
538 rtx rt_val
= NULL_RTX
;/* RTX to return to caller... */
541 struct obstack
*old_obstack
= rtl_obstack
;
543 /* For each of several cases, search the hash table for an existing entry.
544 Use that entry if one is found; otherwise create a new RTL and add it
547 if (GET_RTX_CLASS (code
) == '1')
549 rtx arg0
= va_arg (p
, rtx
);
551 /* A permanent object cannot point to impermanent ones. */
552 if (! ATTR_PERMANENT_P (arg0
))
554 rt_val
= rtx_alloc (code
);
555 XEXP (rt_val
, 0) = arg0
;
559 hashcode
= ((HOST_WIDE_INT
) code
+ RTL_HASH (arg0
));
560 for (h
= attr_hash_table
[hashcode
% RTL_HASH_SIZE
]; h
; h
= h
->next
)
561 if (h
->hashcode
== hashcode
562 && GET_CODE (h
->u
.rtl
) == code
563 && XEXP (h
->u
.rtl
, 0) == arg0
)
568 rtl_obstack
= hash_obstack
;
569 rt_val
= rtx_alloc (code
);
570 XEXP (rt_val
, 0) = arg0
;
573 else if (GET_RTX_CLASS (code
) == 'c'
574 || GET_RTX_CLASS (code
) == '2'
575 || GET_RTX_CLASS (code
) == '<')
577 rtx arg0
= va_arg (p
, rtx
);
578 rtx arg1
= va_arg (p
, rtx
);
580 /* A permanent object cannot point to impermanent ones. */
581 if (! ATTR_PERMANENT_P (arg0
) || ! ATTR_PERMANENT_P (arg1
))
583 rt_val
= rtx_alloc (code
);
584 XEXP (rt_val
, 0) = arg0
;
585 XEXP (rt_val
, 1) = arg1
;
589 hashcode
= ((HOST_WIDE_INT
) code
+ RTL_HASH (arg0
) + RTL_HASH (arg1
));
590 for (h
= attr_hash_table
[hashcode
% RTL_HASH_SIZE
]; h
; h
= h
->next
)
591 if (h
->hashcode
== hashcode
592 && GET_CODE (h
->u
.rtl
) == code
593 && XEXP (h
->u
.rtl
, 0) == arg0
594 && XEXP (h
->u
.rtl
, 1) == arg1
)
599 rtl_obstack
= hash_obstack
;
600 rt_val
= rtx_alloc (code
);
601 XEXP (rt_val
, 0) = arg0
;
602 XEXP (rt_val
, 1) = arg1
;
605 else if (GET_RTX_LENGTH (code
) == 1
606 && GET_RTX_FORMAT (code
)[0] == 's')
608 char *arg0
= va_arg (p
, char *);
610 if (code
== SYMBOL_REF
)
611 arg0
= attr_string (arg0
, strlen (arg0
));
613 hashcode
= ((HOST_WIDE_INT
) code
+ RTL_HASH (arg0
));
614 for (h
= attr_hash_table
[hashcode
% RTL_HASH_SIZE
]; h
; h
= h
->next
)
615 if (h
->hashcode
== hashcode
616 && GET_CODE (h
->u
.rtl
) == code
617 && XSTR (h
->u
.rtl
, 0) == arg0
)
622 rtl_obstack
= hash_obstack
;
623 rt_val
= rtx_alloc (code
);
624 XSTR (rt_val
, 0) = arg0
;
627 else if (GET_RTX_LENGTH (code
) == 2
628 && GET_RTX_FORMAT (code
)[0] == 's'
629 && GET_RTX_FORMAT (code
)[1] == 's')
631 char *arg0
= va_arg (p
, char *);
632 char *arg1
= va_arg (p
, char *);
634 hashcode
= ((HOST_WIDE_INT
) code
+ RTL_HASH (arg0
) + RTL_HASH (arg1
));
635 for (h
= attr_hash_table
[hashcode
% RTL_HASH_SIZE
]; h
; h
= h
->next
)
636 if (h
->hashcode
== hashcode
637 && GET_CODE (h
->u
.rtl
) == code
638 && XSTR (h
->u
.rtl
, 0) == arg0
639 && XSTR (h
->u
.rtl
, 1) == arg1
)
644 rtl_obstack
= hash_obstack
;
645 rt_val
= rtx_alloc (code
);
646 XSTR (rt_val
, 0) = arg0
;
647 XSTR (rt_val
, 1) = arg1
;
650 else if (code
== CONST_INT
)
652 HOST_WIDE_INT arg0
= va_arg (p
, HOST_WIDE_INT
);
662 int i
; /* Array indices... */
663 const char *fmt
; /* Current rtx's format... */
665 rt_val
= rtx_alloc (code
); /* Allocate the storage space. */
667 fmt
= GET_RTX_FORMAT (code
); /* Find the right format... */
668 for (i
= 0; i
< GET_RTX_LENGTH (code
); i
++)
672 case '0': /* Unused field. */
675 case 'i': /* An integer? */
676 XINT (rt_val
, i
) = va_arg (p
, int);
679 case 'w': /* A wide integer? */
680 XWINT (rt_val
, i
) = va_arg (p
, HOST_WIDE_INT
);
683 case 's': /* A string? */
684 XSTR (rt_val
, i
) = va_arg (p
, char *);
687 case 'e': /* An expression? */
688 case 'u': /* An insn? Same except when printing. */
689 XEXP (rt_val
, i
) = va_arg (p
, rtx
);
692 case 'E': /* An RTX vector? */
693 XVEC (rt_val
, i
) = va_arg (p
, rtvec
);
703 rtl_obstack
= old_obstack
;
704 attr_hash_add_rtx (hashcode
, rt_val
);
705 ATTR_PERMANENT_P (rt_val
) = 1;
710 attr_rtx (enum rtx_code code
, ...)
716 result
= attr_rtx_1 (code
, p
);
721 /* Create a new string printed with the printf line arguments into a space
722 of at most LEN bytes:
724 rtx attr_printf (len, format, [arg1, ..., argn]) */
727 attr_printf (unsigned int len
, const char *fmt
, ...)
734 if (len
> sizeof str
- 1) /* Leave room for \0. */
737 vsprintf (str
, fmt
, p
);
740 return attr_string (str
, strlen (str
));
744 attr_eq (const char *name
, const char *value
)
746 return attr_rtx (EQ_ATTR
, attr_string (name
, strlen (name
)),
747 attr_string (value
, strlen (value
)));
753 return XSTR (make_numeric_value (n
), 0);
756 /* Return a permanent (possibly shared) copy of a string STR (not assumed
757 to be null terminated) with LEN bytes. */
760 attr_string (const char *str
, int len
)
767 /* Compute the hash code. */
768 hashcode
= (len
+ 1) * 613 + (unsigned) str
[0];
769 for (i
= 1; i
<= len
; i
+= 2)
770 hashcode
= ((hashcode
* 613) + (unsigned) str
[i
]);
772 hashcode
= -hashcode
;
774 /* Search the table for the string. */
775 for (h
= attr_hash_table
[hashcode
% RTL_HASH_SIZE
]; h
; h
= h
->next
)
776 if (h
->hashcode
== -hashcode
&& h
->u
.str
[0] == str
[0]
777 && !strncmp (h
->u
.str
, str
, len
))
778 return h
->u
.str
; /* <-- return if found. */
780 /* Not found; create a permanent copy and add it to the hash table. */
781 new_str
= (char *) obstack_alloc (hash_obstack
, len
+ 1);
782 memcpy (new_str
, str
, len
);
784 attr_hash_add_string (hashcode
, new_str
);
786 return new_str
; /* Return the new string. */
789 /* Check two rtx's for equality of contents,
790 taking advantage of the fact that if both are hashed
791 then they can't be equal unless they are the same object. */
794 attr_equal_p (rtx x
, rtx y
)
796 return (x
== y
|| (! (ATTR_PERMANENT_P (x
) && ATTR_PERMANENT_P (y
))
797 && rtx_equal_p (x
, y
)));
800 /* Copy an attribute value expression,
801 descending to all depths, but not copying any
802 permanent hashed subexpressions. */
805 attr_copy_rtx (rtx orig
)
810 const char *format_ptr
;
812 /* No need to copy a permanent object. */
813 if (ATTR_PERMANENT_P (orig
))
816 code
= GET_CODE (orig
);
835 copy
= rtx_alloc (code
);
836 PUT_MODE (copy
, GET_MODE (orig
));
837 ATTR_IND_SIMPLIFIED_P (copy
) = ATTR_IND_SIMPLIFIED_P (orig
);
838 ATTR_CURR_SIMPLIFIED_P (copy
) = ATTR_CURR_SIMPLIFIED_P (orig
);
839 ATTR_PERMANENT_P (copy
) = ATTR_PERMANENT_P (orig
);
840 ATTR_EQ_ATTR_P (copy
) = ATTR_EQ_ATTR_P (orig
);
842 format_ptr
= GET_RTX_FORMAT (GET_CODE (copy
));
844 for (i
= 0; i
< GET_RTX_LENGTH (GET_CODE (copy
)); i
++)
846 switch (*format_ptr
++)
849 XEXP (copy
, i
) = XEXP (orig
, i
);
850 if (XEXP (orig
, i
) != NULL
)
851 XEXP (copy
, i
) = attr_copy_rtx (XEXP (orig
, i
));
856 XVEC (copy
, i
) = XVEC (orig
, i
);
857 if (XVEC (orig
, i
) != NULL
)
859 XVEC (copy
, i
) = rtvec_alloc (XVECLEN (orig
, i
));
860 for (j
= 0; j
< XVECLEN (copy
, i
); j
++)
861 XVECEXP (copy
, i
, j
) = attr_copy_rtx (XVECEXP (orig
, i
, j
));
867 XINT (copy
, i
) = XINT (orig
, i
);
871 XWINT (copy
, i
) = XWINT (orig
, i
);
876 XSTR (copy
, i
) = XSTR (orig
, i
);
886 /* Given a test expression for an attribute, ensure it is validly formed.
887 IS_CONST indicates whether the expression is constant for each compiler
888 run (a constant expression may not test any particular insn).
890 Convert (eq_attr "att" "a1,a2") to (ior (eq_attr ... ) (eq_attrq ..))
891 and (eq_attr "att" "!a1") to (not (eq_attr "att" "a1")). Do the latter
892 test first so that (eq_attr "att" "!a1,a2,a3") works as expected.
894 Update the string address in EQ_ATTR expression to be the same used
895 in the attribute (or `alternative_name') to speed up subsequent
896 `find_attr' calls and eliminate most `strcmp' calls.
898 Return the new expression, if any. */
901 check_attr_test (rtx exp
, int is_const
, int lineno
)
903 struct attr_desc
*attr
;
904 struct attr_value
*av
;
905 const char *name_ptr
, *p
;
908 switch (GET_CODE (exp
))
911 /* Handle negation test. */
912 if (XSTR (exp
, 1)[0] == '!')
913 return check_attr_test (attr_rtx (NOT
,
914 attr_eq (XSTR (exp
, 0),
918 else if (n_comma_elts (XSTR (exp
, 1)) == 1)
920 attr
= find_attr (XSTR (exp
, 0), 0);
923 if (! strcmp (XSTR (exp
, 0), "alternative"))
925 XSTR (exp
, 0) = alternative_name
;
926 /* This can't be simplified any further. */
927 ATTR_IND_SIMPLIFIED_P (exp
) = 1;
931 fatal ("unknown attribute `%s' in EQ_ATTR", XSTR (exp
, 0));
934 if (is_const
&& ! attr
->is_const
)
935 fatal ("constant expression uses insn attribute `%s' in EQ_ATTR",
938 /* Copy this just to make it permanent,
939 so expressions using it can be permanent too. */
940 exp
= attr_eq (XSTR (exp
, 0), XSTR (exp
, 1));
942 /* It shouldn't be possible to simplify the value given to a
943 constant attribute, so don't expand this until it's time to
944 write the test expression. */
946 ATTR_IND_SIMPLIFIED_P (exp
) = 1;
948 if (attr
->is_numeric
)
950 for (p
= XSTR (exp
, 1); *p
; p
++)
952 fatal ("attribute `%s' takes only numeric values",
957 for (av
= attr
->first_value
; av
; av
= av
->next
)
958 if (GET_CODE (av
->value
) == CONST_STRING
959 && ! strcmp (XSTR (exp
, 1), XSTR (av
->value
, 0)))
963 fatal ("unknown value `%s' for `%s' attribute",
964 XSTR (exp
, 1), XSTR (exp
, 0));
969 /* Make an IOR tree of the possible values. */
971 name_ptr
= XSTR (exp
, 1);
972 while ((p
= next_comma_elt (&name_ptr
)) != NULL
)
974 newexp
= attr_eq (XSTR (exp
, 0), p
);
975 orexp
= insert_right_side (IOR
, orexp
, newexp
, -2, -2);
978 return check_attr_test (orexp
, is_const
, lineno
);
986 /* Either TRUE or FALSE. */
994 XEXP (exp
, 0) = check_attr_test (XEXP (exp
, 0), is_const
, lineno
);
995 XEXP (exp
, 1) = check_attr_test (XEXP (exp
, 1), is_const
, lineno
);
999 XEXP (exp
, 0) = check_attr_test (XEXP (exp
, 0), is_const
, lineno
);
1005 fatal ("RTL operator \"%s\" not valid in constant attribute test",
1006 GET_RTX_NAME (GET_CODE (exp
)));
1007 /* These cases can't be simplified. */
1008 ATTR_IND_SIMPLIFIED_P (exp
) = 1;
1011 case LE
: case LT
: case GT
: case GE
:
1012 case LEU
: case LTU
: case GTU
: case GEU
:
1014 if (GET_CODE (XEXP (exp
, 0)) == SYMBOL_REF
1015 && GET_CODE (XEXP (exp
, 1)) == SYMBOL_REF
)
1016 exp
= attr_rtx (GET_CODE (exp
),
1017 attr_rtx (SYMBOL_REF
, XSTR (XEXP (exp
, 0), 0)),
1018 attr_rtx (SYMBOL_REF
, XSTR (XEXP (exp
, 1), 0)));
1019 /* These cases can't be simplified. */
1020 ATTR_IND_SIMPLIFIED_P (exp
) = 1;
1026 /* These cases are valid for constant attributes, but can't be
1028 exp
= attr_rtx (SYMBOL_REF
, XSTR (exp
, 0));
1029 ATTR_IND_SIMPLIFIED_P (exp
) = 1;
1033 fatal ("RTL operator \"%s\" not valid in attribute test",
1034 GET_RTX_NAME (GET_CODE (exp
)));
1040 /* Given an expression, ensure that it is validly formed and that all named
1041 attribute values are valid for the given attribute. Issue a fatal error
1042 if not. If no attribute is specified, assume a numeric attribute.
1044 Return a perhaps modified replacement expression for the value. */
1047 check_attr_value (rtx exp
, struct attr_desc
*attr
)
1049 struct attr_value
*av
;
1053 switch (GET_CODE (exp
))
1056 if (attr
&& ! attr
->is_numeric
)
1058 message_with_line (attr
->lineno
,
1059 "CONST_INT not valid for non-numeric attribute %s",
1065 if (INTVAL (exp
) < 0 && ! attr
->negative_ok
)
1067 message_with_line (attr
->lineno
,
1068 "negative numeric value specified for attribute %s",
1076 if (! strcmp (XSTR (exp
, 0), "*"))
1079 if (attr
== 0 || attr
->is_numeric
)
1082 if (attr
&& attr
->negative_ok
&& *p
== '-')
1087 message_with_line (attr
? attr
->lineno
: 0,
1088 "non-numeric value for numeric attribute %s",
1089 attr
? attr
->name
: "internal");
1096 for (av
= attr
->first_value
; av
; av
= av
->next
)
1097 if (GET_CODE (av
->value
) == CONST_STRING
1098 && ! strcmp (XSTR (av
->value
, 0), XSTR (exp
, 0)))
1103 message_with_line (attr
->lineno
,
1104 "unknown value `%s' for `%s' attribute",
1105 XSTR (exp
, 0), attr
? attr
->name
: "internal");
1111 XEXP (exp
, 0) = check_attr_test (XEXP (exp
, 0),
1112 attr
? attr
->is_const
: 0,
1113 attr
? attr
->lineno
: 0);
1114 XEXP (exp
, 1) = check_attr_value (XEXP (exp
, 1), attr
);
1115 XEXP (exp
, 2) = check_attr_value (XEXP (exp
, 2), attr
);
1123 if (attr
&& !attr
->is_numeric
)
1125 message_with_line (attr
->lineno
,
1126 "invalid operation `%s' for non-numeric attribute value",
1127 GET_RTX_NAME (GET_CODE (exp
)));
1135 XEXP (exp
, 0) = check_attr_value (XEXP (exp
, 0), attr
);
1136 XEXP (exp
, 1) = check_attr_value (XEXP (exp
, 1), attr
);
1144 XEXP (exp
, 0) = check_attr_value (XEXP (exp
, 0), attr
);
1148 if (XVECLEN (exp
, 0) % 2 != 0)
1150 message_with_line (attr
->lineno
,
1151 "first operand of COND must have even length");
1156 for (i
= 0; i
< XVECLEN (exp
, 0); i
+= 2)
1158 XVECEXP (exp
, 0, i
) = check_attr_test (XVECEXP (exp
, 0, i
),
1159 attr
? attr
->is_const
: 0,
1160 attr
? attr
->lineno
: 0);
1161 XVECEXP (exp
, 0, i
+ 1)
1162 = check_attr_value (XVECEXP (exp
, 0, i
+ 1), attr
);
1165 XEXP (exp
, 1) = check_attr_value (XEXP (exp
, 1), attr
);
1170 struct attr_desc
*attr2
= find_attr (XSTR (exp
, 0), 0);
1173 message_with_line (attr
? attr
->lineno
: 0,
1174 "unknown attribute `%s' in ATTR",
1178 else if (attr
&& attr
->is_const
&& ! attr2
->is_const
)
1180 message_with_line (attr
->lineno
,
1181 "non-constant attribute `%s' referenced from `%s'",
1182 XSTR (exp
, 0), attr
->name
);
1186 && (attr
->is_numeric
!= attr2
->is_numeric
1187 || (! attr
->negative_ok
&& attr2
->negative_ok
)))
1189 message_with_line (attr
->lineno
,
1190 "numeric attribute mismatch calling `%s' from `%s'",
1191 XSTR (exp
, 0), attr
->name
);
1198 /* A constant SYMBOL_REF is valid as a constant attribute test and
1199 is expanded later by make_canonical into a COND. In a non-constant
1200 attribute test, it is left be. */
1201 return attr_rtx (SYMBOL_REF
, XSTR (exp
, 0));
1204 message_with_line (attr
? attr
->lineno
: 0,
1205 "invalid operation `%s' for attribute value",
1206 GET_RTX_NAME (GET_CODE (exp
)));
1214 /* Given an SET_ATTR_ALTERNATIVE expression, convert to the canonical SET.
1215 It becomes a COND with each test being (eq_attr "alternative "n") */
1218 convert_set_attr_alternative (rtx exp
, struct insn_def
*id
)
1220 int num_alt
= id
->num_alternatives
;
1224 if (XVECLEN (exp
, 1) != num_alt
)
1226 message_with_line (id
->lineno
,
1227 "bad number of entries in SET_ATTR_ALTERNATIVE");
1232 /* Make a COND with all tests but the last. Select the last value via the
1234 condexp
= rtx_alloc (COND
);
1235 XVEC (condexp
, 0) = rtvec_alloc ((num_alt
- 1) * 2);
1237 for (i
= 0; i
< num_alt
- 1; i
++)
1240 p
= attr_numeral (i
);
1242 XVECEXP (condexp
, 0, 2 * i
) = attr_eq (alternative_name
, p
);
1243 XVECEXP (condexp
, 0, 2 * i
+ 1) = XVECEXP (exp
, 1, i
);
1246 XEXP (condexp
, 1) = XVECEXP (exp
, 1, i
);
1248 return attr_rtx (SET
, attr_rtx (ATTR
, XSTR (exp
, 0)), condexp
);
1251 /* Given a SET_ATTR, convert to the appropriate SET. If a comma-separated
1252 list of values is given, convert to SET_ATTR_ALTERNATIVE first. */
1255 convert_set_attr (rtx exp
, struct insn_def
*id
)
1258 const char *name_ptr
;
1262 /* See how many alternative specified. */
1263 n
= n_comma_elts (XSTR (exp
, 1));
1265 return attr_rtx (SET
,
1266 attr_rtx (ATTR
, XSTR (exp
, 0)),
1267 attr_rtx (CONST_STRING
, XSTR (exp
, 1)));
1269 newexp
= rtx_alloc (SET_ATTR_ALTERNATIVE
);
1270 XSTR (newexp
, 0) = XSTR (exp
, 0);
1271 XVEC (newexp
, 1) = rtvec_alloc (n
);
1273 /* Process each comma-separated name. */
1274 name_ptr
= XSTR (exp
, 1);
1276 while ((p
= next_comma_elt (&name_ptr
)) != NULL
)
1277 XVECEXP (newexp
, 1, n
++) = attr_rtx (CONST_STRING
, p
);
1279 return convert_set_attr_alternative (newexp
, id
);
1282 /* Scan all definitions, checking for validity. Also, convert any SET_ATTR
1283 and SET_ATTR_ALTERNATIVE expressions to the corresponding SET
1289 struct insn_def
*id
;
1290 struct attr_desc
*attr
;
1294 for (id
= defs
; id
; id
= id
->next
)
1296 if (XVEC (id
->def
, id
->vec_idx
) == NULL
)
1299 for (i
= 0; i
< XVECLEN (id
->def
, id
->vec_idx
); i
++)
1301 value
= XVECEXP (id
->def
, id
->vec_idx
, i
);
1302 switch (GET_CODE (value
))
1305 if (GET_CODE (XEXP (value
, 0)) != ATTR
)
1307 message_with_line (id
->lineno
, "bad attribute set");
1313 case SET_ATTR_ALTERNATIVE
:
1314 value
= convert_set_attr_alternative (value
, id
);
1318 value
= convert_set_attr (value
, id
);
1322 message_with_line (id
->lineno
, "invalid attribute code %s",
1323 GET_RTX_NAME (GET_CODE (value
)));
1327 if (value
== NULL_RTX
)
1330 if ((attr
= find_attr (XSTR (XEXP (value
, 0), 0), 0)) == NULL
)
1332 message_with_line (id
->lineno
, "unknown attribute %s",
1333 XSTR (XEXP (value
, 0), 0));
1338 XVECEXP (id
->def
, id
->vec_idx
, i
) = value
;
1339 XEXP (value
, 1) = check_attr_value (XEXP (value
, 1), attr
);
1344 /* Given a valid expression for an attribute value, remove any IF_THEN_ELSE
1345 expressions by converting them into a COND. This removes cases from this
1346 program. Also, replace an attribute value of "*" with the default attribute
1350 make_canonical (struct attr_desc
*attr
, rtx exp
)
1355 switch (GET_CODE (exp
))
1358 exp
= make_numeric_value (INTVAL (exp
));
1362 if (! strcmp (XSTR (exp
, 0), "*"))
1364 if (attr
== 0 || attr
->default_val
== 0)
1365 fatal ("(attr_value \"*\") used in invalid context");
1366 exp
= attr
->default_val
->value
;
1372 if (!attr
->is_const
|| ATTR_IND_SIMPLIFIED_P (exp
))
1374 /* The SYMBOL_REF is constant for a given run, so mark it as unchanging.
1375 This makes the COND something that won't be considered an arbitrary
1376 expression by walk_attr_value. */
1377 ATTR_IND_SIMPLIFIED_P (exp
) = 1;
1378 exp
= check_attr_value (exp
, attr
);
1382 newexp
= rtx_alloc (COND
);
1383 XVEC (newexp
, 0) = rtvec_alloc (2);
1384 XVECEXP (newexp
, 0, 0) = XEXP (exp
, 0);
1385 XVECEXP (newexp
, 0, 1) = XEXP (exp
, 1);
1387 XEXP (newexp
, 1) = XEXP (exp
, 2);
1390 /* Fall through to COND case since this is now a COND. */
1397 /* First, check for degenerate COND. */
1398 if (XVECLEN (exp
, 0) == 0)
1399 return make_canonical (attr
, XEXP (exp
, 1));
1400 defval
= XEXP (exp
, 1) = make_canonical (attr
, XEXP (exp
, 1));
1402 for (i
= 0; i
< XVECLEN (exp
, 0); i
+= 2)
1404 XVECEXP (exp
, 0, i
) = copy_boolean (XVECEXP (exp
, 0, i
));
1405 XVECEXP (exp
, 0, i
+ 1)
1406 = make_canonical (attr
, XVECEXP (exp
, 0, i
+ 1));
1407 if (! rtx_equal_p (XVECEXP (exp
, 0, i
+ 1), defval
))
1423 copy_boolean (rtx exp
)
1425 if (GET_CODE (exp
) == AND
|| GET_CODE (exp
) == IOR
)
1426 return attr_rtx (GET_CODE (exp
), copy_boolean (XEXP (exp
, 0)),
1427 copy_boolean (XEXP (exp
, 1)));
1431 /* Given a value and an attribute description, return a `struct attr_value *'
1432 that represents that value. This is either an existing structure, if the
1433 value has been previously encountered, or a newly-created structure.
1435 `insn_code' is the code of an insn whose attribute has the specified
1436 value (-2 if not processing an insn). We ensure that all insns for
1437 a given value have the same number of alternatives if the value checks
1440 static struct attr_value
*
1441 get_attr_value (rtx value
, struct attr_desc
*attr
, int insn_code
)
1443 struct attr_value
*av
;
1446 value
= make_canonical (attr
, value
);
1447 if (compares_alternatives_p (value
))
1449 if (insn_code
< 0 || insn_alternatives
== NULL
)
1450 fatal ("(eq_attr \"alternatives\" ...) used in non-insn context");
1452 num_alt
= insn_alternatives
[insn_code
];
1455 for (av
= attr
->first_value
; av
; av
= av
->next
)
1456 if (rtx_equal_p (value
, av
->value
)
1457 && (num_alt
== 0 || av
->first_insn
== NULL
1458 || insn_alternatives
[av
->first_insn
->insn_code
]))
1461 av
= (struct attr_value
*) oballoc (sizeof (struct attr_value
));
1463 av
->next
= attr
->first_value
;
1464 attr
->first_value
= av
;
1465 av
->first_insn
= NULL
;
1467 av
->has_asm_insn
= 0;
1472 /* After all DEFINE_DELAYs have been read in, create internal attributes
1473 to generate the required routines.
1475 First, we compute the number of delay slots for each insn (as a COND of
1476 each of the test expressions in DEFINE_DELAYs). Then, if more than one
1477 delay type is specified, we compute a similar function giving the
1478 DEFINE_DELAY ordinal for each insn.
1480 Finally, for each [DEFINE_DELAY, slot #] pair, we compute an attribute that
1481 tells whether a given insn can be in that delay slot.
1483 Normal attribute filling and optimization expands these to contain the
1484 information needed to handle delay slots. */
1487 expand_delays (void)
1489 struct delay_desc
*delay
;
1495 /* First, generate data for `num_delay_slots' function. */
1497 condexp
= rtx_alloc (COND
);
1498 XVEC (condexp
, 0) = rtvec_alloc (num_delays
* 2);
1499 XEXP (condexp
, 1) = make_numeric_value (0);
1501 for (i
= 0, delay
= delays
; delay
; i
+= 2, delay
= delay
->next
)
1503 XVECEXP (condexp
, 0, i
) = XEXP (delay
->def
, 0);
1504 XVECEXP (condexp
, 0, i
+ 1)
1505 = make_numeric_value (XVECLEN (delay
->def
, 1) / 3);
1508 make_internal_attr ("*num_delay_slots", condexp
, 0);
1510 /* If more than one delay type, do the same for computing the delay type. */
1513 condexp
= rtx_alloc (COND
);
1514 XVEC (condexp
, 0) = rtvec_alloc (num_delays
* 2);
1515 XEXP (condexp
, 1) = make_numeric_value (0);
1517 for (i
= 0, delay
= delays
; delay
; i
+= 2, delay
= delay
->next
)
1519 XVECEXP (condexp
, 0, i
) = XEXP (delay
->def
, 0);
1520 XVECEXP (condexp
, 0, i
+ 1) = make_numeric_value (delay
->num
);
1523 make_internal_attr ("*delay_type", condexp
, 1);
1526 /* For each delay possibility and delay slot, compute an eligibility
1527 attribute for non-annulled insns and for each type of annulled (annul
1528 if true and annul if false). */
1529 for (delay
= delays
; delay
; delay
= delay
->next
)
1531 for (i
= 0; i
< XVECLEN (delay
->def
, 1); i
+= 3)
1533 condexp
= XVECEXP (delay
->def
, 1, i
);
1535 condexp
= false_rtx
;
1536 newexp
= attr_rtx (IF_THEN_ELSE
, condexp
,
1537 make_numeric_value (1), make_numeric_value (0));
1539 p
= attr_printf (sizeof "*delay__" + MAX_DIGITS
* 2,
1540 "*delay_%d_%d", delay
->num
, i
/ 3);
1541 make_internal_attr (p
, newexp
, 1);
1543 if (have_annul_true
)
1545 condexp
= XVECEXP (delay
->def
, 1, i
+ 1);
1546 if (condexp
== 0) condexp
= false_rtx
;
1547 newexp
= attr_rtx (IF_THEN_ELSE
, condexp
,
1548 make_numeric_value (1),
1549 make_numeric_value (0));
1550 p
= attr_printf (sizeof "*annul_true__" + MAX_DIGITS
* 2,
1551 "*annul_true_%d_%d", delay
->num
, i
/ 3);
1552 make_internal_attr (p
, newexp
, 1);
1555 if (have_annul_false
)
1557 condexp
= XVECEXP (delay
->def
, 1, i
+ 2);
1558 if (condexp
== 0) condexp
= false_rtx
;
1559 newexp
= attr_rtx (IF_THEN_ELSE
, condexp
,
1560 make_numeric_value (1),
1561 make_numeric_value (0));
1562 p
= attr_printf (sizeof "*annul_false__" + MAX_DIGITS
* 2,
1563 "*annul_false_%d_%d", delay
->num
, i
/ 3);
1564 make_internal_attr (p
, newexp
, 1);
1570 /* This function is given a left and right side expression and an operator.
1571 Each side is a conditional expression, each alternative of which has a
1572 numerical value. The function returns another conditional expression
1573 which, for every possible set of condition values, returns a value that is
1574 the operator applied to the values of the two sides.
1576 Since this is called early, it must also support IF_THEN_ELSE. */
1579 operate_exp (enum operator op
, rtx left
, rtx right
)
1581 int left_value
, right_value
;
1585 /* If left is a string, apply operator to it and the right side. */
1586 if (GET_CODE (left
) == CONST_STRING
)
1588 /* If right is also a string, just perform the operation. */
1589 if (GET_CODE (right
) == CONST_STRING
)
1591 left_value
= atoi (XSTR (left
, 0));
1592 right_value
= atoi (XSTR (right
, 0));
1596 i
= left_value
+ right_value
;
1600 i
= left_value
- right_value
;
1603 case POS_MINUS_OP
: /* The positive part of LEFT - RIGHT. */
1604 if (left_value
> right_value
)
1605 i
= left_value
- right_value
;
1612 i
= left_value
| right_value
;
1616 i
= left_value
== right_value
;
1620 i
= (left_value
<< (HOST_BITS_PER_INT
/ 2)) | right_value
;
1624 if (left_value
> right_value
)
1631 if (left_value
< right_value
)
1641 if (i
== left_value
)
1643 if (i
== right_value
)
1645 return make_numeric_value (i
);
1647 else if (GET_CODE (right
) == IF_THEN_ELSE
)
1649 /* Apply recursively to all values within. */
1650 rtx newleft
= operate_exp (op
, left
, XEXP (right
, 1));
1651 rtx newright
= operate_exp (op
, left
, XEXP (right
, 2));
1652 if (rtx_equal_p (newleft
, newright
))
1654 return attr_rtx (IF_THEN_ELSE
, XEXP (right
, 0), newleft
, newright
);
1656 else if (GET_CODE (right
) == COND
)
1661 newexp
= rtx_alloc (COND
);
1662 XVEC (newexp
, 0) = rtvec_alloc (XVECLEN (right
, 0));
1663 defval
= XEXP (newexp
, 1) = operate_exp (op
, left
, XEXP (right
, 1));
1665 for (i
= 0; i
< XVECLEN (right
, 0); i
+= 2)
1667 XVECEXP (newexp
, 0, i
) = XVECEXP (right
, 0, i
);
1668 XVECEXP (newexp
, 0, i
+ 1)
1669 = operate_exp (op
, left
, XVECEXP (right
, 0, i
+ 1));
1670 if (! rtx_equal_p (XVECEXP (newexp
, 0, i
+ 1),
1675 /* If the resulting cond is trivial (all alternatives
1676 give the same value), optimize it away. */
1678 return operate_exp (op
, left
, XEXP (right
, 1));
1683 fatal ("badly formed attribute value");
1686 /* A hack to prevent expand_units from completely blowing up: ORX_OP does
1687 not associate through IF_THEN_ELSE. */
1688 else if (op
== ORX_OP
&& GET_CODE (right
) == IF_THEN_ELSE
)
1690 return attr_rtx (IOR
, left
, right
);
1693 /* Otherwise, do recursion the other way. */
1694 else if (GET_CODE (left
) == IF_THEN_ELSE
)
1696 rtx newleft
= operate_exp (op
, XEXP (left
, 1), right
);
1697 rtx newright
= operate_exp (op
, XEXP (left
, 2), right
);
1698 if (rtx_equal_p (newleft
, newright
))
1700 return attr_rtx (IF_THEN_ELSE
, XEXP (left
, 0), newleft
, newright
);
1702 else if (GET_CODE (left
) == COND
)
1707 newexp
= rtx_alloc (COND
);
1708 XVEC (newexp
, 0) = rtvec_alloc (XVECLEN (left
, 0));
1709 defval
= XEXP (newexp
, 1) = operate_exp (op
, XEXP (left
, 1), right
);
1711 for (i
= 0; i
< XVECLEN (left
, 0); i
+= 2)
1713 XVECEXP (newexp
, 0, i
) = XVECEXP (left
, 0, i
);
1714 XVECEXP (newexp
, 0, i
+ 1)
1715 = operate_exp (op
, XVECEXP (left
, 0, i
+ 1), right
);
1716 if (! rtx_equal_p (XVECEXP (newexp
, 0, i
+ 1),
1721 /* If the cond is trivial (all alternatives give the same value),
1722 optimize it away. */
1724 return operate_exp (op
, XEXP (left
, 1), right
);
1726 /* If the result is the same as the LEFT operand,
1728 if (rtx_equal_p (newexp
, left
))
1735 fatal ("badly formed attribute value");
1740 /* Once all attributes and DEFINE_FUNCTION_UNITs have been read, we
1741 construct a number of attributes.
1743 The first produces a function `function_units_used' which is given an
1744 insn and produces an encoding showing which function units are required
1745 for the execution of that insn. If the value is non-negative, the insn
1746 uses that unit; otherwise, the value is a one's complement mask of units
1749 The second produces a function `result_ready_cost' which is used to
1750 determine the time that the result of an insn will be ready and hence
1751 a worst-case schedule.
1753 Both of these produce quite complex expressions which are then set as the
1754 default value of internal attributes. Normal attribute simplification
1755 should produce reasonable expressions.
1757 For each unit, a `<name>_unit_ready_cost' function will take an
1758 insn and give the delay until that unit will be ready with the result
1759 and a `<name>_unit_conflict_cost' function is given an insn already
1760 executing on the unit and a candidate to execute and will give the
1761 cost from the time the executing insn started until the candidate
1762 can start (ignore limitations on the number of simultaneous insns).
1764 For each unit, a `<name>_unit_blockage' function is given an insn
1765 already executing on the unit and a candidate to execute and will
1766 give the delay incurred due to function unit conflicts. The range of
1767 blockage cost values for a given executing insn is given by the
1768 `<name>_unit_blockage_range' function. These values are encoded in
1769 an int where the upper half gives the minimum value and the lower
1770 half gives the maximum value. */
1775 struct function_unit
*unit
, **unit_num
;
1776 struct function_unit_op
*op
, **op_array
, ***unit_ops
;
1781 int i
, j
, u
, num
, nvalues
;
1783 /* Rebuild the condition for the unit to share the RTL expressions.
1784 Sharing is required by simplify_by_exploding. Build the issue delay
1785 expressions. Validate the expressions we were given for the conditions
1786 and conflict vector. Then make attributes for use in the conflict
1789 for (unit
= units
; unit
; unit
= unit
->next
)
1791 unit
->condexp
= check_attr_test (unit
->condexp
, 0, unit
->first_lineno
);
1793 for (op
= unit
->ops
; op
; op
= op
->next
)
1795 rtx issue_delay
= make_numeric_value (op
->issue_delay
);
1796 rtx issue_exp
= issue_delay
;
1798 /* Build, validate, and simplify the issue delay expression. */
1799 if (op
->conflict_exp
!= true_rtx
)
1800 issue_exp
= attr_rtx (IF_THEN_ELSE
, op
->conflict_exp
,
1801 issue_exp
, make_numeric_value (0));
1802 issue_exp
= check_attr_value (make_canonical (NULL_ATTR
,
1805 issue_exp
= simplify_knowing (issue_exp
, unit
->condexp
);
1806 op
->issue_exp
= issue_exp
;
1808 /* Make an attribute for use in the conflict function if needed. */
1809 unit
->needs_conflict_function
= (unit
->issue_delay
.min
1810 != unit
->issue_delay
.max
);
1811 if (unit
->needs_conflict_function
)
1813 str
= attr_printf ((strlen (unit
->name
) + sizeof "*_cost_"
1815 "*%s_cost_%d", unit
->name
, op
->num
);
1816 make_internal_attr (str
, issue_exp
, 1);
1819 /* Validate the condition. */
1820 op
->condexp
= check_attr_test (op
->condexp
, 0, op
->lineno
);
1824 /* Compute the mask of function units used. Initially, the unitsmask is
1825 zero. Set up a conditional to compute each unit's contribution. */
1826 unitsmask
= make_numeric_value (0);
1827 newexp
= rtx_alloc (IF_THEN_ELSE
);
1828 XEXP (newexp
, 2) = make_numeric_value (0);
1830 /* If we have just a few units, we may be all right expanding the whole
1831 thing. But the expansion is 2**N in space on the number of opclasses,
1832 so we can't do this for very long -- Alpha and MIPS in particular have
1833 problems with this. So in that situation, we fall back on an alternate
1834 implementation method. */
1835 #define NUM_UNITOP_CUTOFF 20
1837 if (num_unit_opclasses
< NUM_UNITOP_CUTOFF
)
1839 /* Merge each function unit into the unit mask attributes. */
1840 for (unit
= units
; unit
; unit
= unit
->next
)
1842 XEXP (newexp
, 0) = unit
->condexp
;
1843 XEXP (newexp
, 1) = make_numeric_value (1 << unit
->num
);
1844 unitsmask
= operate_exp (OR_OP
, unitsmask
, newexp
);
1849 /* Merge each function unit into the unit mask attributes. */
1850 for (unit
= units
; unit
; unit
= unit
->next
)
1852 XEXP (newexp
, 0) = unit
->condexp
;
1853 XEXP (newexp
, 1) = make_numeric_value (1 << unit
->num
);
1854 unitsmask
= operate_exp (ORX_OP
, unitsmask
, attr_copy_rtx (newexp
));
1858 /* Simplify the unit mask expression, encode it, and make an attribute
1859 for the function_units_used function. */
1860 unitsmask
= simplify_by_exploding (unitsmask
);
1862 if (num_unit_opclasses
< NUM_UNITOP_CUTOFF
)
1863 unitsmask
= encode_units_mask (unitsmask
);
1866 /* We can no longer encode unitsmask at compile time, so emit code to
1867 calculate it at runtime. Rather, put a marker for where we'd do
1868 the code, and actually output it in write_attr_get(). */
1869 unitsmask
= attr_rtx (FFS
, unitsmask
);
1872 make_internal_attr ("*function_units_used", unitsmask
, 10);
1874 /* Create an array of ops for each unit. Add an extra unit for the
1875 result_ready_cost function that has the ops of all other units. */
1876 unit_ops
= (struct function_unit_op
***)
1877 xmalloc ((num_units
+ 1) * sizeof (struct function_unit_op
**));
1878 unit_num
= (struct function_unit
**)
1879 xmalloc ((num_units
+ 1) * sizeof (struct function_unit
*));
1881 unit_num
[num_units
] = unit
= (struct function_unit
*)
1882 xmalloc (sizeof (struct function_unit
));
1883 unit
->num
= num_units
;
1884 unit
->num_opclasses
= 0;
1886 for (unit
= units
; unit
; unit
= unit
->next
)
1888 unit_num
[num_units
]->num_opclasses
+= unit
->num_opclasses
;
1889 unit_num
[unit
->num
] = unit
;
1890 unit_ops
[unit
->num
] = op_array
= (struct function_unit_op
**)
1891 xmalloc (unit
->num_opclasses
* sizeof (struct function_unit_op
*));
1893 for (op
= unit
->ops
; op
; op
= op
->next
)
1894 op_array
[op
->num
] = op
;
1897 /* Compose the array of ops for the extra unit. */
1898 unit_ops
[num_units
] = op_array
= (struct function_unit_op
**)
1899 xmalloc (unit_num
[num_units
]->num_opclasses
1900 * sizeof (struct function_unit_op
*));
1902 for (unit
= units
, i
= 0; unit
; i
+= unit
->num_opclasses
, unit
= unit
->next
)
1903 memcpy (&op_array
[i
], unit_ops
[unit
->num
],
1904 unit
->num_opclasses
* sizeof (struct function_unit_op
*));
1906 /* Compute the ready cost function for each unit by computing the
1907 condition for each non-default value. */
1908 for (u
= 0; u
<= num_units
; u
++)
1914 op_array
= unit_ops
[unit
->num
];
1915 num
= unit
->num_opclasses
;
1917 /* Sort the array of ops into increasing ready cost order. */
1918 for (i
= 0; i
< num
; i
++)
1919 for (j
= num
- 1; j
> i
; j
--)
1920 if (op_array
[j
- 1]->ready
< op_array
[j
]->ready
)
1923 op_array
[j
] = op_array
[j
- 1];
1924 op_array
[j
- 1] = op
;
1927 /* Determine how many distinct non-default ready cost values there
1928 are. We use a default ready cost value of 1. */
1929 nvalues
= 0; value
= 1;
1930 for (i
= num
- 1; i
>= 0; i
--)
1931 if (op_array
[i
]->ready
> value
)
1933 value
= op_array
[i
]->ready
;
1938 readycost
= make_numeric_value (1);
1941 /* Construct the ready cost expression as a COND of each value from
1942 the largest to the smallest. */
1943 readycost
= rtx_alloc (COND
);
1944 XVEC (readycost
, 0) = rtvec_alloc (nvalues
* 2);
1945 XEXP (readycost
, 1) = make_numeric_value (1);
1949 value
= op_array
[0]->ready
;
1950 for (i
= 0; i
< num
; i
++)
1955 else if (op
->ready
== value
)
1956 orexp
= insert_right_side (IOR
, orexp
, op
->condexp
, -2, -2);
1959 XVECEXP (readycost
, 0, nvalues
* 2) = orexp
;
1960 XVECEXP (readycost
, 0, nvalues
* 2 + 1)
1961 = make_numeric_value (value
);
1964 orexp
= op
->condexp
;
1967 XVECEXP (readycost
, 0, nvalues
* 2) = orexp
;
1968 XVECEXP (readycost
, 0, nvalues
* 2 + 1) = make_numeric_value (value
);
1973 rtx max_blockage
= 0, min_blockage
= 0;
1975 /* Simplify the readycost expression by only considering insns
1976 that use the unit. */
1977 readycost
= simplify_knowing (readycost
, unit
->condexp
);
1979 /* Determine the blockage cost the executing insn (E) given
1980 the candidate insn (C). This is the maximum of the issue
1981 delay, the pipeline delay, and the simultaneity constraint.
1982 Each function_unit_op represents the characteristics of the
1983 candidate insn, so in the expressions below, C is a known
1984 term and E is an unknown term.
1986 We compute the blockage cost for each E for every possible C.
1987 Thus OP represents E, and READYCOST is a list of values for
1990 The issue delay function for C is op->issue_exp and is used to
1991 write the `<name>_unit_conflict_cost' function. Symbolically
1992 this is "ISSUE-DELAY (E,C)".
1994 The pipeline delay results form the FIFO constraint on the
1995 function unit and is "READY-COST (E) + 1 - READY-COST (C)".
1997 The simultaneity constraint is based on how long it takes to
1998 fill the unit given the minimum issue delay. FILL-TIME is the
1999 constant "MIN (ISSUE-DELAY (*,*)) * (SIMULTANEITY - 1)", and
2000 the simultaneity constraint is "READY-COST (E) - FILL-TIME"
2001 if SIMULTANEITY is nonzero and zero otherwise.
2003 Thus, BLOCKAGE (E,C) when SIMULTANEITY is zero is
2005 MAX (ISSUE-DELAY (E,C),
2006 READY-COST (E) - (READY-COST (C) - 1))
2010 MAX (ISSUE-DELAY (E,C),
2011 READY-COST (E) - (READY-COST (C) - 1),
2012 READY-COST (E) - FILL-TIME)
2014 The `<name>_unit_blockage' function is computed by determining
2015 this value for each candidate insn. As these values are
2016 computed, we also compute the upper and lower bounds for
2017 BLOCKAGE (E,*). These are combined to form the function
2018 `<name>_unit_blockage_range'. Finally, the maximum blockage
2019 cost, MAX (BLOCKAGE (*,*)), is computed. */
2021 for (op
= unit
->ops
; op
; op
= op
->next
)
2023 rtx blockage
= op
->issue_exp
;
2024 blockage
= simplify_knowing (blockage
, unit
->condexp
);
2026 /* Add this op's contribution to MAX (BLOCKAGE (E,*)) and
2027 MIN (BLOCKAGE (E,*)). */
2028 if (max_blockage
== 0)
2029 max_blockage
= min_blockage
= blockage
;
2033 = simplify_knowing (operate_exp (MAX_OP
, max_blockage
,
2037 = simplify_knowing (operate_exp (MIN_OP
, min_blockage
,
2042 /* Make an attribute for use in the blockage function. */
2043 str
= attr_printf ((strlen (unit
->name
) + sizeof "*_block_"
2045 "*%s_block_%d", unit
->name
, op
->num
);
2046 make_internal_attr (str
, blockage
, 1);
2049 /* Record MAX (BLOCKAGE (*,*)). */
2052 unit
->max_blockage
= max_attr_value (max_blockage
, &unknown
);
2055 /* See if the upper and lower bounds of BLOCKAGE (E,*) are the
2056 same. If so, the blockage function carries no additional
2057 information and is not written. */
2058 newexp
= operate_exp (EQ_OP
, max_blockage
, min_blockage
);
2059 newexp
= simplify_knowing (newexp
, unit
->condexp
);
2060 unit
->needs_blockage_function
2061 = (GET_CODE (newexp
) != CONST_STRING
2062 || atoi (XSTR (newexp
, 0)) != 1);
2064 /* If the all values of BLOCKAGE (E,C) have the same value,
2065 neither blockage function is written. */
2066 unit
->needs_range_function
2067 = (unit
->needs_blockage_function
2068 || GET_CODE (max_blockage
) != CONST_STRING
);
2070 if (unit
->needs_range_function
)
2072 /* Compute the blockage range function and make an attribute
2073 for writing its value. */
2074 newexp
= operate_exp (RANGE_OP
, min_blockage
, max_blockage
);
2075 newexp
= simplify_knowing (newexp
, unit
->condexp
);
2077 str
= attr_printf ((strlen (unit
->name
)
2078 + sizeof "*_unit_blockage_range"),
2079 "*%s_unit_blockage_range", unit
->name
);
2080 make_internal_attr (str
, newexp
, 20);
2083 str
= attr_printf (strlen (unit
->name
) + sizeof "*_unit_ready_cost",
2084 "*%s_unit_ready_cost", unit
->name
);
2087 str
= "*result_ready_cost";
2089 /* Make an attribute for the ready_cost function. Simplifying
2090 further with simplify_by_exploding doesn't win. */
2091 make_internal_attr (str
, readycost
, 0);
2094 /* For each unit that requires a conflict cost function, make an attribute
2095 that maps insns to the operation number. */
2096 for (unit
= units
; unit
; unit
= unit
->next
)
2100 if (! unit
->needs_conflict_function
2101 && ! unit
->needs_blockage_function
)
2104 caseexp
= rtx_alloc (COND
);
2105 XVEC (caseexp
, 0) = rtvec_alloc ((unit
->num_opclasses
- 1) * 2);
2107 for (op
= unit
->ops
; op
; op
= op
->next
)
2109 /* Make our adjustment to the COND being computed. If we are the
2110 last operation class, place our values into the default of the
2112 if (op
->num
== unit
->num_opclasses
- 1)
2114 XEXP (caseexp
, 1) = make_numeric_value (op
->num
);
2118 XVECEXP (caseexp
, 0, op
->num
* 2) = op
->condexp
;
2119 XVECEXP (caseexp
, 0, op
->num
* 2 + 1)
2120 = make_numeric_value (op
->num
);
2124 /* Simplifying caseexp with simplify_by_exploding doesn't win. */
2125 str
= attr_printf (strlen (unit
->name
) + sizeof "*_cases",
2126 "*%s_cases", unit
->name
);
2127 make_internal_attr (str
, caseexp
, 1);
2131 /* Simplify EXP given KNOWN_TRUE. */
2134 simplify_knowing (rtx exp
, rtx known_true
)
2136 if (GET_CODE (exp
) != CONST_STRING
)
2138 int unknown
= 0, max
;
2139 max
= max_attr_value (exp
, &unknown
);
2142 exp
= attr_rtx (IF_THEN_ELSE
, known_true
, exp
,
2143 make_numeric_value (max
));
2144 exp
= simplify_by_exploding (exp
);
2150 /* Translate the CONST_STRING expressions in X to change the encoding of
2151 value. On input, the value is a bitmask with a one bit for each unit
2152 used; on output, the value is the unit number (zero based) if one
2153 and only one unit is used or the one's complement of the bitmask. */
2156 encode_units_mask (rtx x
)
2163 code
= GET_CODE (x
);
2168 i
= atoi (XSTR (x
, 0));
2170 /* The sign bit encodes a one's complement mask. */
2172 else if (i
!= 0 && i
== (i
& -i
))
2173 /* Only one bit is set, so yield that unit number. */
2174 for (j
= 0; (i
>>= 1) != 0; j
++)
2178 return attr_rtx (CONST_STRING
, attr_printf (MAX_DIGITS
, "%d", j
));
2196 /* Compare the elements. If any pair of corresponding elements
2197 fail to match, return 0 for the whole things. */
2199 fmt
= GET_RTX_FORMAT (code
);
2200 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
2206 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
2207 XVECEXP (x
, i
, j
) = encode_units_mask (XVECEXP (x
, i
, j
));
2211 XEXP (x
, i
) = encode_units_mask (XEXP (x
, i
));
2218 /* Once all attributes and insns have been read and checked, we construct for
2219 each attribute value a list of all the insns that have that value for
2223 fill_attr (struct attr_desc
*attr
)
2225 struct attr_value
*av
;
2226 struct insn_ent
*ie
;
2227 struct insn_def
*id
;
2231 /* Don't fill constant attributes. The value is independent of
2232 any particular insn. */
2236 for (id
= defs
; id
; id
= id
->next
)
2238 /* If no value is specified for this insn for this attribute, use the
2241 if (XVEC (id
->def
, id
->vec_idx
))
2242 for (i
= 0; i
< XVECLEN (id
->def
, id
->vec_idx
); i
++)
2243 if (! strcmp (XSTR (XEXP (XVECEXP (id
->def
, id
->vec_idx
, i
), 0), 0),
2245 value
= XEXP (XVECEXP (id
->def
, id
->vec_idx
, i
), 1);
2248 av
= attr
->default_val
;
2250 av
= get_attr_value (value
, attr
, id
->insn_code
);
2252 ie
= (struct insn_ent
*) oballoc (sizeof (struct insn_ent
));
2253 ie
->insn_code
= id
->insn_code
;
2254 ie
->insn_index
= id
->insn_code
;
2255 insert_insn_ent (av
, ie
);
2259 /* Given an expression EXP, see if it is a COND or IF_THEN_ELSE that has a
2260 test that checks relative positions of insns (uses MATCH_DUP or PC).
2261 If so, replace it with what is obtained by passing the expression to
2262 ADDRESS_FN. If not but it is a COND or IF_THEN_ELSE, call this routine
2263 recursively on each value (including the default value). Otherwise,
2264 return the value returned by NO_ADDRESS_FN applied to EXP. */
2267 substitute_address (rtx exp
, rtx (*no_address_fn
) (rtx
),
2268 rtx (*address_fn
) (rtx
))
2273 if (GET_CODE (exp
) == COND
)
2275 /* See if any tests use addresses. */
2277 for (i
= 0; i
< XVECLEN (exp
, 0); i
+= 2)
2278 walk_attr_value (XVECEXP (exp
, 0, i
));
2281 return (*address_fn
) (exp
);
2283 /* Make a new copy of this COND, replacing each element. */
2284 newexp
= rtx_alloc (COND
);
2285 XVEC (newexp
, 0) = rtvec_alloc (XVECLEN (exp
, 0));
2286 for (i
= 0; i
< XVECLEN (exp
, 0); i
+= 2)
2288 XVECEXP (newexp
, 0, i
) = XVECEXP (exp
, 0, i
);
2289 XVECEXP (newexp
, 0, i
+ 1)
2290 = substitute_address (XVECEXP (exp
, 0, i
+ 1),
2291 no_address_fn
, address_fn
);
2294 XEXP (newexp
, 1) = substitute_address (XEXP (exp
, 1),
2295 no_address_fn
, address_fn
);
2300 else if (GET_CODE (exp
) == IF_THEN_ELSE
)
2303 walk_attr_value (XEXP (exp
, 0));
2305 return (*address_fn
) (exp
);
2307 return attr_rtx (IF_THEN_ELSE
,
2308 substitute_address (XEXP (exp
, 0),
2309 no_address_fn
, address_fn
),
2310 substitute_address (XEXP (exp
, 1),
2311 no_address_fn
, address_fn
),
2312 substitute_address (XEXP (exp
, 2),
2313 no_address_fn
, address_fn
));
2316 return (*no_address_fn
) (exp
);
2319 /* Make new attributes from the `length' attribute. The following are made,
2320 each corresponding to a function called from `shorten_branches' or
2323 *insn_default_length This is the length of the insn to be returned
2324 by `get_attr_length' before `shorten_branches'
2325 has been called. In each case where the length
2326 depends on relative addresses, the largest
2327 possible is used. This routine is also used
2328 to compute the initial size of the insn.
2330 *insn_variable_length_p This returns 1 if the insn's length depends
2331 on relative addresses, zero otherwise.
2333 *insn_current_length This is only called when it is known that the
2334 insn has a variable length and returns the
2335 current length, based on relative addresses.
2339 make_length_attrs (void)
2341 static const char *const new_names
[] = {"*insn_default_length",
2342 "*insn_variable_length_p",
2343 "*insn_current_length"};
2344 static rtx (*const no_address_fn
[]) (rtx
) = {identity_fn
, zero_fn
, zero_fn
};
2345 static rtx (*const address_fn
[]) (rtx
) = {max_fn
, one_fn
, identity_fn
};
2347 struct attr_desc
*length_attr
, *new_attr
;
2348 struct attr_value
*av
, *new_av
;
2349 struct insn_ent
*ie
, *new_ie
;
2351 /* See if length attribute is defined. If so, it must be numeric. Make
2352 it special so we don't output anything for it. */
2353 length_attr
= find_attr ("length", 0);
2354 if (length_attr
== 0)
2357 if (! length_attr
->is_numeric
)
2358 fatal ("length attribute must be numeric");
2360 length_attr
->is_const
= 0;
2361 length_attr
->is_special
= 1;
2363 /* Make each new attribute, in turn. */
2364 for (i
= 0; i
< ARRAY_SIZE (new_names
); i
++)
2366 make_internal_attr (new_names
[i
],
2367 substitute_address (length_attr
->default_val
->value
,
2368 no_address_fn
[i
], address_fn
[i
]),
2370 new_attr
= find_attr (new_names
[i
], 0);
2371 for (av
= length_attr
->first_value
; av
; av
= av
->next
)
2372 for (ie
= av
->first_insn
; ie
; ie
= ie
->next
)
2374 new_av
= get_attr_value (substitute_address (av
->value
,
2377 new_attr
, ie
->insn_code
);
2378 new_ie
= (struct insn_ent
*) oballoc (sizeof (struct insn_ent
));
2379 new_ie
->insn_code
= ie
->insn_code
;
2380 new_ie
->insn_index
= ie
->insn_index
;
2381 insert_insn_ent (new_av
, new_ie
);
2386 /* Utility functions called from above routine. */
2389 identity_fn (rtx exp
)
2395 zero_fn (rtx exp ATTRIBUTE_UNUSED
)
2397 return make_numeric_value (0);
2401 one_fn (rtx exp ATTRIBUTE_UNUSED
)
2403 return make_numeric_value (1);
2410 return make_numeric_value (max_attr_value (exp
, &unknown
));
2414 write_length_unit_log (void)
2416 struct attr_desc
*length_attr
= find_attr ("length", 0);
2417 struct attr_value
*av
;
2418 struct insn_ent
*ie
;
2419 unsigned int length_unit_log
, length_or
;
2422 if (length_attr
== 0)
2424 length_or
= or_attr_value (length_attr
->default_val
->value
, &unknown
);
2425 for (av
= length_attr
->first_value
; av
; av
= av
->next
)
2426 for (ie
= av
->first_insn
; ie
; ie
= ie
->next
)
2427 length_or
|= or_attr_value (av
->value
, &unknown
);
2430 length_unit_log
= 0;
2433 length_or
= ~length_or
;
2434 for (length_unit_log
= 0; length_or
& 1; length_or
>>= 1)
2437 printf ("int length_unit_log = %u;\n", length_unit_log
);
2440 /* Take a COND expression and see if any of the conditions in it can be
2441 simplified. If any are known true or known false for the particular insn
2442 code, the COND can be further simplified.
2444 Also call ourselves on any COND operations that are values of this COND.
2446 We do not modify EXP; rather, we make and return a new rtx. */
2449 simplify_cond (rtx exp
, int insn_code
, int insn_index
)
2452 /* We store the desired contents here,
2453 then build a new expression if they don't match EXP. */
2454 rtx defval
= XEXP (exp
, 1);
2455 rtx new_defval
= XEXP (exp
, 1);
2456 int len
= XVECLEN (exp
, 0);
2457 rtx
*tests
= (rtx
*) xmalloc (len
* sizeof (rtx
));
2461 /* This lets us free all storage allocated below, if appropriate. */
2462 obstack_finish (rtl_obstack
);
2464 memcpy (tests
, XVEC (exp
, 0)->elem
, len
* sizeof (rtx
));
2466 /* See if default value needs simplification. */
2467 if (GET_CODE (defval
) == COND
)
2468 new_defval
= simplify_cond (defval
, insn_code
, insn_index
);
2470 /* Simplify the subexpressions, and see what tests we can get rid of. */
2472 for (i
= 0; i
< len
; i
+= 2)
2474 rtx newtest
, newval
;
2476 /* Simplify this test. */
2477 newtest
= simplify_test_exp_in_temp (tests
[i
], insn_code
, insn_index
);
2480 newval
= tests
[i
+ 1];
2481 /* See if this value may need simplification. */
2482 if (GET_CODE (newval
) == COND
)
2483 newval
= simplify_cond (newval
, insn_code
, insn_index
);
2485 /* Look for ways to delete or combine this test. */
2486 if (newtest
== true_rtx
)
2488 /* If test is true, make this value the default
2489 and discard this + any following tests. */
2491 defval
= tests
[i
+ 1];
2492 new_defval
= newval
;
2495 else if (newtest
== false_rtx
)
2497 /* If test is false, discard it and its value. */
2498 for (j
= i
; j
< len
- 2; j
++)
2499 tests
[j
] = tests
[j
+ 2];
2503 else if (i
> 0 && attr_equal_p (newval
, tests
[i
- 1]))
2505 /* If this value and the value for the prev test are the same,
2509 = insert_right_side (IOR
, tests
[i
- 2], newtest
,
2510 insn_code
, insn_index
);
2512 /* Delete this test/value. */
2513 for (j
= i
; j
< len
- 2; j
++)
2514 tests
[j
] = tests
[j
+ 2];
2519 tests
[i
+ 1] = newval
;
2522 /* If the last test in a COND has the same value
2523 as the default value, that test isn't needed. */
2525 while (len
> 0 && attr_equal_p (tests
[len
- 1], new_defval
))
2528 /* See if we changed anything. */
2529 if (len
!= XVECLEN (exp
, 0) || new_defval
!= XEXP (exp
, 1))
2532 for (i
= 0; i
< len
; i
++)
2533 if (! attr_equal_p (tests
[i
], XVECEXP (exp
, 0, i
)))
2541 if (GET_CODE (defval
) == COND
)
2542 ret
= simplify_cond (defval
, insn_code
, insn_index
);
2550 rtx newexp
= rtx_alloc (COND
);
2552 XVEC (newexp
, 0) = rtvec_alloc (len
);
2553 memcpy (XVEC (newexp
, 0)->elem
, tests
, len
* sizeof (rtx
));
2554 XEXP (newexp
, 1) = new_defval
;
2561 /* Remove an insn entry from an attribute value. */
2564 remove_insn_ent (struct attr_value
*av
, struct insn_ent
*ie
)
2566 struct insn_ent
*previe
;
2568 if (av
->first_insn
== ie
)
2569 av
->first_insn
= ie
->next
;
2572 for (previe
= av
->first_insn
; previe
->next
!= ie
; previe
= previe
->next
)
2574 previe
->next
= ie
->next
;
2578 if (ie
->insn_code
== -1)
2579 av
->has_asm_insn
= 0;
2584 /* Insert an insn entry in an attribute value list. */
2587 insert_insn_ent (struct attr_value
*av
, struct insn_ent
*ie
)
2589 ie
->next
= av
->first_insn
;
2590 av
->first_insn
= ie
;
2592 if (ie
->insn_code
== -1)
2593 av
->has_asm_insn
= 1;
2598 /* This is a utility routine to take an expression that is a tree of either
2599 AND or IOR expressions and insert a new term. The new term will be
2600 inserted at the right side of the first node whose code does not match
2601 the root. A new node will be created with the root's code. Its left
2602 side will be the old right side and its right side will be the new
2605 If the `term' is itself a tree, all its leaves will be inserted. */
2608 insert_right_side (enum rtx_code code
, rtx exp
, rtx term
, int insn_code
, int insn_index
)
2612 /* Avoid consing in some special cases. */
2613 if (code
== AND
&& term
== true_rtx
)
2615 if (code
== AND
&& term
== false_rtx
)
2617 if (code
== AND
&& exp
== true_rtx
)
2619 if (code
== AND
&& exp
== false_rtx
)
2621 if (code
== IOR
&& term
== true_rtx
)
2623 if (code
== IOR
&& term
== false_rtx
)
2625 if (code
== IOR
&& exp
== true_rtx
)
2627 if (code
== IOR
&& exp
== false_rtx
)
2629 if (attr_equal_p (exp
, term
))
2632 if (GET_CODE (term
) == code
)
2634 exp
= insert_right_side (code
, exp
, XEXP (term
, 0),
2635 insn_code
, insn_index
);
2636 exp
= insert_right_side (code
, exp
, XEXP (term
, 1),
2637 insn_code
, insn_index
);
2642 if (GET_CODE (exp
) == code
)
2644 rtx
new = insert_right_side (code
, XEXP (exp
, 1),
2645 term
, insn_code
, insn_index
);
2646 if (new != XEXP (exp
, 1))
2647 /* Make a copy of this expression and call recursively. */
2648 newexp
= attr_rtx (code
, XEXP (exp
, 0), new);
2654 /* Insert the new term. */
2655 newexp
= attr_rtx (code
, exp
, term
);
2658 return simplify_test_exp_in_temp (newexp
, insn_code
, insn_index
);
2661 /* If we have an expression which AND's a bunch of
2662 (not (eq_attrq "alternative" "n"))
2663 terms, we may have covered all or all but one of the possible alternatives.
2664 If so, we can optimize. Similarly for IOR's of EQ_ATTR.
2666 This routine is passed an expression and either AND or IOR. It returns a
2667 bitmask indicating which alternatives are mentioned within EXP. */
2670 compute_alternative_mask (rtx exp
, enum rtx_code code
)
2673 if (GET_CODE (exp
) == code
)
2674 return compute_alternative_mask (XEXP (exp
, 0), code
)
2675 | compute_alternative_mask (XEXP (exp
, 1), code
);
2677 else if (code
== AND
&& GET_CODE (exp
) == NOT
2678 && GET_CODE (XEXP (exp
, 0)) == EQ_ATTR
2679 && XSTR (XEXP (exp
, 0), 0) == alternative_name
)
2680 string
= XSTR (XEXP (exp
, 0), 1);
2682 else if (code
== IOR
&& GET_CODE (exp
) == EQ_ATTR
2683 && XSTR (exp
, 0) == alternative_name
)
2684 string
= XSTR (exp
, 1);
2690 return 1 << (string
[0] - '0');
2691 return 1 << atoi (string
);
2694 /* Given I, a single-bit mask, return RTX to compare the `alternative'
2695 attribute with the value represented by that bit. */
2698 make_alternative_compare (int mask
)
2704 for (i
= 0; (mask
& (1 << i
)) == 0; i
++)
2707 newexp
= attr_rtx (EQ_ATTR
, alternative_name
, attr_numeral (i
));
2708 ATTR_IND_SIMPLIFIED_P (newexp
) = 1;
2713 /* If we are processing an (eq_attr "attr" "value") test, we find the value
2714 of "attr" for this insn code. From that value, we can compute a test
2715 showing when the EQ_ATTR will be true. This routine performs that
2716 computation. If a test condition involves an address, we leave the EQ_ATTR
2717 intact because addresses are only valid for the `length' attribute.
2719 EXP is the EQ_ATTR expression and VALUE is the value of that attribute
2720 for the insn corresponding to INSN_CODE and INSN_INDEX. */
2723 evaluate_eq_attr (rtx exp
, rtx value
, int insn_code
, int insn_index
)
2730 if (GET_CODE (value
) == CONST_STRING
)
2732 if (! strcmp (XSTR (value
, 0), XSTR (exp
, 1)))
2737 else if (GET_CODE (value
) == SYMBOL_REF
)
2742 if (GET_CODE (exp
) != EQ_ATTR
)
2745 if (strlen (XSTR (exp
, 0)) + strlen (XSTR (exp
, 1)) + 2 > 256)
2748 strcpy (string
, XSTR (exp
, 0));
2749 strcat (string
, "_");
2750 strcat (string
, XSTR (exp
, 1));
2751 for (p
= string
; *p
; p
++)
2754 newexp
= attr_rtx (EQ
, value
,
2755 attr_rtx (SYMBOL_REF
,
2756 attr_string (string
, strlen (string
))));
2758 else if (GET_CODE (value
) == COND
)
2760 /* We construct an IOR of all the cases for which the requested attribute
2761 value is present. Since we start with FALSE, if it is not present,
2762 FALSE will be returned.
2764 Each case is the AND of the NOT's of the previous conditions with the
2765 current condition; in the default case the current condition is TRUE.
2767 For each possible COND value, call ourselves recursively.
2769 The extra TRUE and FALSE expressions will be eliminated by another
2770 call to the simplification routine. */
2775 if (current_alternative_string
)
2776 clear_struct_flag (value
);
2778 for (i
= 0; i
< XVECLEN (value
, 0); i
+= 2)
2780 rtx
this = simplify_test_exp_in_temp (XVECEXP (value
, 0, i
),
2781 insn_code
, insn_index
);
2783 SIMPLIFY_ALTERNATIVE (this);
2785 right
= insert_right_side (AND
, andexp
, this,
2786 insn_code
, insn_index
);
2787 right
= insert_right_side (AND
, right
,
2788 evaluate_eq_attr (exp
,
2791 insn_code
, insn_index
),
2792 insn_code
, insn_index
);
2793 orexp
= insert_right_side (IOR
, orexp
, right
,
2794 insn_code
, insn_index
);
2796 /* Add this condition into the AND expression. */
2797 newexp
= attr_rtx (NOT
, this);
2798 andexp
= insert_right_side (AND
, andexp
, newexp
,
2799 insn_code
, insn_index
);
2802 /* Handle the default case. */
2803 right
= insert_right_side (AND
, andexp
,
2804 evaluate_eq_attr (exp
, XEXP (value
, 1),
2805 insn_code
, insn_index
),
2806 insn_code
, insn_index
);
2807 newexp
= insert_right_side (IOR
, orexp
, right
, insn_code
, insn_index
);
2812 /* If uses an address, must return original expression. But set the
2813 ATTR_IND_SIMPLIFIED_P bit so we don't try to simplify it again. */
2816 walk_attr_value (newexp
);
2820 /* This had `&& current_alternative_string', which seems to be wrong. */
2821 if (! ATTR_IND_SIMPLIFIED_P (exp
))
2822 return copy_rtx_unchanging (exp
);
2829 /* This routine is called when an AND of a term with a tree of AND's is
2830 encountered. If the term or its complement is present in the tree, it
2831 can be replaced with TRUE or FALSE, respectively.
2833 Note that (eq_attr "att" "v1") and (eq_attr "att" "v2") cannot both
2834 be true and hence are complementary.
2836 There is one special case: If we see
2837 (and (not (eq_attr "att" "v1"))
2838 (eq_attr "att" "v2"))
2839 this can be replaced by (eq_attr "att" "v2"). To do this we need to
2840 replace the term, not anything in the AND tree. So we pass a pointer to
2844 simplify_and_tree (rtx exp
, rtx
*pterm
, int insn_code
, int insn_index
)
2849 int left_eliminates_term
, right_eliminates_term
;
2851 if (GET_CODE (exp
) == AND
)
2853 left
= simplify_and_tree (XEXP (exp
, 0), pterm
, insn_code
, insn_index
);
2854 right
= simplify_and_tree (XEXP (exp
, 1), pterm
, insn_code
, insn_index
);
2855 if (left
!= XEXP (exp
, 0) || right
!= XEXP (exp
, 1))
2857 newexp
= attr_rtx (GET_CODE (exp
), left
, right
);
2859 exp
= simplify_test_exp_in_temp (newexp
, insn_code
, insn_index
);
2863 else if (GET_CODE (exp
) == IOR
)
2865 /* For the IOR case, we do the same as above, except that we can
2866 only eliminate `term' if both sides of the IOR would do so. */
2868 left
= simplify_and_tree (XEXP (exp
, 0), &temp
, insn_code
, insn_index
);
2869 left_eliminates_term
= (temp
== true_rtx
);
2872 right
= simplify_and_tree (XEXP (exp
, 1), &temp
, insn_code
, insn_index
);
2873 right_eliminates_term
= (temp
== true_rtx
);
2875 if (left_eliminates_term
&& right_eliminates_term
)
2878 if (left
!= XEXP (exp
, 0) || right
!= XEXP (exp
, 1))
2880 newexp
= attr_rtx (GET_CODE (exp
), left
, right
);
2882 exp
= simplify_test_exp_in_temp (newexp
, insn_code
, insn_index
);
2886 /* Check for simplifications. Do some extra checking here since this
2887 routine is called so many times. */
2892 else if (GET_CODE (exp
) == NOT
&& XEXP (exp
, 0) == *pterm
)
2895 else if (GET_CODE (*pterm
) == NOT
&& exp
== XEXP (*pterm
, 0))
2898 else if (GET_CODE (exp
) == EQ_ATTR
&& GET_CODE (*pterm
) == EQ_ATTR
)
2900 if (XSTR (exp
, 0) != XSTR (*pterm
, 0))
2903 if (! strcmp (XSTR (exp
, 1), XSTR (*pterm
, 1)))
2909 else if (GET_CODE (*pterm
) == EQ_ATTR
&& GET_CODE (exp
) == NOT
2910 && GET_CODE (XEXP (exp
, 0)) == EQ_ATTR
)
2912 if (XSTR (*pterm
, 0) != XSTR (XEXP (exp
, 0), 0))
2915 if (! strcmp (XSTR (*pterm
, 1), XSTR (XEXP (exp
, 0), 1)))
2921 else if (GET_CODE (exp
) == EQ_ATTR
&& GET_CODE (*pterm
) == NOT
2922 && GET_CODE (XEXP (*pterm
, 0)) == EQ_ATTR
)
2924 if (XSTR (exp
, 0) != XSTR (XEXP (*pterm
, 0), 0))
2927 if (! strcmp (XSTR (exp
, 1), XSTR (XEXP (*pterm
, 0), 1)))
2933 else if (GET_CODE (exp
) == NOT
&& GET_CODE (*pterm
) == NOT
)
2935 if (attr_equal_p (XEXP (exp
, 0), XEXP (*pterm
, 0)))
2939 else if (GET_CODE (exp
) == NOT
)
2941 if (attr_equal_p (XEXP (exp
, 0), *pterm
))
2945 else if (GET_CODE (*pterm
) == NOT
)
2947 if (attr_equal_p (XEXP (*pterm
, 0), exp
))
2951 else if (attr_equal_p (exp
, *pterm
))
2957 /* Similar to `simplify_and_tree', but for IOR trees. */
2960 simplify_or_tree (rtx exp
, rtx
*pterm
, int insn_code
, int insn_index
)
2965 int left_eliminates_term
, right_eliminates_term
;
2967 if (GET_CODE (exp
) == IOR
)
2969 left
= simplify_or_tree (XEXP (exp
, 0), pterm
, insn_code
, insn_index
);
2970 right
= simplify_or_tree (XEXP (exp
, 1), pterm
, insn_code
, insn_index
);
2971 if (left
!= XEXP (exp
, 0) || right
!= XEXP (exp
, 1))
2973 newexp
= attr_rtx (GET_CODE (exp
), left
, right
);
2975 exp
= simplify_test_exp_in_temp (newexp
, insn_code
, insn_index
);
2979 else if (GET_CODE (exp
) == AND
)
2981 /* For the AND case, we do the same as above, except that we can
2982 only eliminate `term' if both sides of the AND would do so. */
2984 left
= simplify_or_tree (XEXP (exp
, 0), &temp
, insn_code
, insn_index
);
2985 left_eliminates_term
= (temp
== false_rtx
);
2988 right
= simplify_or_tree (XEXP (exp
, 1), &temp
, insn_code
, insn_index
);
2989 right_eliminates_term
= (temp
== false_rtx
);
2991 if (left_eliminates_term
&& right_eliminates_term
)
2994 if (left
!= XEXP (exp
, 0) || right
!= XEXP (exp
, 1))
2996 newexp
= attr_rtx (GET_CODE (exp
), left
, right
);
2998 exp
= simplify_test_exp_in_temp (newexp
, insn_code
, insn_index
);
3002 if (attr_equal_p (exp
, *pterm
))
3005 else if (GET_CODE (exp
) == NOT
&& attr_equal_p (XEXP (exp
, 0), *pterm
))
3008 else if (GET_CODE (*pterm
) == NOT
&& attr_equal_p (XEXP (*pterm
, 0), exp
))
3011 else if (GET_CODE (*pterm
) == EQ_ATTR
&& GET_CODE (exp
) == NOT
3012 && GET_CODE (XEXP (exp
, 0)) == EQ_ATTR
3013 && XSTR (*pterm
, 0) == XSTR (XEXP (exp
, 0), 0))
3016 else if (GET_CODE (exp
) == EQ_ATTR
&& GET_CODE (*pterm
) == NOT
3017 && GET_CODE (XEXP (*pterm
, 0)) == EQ_ATTR
3018 && XSTR (exp
, 0) == XSTR (XEXP (*pterm
, 0), 0))
3024 /* Compute approximate cost of the expression. Used to decide whether
3025 expression is cheap enough for inline. */
3027 attr_rtx_cost (rtx x
)
3033 code
= GET_CODE (x
);
3042 /* Alternatives don't result into function call. */
3043 if (!strcmp (XSTR (x
, 0), "alternative"))
3050 const char *fmt
= GET_RTX_FORMAT (code
);
3051 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
3057 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
3058 cost
+= attr_rtx_cost (XVECEXP (x
, i
, j
));
3061 cost
+= attr_rtx_cost (XEXP (x
, i
));
3071 /* Simplify test expression and use temporary obstack in order to avoid
3072 memory bloat. Use ATTR_IND_SIMPLIFIED to avoid unnecessary simplifications
3073 and avoid unnecessary copying if possible. */
3076 simplify_test_exp_in_temp (rtx exp
, int insn_code
, int insn_index
)
3079 struct obstack
*old
;
3080 if (ATTR_IND_SIMPLIFIED_P (exp
))
3083 rtl_obstack
= temp_obstack
;
3084 x
= simplify_test_exp (exp
, insn_code
, insn_index
);
3086 if (x
== exp
|| rtl_obstack
== temp_obstack
)
3088 return attr_copy_rtx (x
);
3091 /* Given an expression, see if it can be simplified for a particular insn
3092 code based on the values of other attributes being tested. This can
3093 eliminate nested get_attr_... calls.
3095 Note that if an endless recursion is specified in the patterns, the
3096 optimization will loop. However, it will do so in precisely the cases where
3097 an infinite recursion loop could occur during compilation. It's better that
3101 simplify_test_exp (rtx exp
, int insn_code
, int insn_index
)
3104 struct attr_desc
*attr
;
3105 struct attr_value
*av
;
3106 struct insn_ent
*ie
;
3110 /* Don't re-simplify something we already simplified. */
3111 if (ATTR_IND_SIMPLIFIED_P (exp
) || ATTR_CURR_SIMPLIFIED_P (exp
))
3114 switch (GET_CODE (exp
))
3117 left
= SIMPLIFY_TEST_EXP (XEXP (exp
, 0), insn_code
, insn_index
);
3118 SIMPLIFY_ALTERNATIVE (left
);
3119 if (left
== false_rtx
)
3121 right
= SIMPLIFY_TEST_EXP (XEXP (exp
, 1), insn_code
, insn_index
);
3122 SIMPLIFY_ALTERNATIVE (right
);
3123 if (left
== false_rtx
)
3126 /* If either side is an IOR and we have (eq_attr "alternative" ..")
3127 present on both sides, apply the distributive law since this will
3128 yield simplifications. */
3129 if ((GET_CODE (left
) == IOR
|| GET_CODE (right
) == IOR
)
3130 && compute_alternative_mask (left
, IOR
)
3131 && compute_alternative_mask (right
, IOR
))
3133 if (GET_CODE (left
) == IOR
)
3140 newexp
= attr_rtx (IOR
,
3141 attr_rtx (AND
, left
, XEXP (right
, 0)),
3142 attr_rtx (AND
, left
, XEXP (right
, 1)));
3144 return SIMPLIFY_TEST_EXP (newexp
, insn_code
, insn_index
);
3147 /* Try with the term on both sides. */
3148 right
= simplify_and_tree (right
, &left
, insn_code
, insn_index
);
3149 if (left
== XEXP (exp
, 0) && right
== XEXP (exp
, 1))
3150 left
= simplify_and_tree (left
, &right
, insn_code
, insn_index
);
3152 if (left
== false_rtx
|| right
== false_rtx
)
3154 else if (left
== true_rtx
)
3158 else if (right
== true_rtx
)
3162 /* See if all or all but one of the insn's alternatives are specified
3163 in this tree. Optimize if so. */
3165 else if (insn_code
>= 0
3166 && (GET_CODE (left
) == AND
3167 || (GET_CODE (left
) == NOT
3168 && GET_CODE (XEXP (left
, 0)) == EQ_ATTR
3169 && XSTR (XEXP (left
, 0), 0) == alternative_name
)
3170 || GET_CODE (right
) == AND
3171 || (GET_CODE (right
) == NOT
3172 && GET_CODE (XEXP (right
, 0)) == EQ_ATTR
3173 && XSTR (XEXP (right
, 0), 0) == alternative_name
)))
3175 i
= compute_alternative_mask (exp
, AND
);
3176 if (i
& ~insn_alternatives
[insn_code
])
3177 fatal ("invalid alternative specified for pattern number %d",
3180 /* If all alternatives are excluded, this is false. */
3181 i
^= insn_alternatives
[insn_code
];
3184 else if ((i
& (i
- 1)) == 0 && insn_alternatives
[insn_code
] > 1)
3186 /* If just one excluded, AND a comparison with that one to the
3187 front of the tree. The others will be eliminated by
3188 optimization. We do not want to do this if the insn has one
3189 alternative and we have tested none of them! */
3190 left
= make_alternative_compare (i
);
3191 right
= simplify_and_tree (exp
, &left
, insn_code
, insn_index
);
3192 newexp
= attr_rtx (AND
, left
, right
);
3194 return SIMPLIFY_TEST_EXP (newexp
, insn_code
, insn_index
);
3198 if (left
!= XEXP (exp
, 0) || right
!= XEXP (exp
, 1))
3200 newexp
= attr_rtx (AND
, left
, right
);
3201 return SIMPLIFY_TEST_EXP (newexp
, insn_code
, insn_index
);
3206 left
= SIMPLIFY_TEST_EXP (XEXP (exp
, 0), insn_code
, insn_index
);
3207 SIMPLIFY_ALTERNATIVE (left
);
3208 if (left
== true_rtx
)
3210 right
= SIMPLIFY_TEST_EXP (XEXP (exp
, 1), insn_code
, insn_index
);
3211 SIMPLIFY_ALTERNATIVE (right
);
3212 if (right
== true_rtx
)
3215 right
= simplify_or_tree (right
, &left
, insn_code
, insn_index
);
3216 if (left
== XEXP (exp
, 0) && right
== XEXP (exp
, 1))
3217 left
= simplify_or_tree (left
, &right
, insn_code
, insn_index
);
3219 if (right
== true_rtx
|| left
== true_rtx
)
3221 else if (left
== false_rtx
)
3225 else if (right
== false_rtx
)
3230 /* Test for simple cases where the distributive law is useful. I.e.,
3231 convert (ior (and (x) (y))
3237 else if (GET_CODE (left
) == AND
&& GET_CODE (right
) == AND
3238 && attr_equal_p (XEXP (left
, 0), XEXP (right
, 0)))
3240 newexp
= attr_rtx (IOR
, XEXP (left
, 1), XEXP (right
, 1));
3242 left
= XEXP (left
, 0);
3244 newexp
= attr_rtx (AND
, left
, right
);
3245 return SIMPLIFY_TEST_EXP (newexp
, insn_code
, insn_index
);
3248 /* See if all or all but one of the insn's alternatives are specified
3249 in this tree. Optimize if so. */
3251 else if (insn_code
>= 0
3252 && (GET_CODE (left
) == IOR
3253 || (GET_CODE (left
) == EQ_ATTR
3254 && XSTR (left
, 0) == alternative_name
)
3255 || GET_CODE (right
) == IOR
3256 || (GET_CODE (right
) == EQ_ATTR
3257 && XSTR (right
, 0) == alternative_name
)))
3259 i
= compute_alternative_mask (exp
, IOR
);
3260 if (i
& ~insn_alternatives
[insn_code
])
3261 fatal ("invalid alternative specified for pattern number %d",
3264 /* If all alternatives are included, this is true. */
3265 i
^= insn_alternatives
[insn_code
];
3268 else if ((i
& (i
- 1)) == 0 && insn_alternatives
[insn_code
] > 1)
3270 /* If just one excluded, IOR a comparison with that one to the
3271 front of the tree. The others will be eliminated by
3272 optimization. We do not want to do this if the insn has one
3273 alternative and we have tested none of them! */
3274 left
= make_alternative_compare (i
);
3275 right
= simplify_and_tree (exp
, &left
, insn_code
, insn_index
);
3276 newexp
= attr_rtx (IOR
, attr_rtx (NOT
, left
), right
);
3278 return SIMPLIFY_TEST_EXP (newexp
, insn_code
, insn_index
);
3282 if (left
!= XEXP (exp
, 0) || right
!= XEXP (exp
, 1))
3284 newexp
= attr_rtx (IOR
, left
, right
);
3285 return SIMPLIFY_TEST_EXP (newexp
, insn_code
, insn_index
);
3290 if (GET_CODE (XEXP (exp
, 0)) == NOT
)
3292 left
= SIMPLIFY_TEST_EXP (XEXP (XEXP (exp
, 0), 0),
3293 insn_code
, insn_index
);
3294 SIMPLIFY_ALTERNATIVE (left
);
3298 left
= SIMPLIFY_TEST_EXP (XEXP (exp
, 0), insn_code
, insn_index
);
3299 SIMPLIFY_ALTERNATIVE (left
);
3300 if (GET_CODE (left
) == NOT
)
3301 return XEXP (left
, 0);
3303 if (left
== false_rtx
)
3305 else if (left
== true_rtx
)
3308 /* Try to apply De`Morgan's laws. */
3309 else if (GET_CODE (left
) == IOR
)
3311 newexp
= attr_rtx (AND
,
3312 attr_rtx (NOT
, XEXP (left
, 0)),
3313 attr_rtx (NOT
, XEXP (left
, 1)));
3315 newexp
= SIMPLIFY_TEST_EXP (newexp
, insn_code
, insn_index
);
3317 else if (GET_CODE (left
) == AND
)
3319 newexp
= attr_rtx (IOR
,
3320 attr_rtx (NOT
, XEXP (left
, 0)),
3321 attr_rtx (NOT
, XEXP (left
, 1)));
3323 newexp
= SIMPLIFY_TEST_EXP (newexp
, insn_code
, insn_index
);
3325 else if (left
!= XEXP (exp
, 0))
3327 newexp
= attr_rtx (NOT
, left
);
3332 if (current_alternative_string
&& XSTR (exp
, 0) == alternative_name
)
3333 return (XSTR (exp
, 1) == current_alternative_string
3334 ? true_rtx
: false_rtx
);
3336 /* Look at the value for this insn code in the specified attribute.
3337 We normally can replace this comparison with the condition that
3338 would give this insn the values being tested for. */
3339 if (XSTR (exp
, 0) != alternative_name
3340 && (attr
= find_attr (XSTR (exp
, 0), 0)) != NULL
)
3341 for (av
= attr
->first_value
; av
; av
= av
->next
)
3342 for (ie
= av
->first_insn
; ie
; ie
= ie
->next
)
3343 if (ie
->insn_code
== insn_code
)
3346 x
= evaluate_eq_attr (exp
, av
->value
, insn_code
, insn_index
);
3347 x
= SIMPLIFY_TEST_EXP (x
, insn_code
, insn_index
);
3348 if (attr_rtx_cost(x
) < 20)
3357 /* We have already simplified this expression. Simplifying it again
3358 won't buy anything unless we weren't given a valid insn code
3359 to process (i.e., we are canonicalizing something.). */
3360 if (insn_code
!= -2 /* Seems wrong: && current_alternative_string. */
3361 && ! ATTR_IND_SIMPLIFIED_P (newexp
))
3362 return copy_rtx_unchanging (newexp
);
3367 /* Optimize the attribute lists by seeing if we can determine conditional
3368 values from the known values of other attributes. This will save subroutine
3369 calls during the compilation. */
3372 optimize_attrs (void)
3374 struct attr_desc
*attr
;
3375 struct attr_value
*av
;
3376 struct insn_ent
*ie
;
3379 struct attr_value_list
3381 struct attr_value
*av
;
3382 struct insn_ent
*ie
;
3383 struct attr_desc
*attr
;
3384 struct attr_value_list
*next
;
3386 struct attr_value_list
**insn_code_values
;
3387 struct attr_value_list
*ivbuf
;
3388 struct attr_value_list
*iv
;
3390 /* For each insn code, make a list of all the insn_ent's for it,
3391 for all values for all attributes. */
3393 if (num_insn_ents
== 0)
3396 /* Make 2 extra elements, for "code" values -2 and -1. */
3398 = (struct attr_value_list
**) xmalloc ((insn_code_number
+ 2)
3399 * sizeof (struct attr_value_list
*));
3400 memset ((char *) insn_code_values
, 0,
3401 (insn_code_number
+ 2) * sizeof (struct attr_value_list
*));
3403 /* Offset the table address so we can index by -2 or -1. */
3404 insn_code_values
+= 2;
3406 iv
= ivbuf
= ((struct attr_value_list
*)
3407 xmalloc (num_insn_ents
* sizeof (struct attr_value_list
)));
3409 for (i
= 0; i
< MAX_ATTRS_INDEX
; i
++)
3410 for (attr
= attrs
[i
]; attr
; attr
= attr
->next
)
3411 for (av
= attr
->first_value
; av
; av
= av
->next
)
3412 for (ie
= av
->first_insn
; ie
; ie
= ie
->next
)
3417 iv
->next
= insn_code_values
[ie
->insn_code
];
3418 insn_code_values
[ie
->insn_code
] = iv
;
3422 /* Sanity check on num_insn_ents. */
3423 if (iv
!= ivbuf
+ num_insn_ents
)
3426 /* Process one insn code at a time. */
3427 for (i
= -2; i
< insn_code_number
; i
++)
3429 /* Clear the ATTR_CURR_SIMPLIFIED_P flag everywhere relevant.
3430 We use it to mean "already simplified for this insn". */
3431 for (iv
= insn_code_values
[i
]; iv
; iv
= iv
->next
)
3432 clear_struct_flag (iv
->av
->value
);
3434 for (iv
= insn_code_values
[i
]; iv
; iv
= iv
->next
)
3436 struct obstack
*old
= rtl_obstack
;
3441 if (GET_CODE (av
->value
) != COND
)
3444 rtl_obstack
= temp_obstack
;
3446 while (GET_CODE (newexp
) == COND
)
3448 rtx newexp2
= simplify_cond (newexp
, ie
->insn_code
,
3450 if (newexp2
== newexp
)
3456 if (newexp
!= av
->value
)
3458 newexp
= attr_copy_rtx (newexp
);
3459 remove_insn_ent (av
, ie
);
3460 av
= get_attr_value (newexp
, attr
, ie
->insn_code
);
3462 insert_insn_ent (av
, ie
);
3468 free (insn_code_values
- 2);
3471 /* If EXP is a suitable expression, reorganize it by constructing an
3472 equivalent expression that is a COND with the tests being all combinations
3473 of attribute values and the values being simple constants. */
3476 simplify_by_exploding (rtx exp
)
3478 rtx list
= 0, link
, condexp
, defval
= NULL_RTX
;
3479 struct dimension
*space
;
3480 rtx
*condtest
, *condval
;
3481 int i
, j
, total
, ndim
= 0;
3482 int most_tests
, num_marks
, new_marks
;
3485 /* Locate all the EQ_ATTR expressions. */
3486 if (! find_and_mark_used_attributes (exp
, &list
, &ndim
) || ndim
== 0)
3488 unmark_used_attributes (list
, 0, 0);
3492 /* Create an attribute space from the list of used attributes. For each
3493 dimension in the attribute space, record the attribute, list of values
3494 used, and number of values used. Add members to the list of values to
3495 cover the domain of the attribute. This makes the expanded COND form
3496 order independent. */
3498 space
= (struct dimension
*) xmalloc (ndim
* sizeof (struct dimension
));
3501 for (ndim
= 0; list
; ndim
++)
3503 /* Pull the first attribute value from the list and record that
3504 attribute as another dimension in the attribute space. */
3505 const char *name
= XSTR (XEXP (list
, 0), 0);
3508 if ((space
[ndim
].attr
= find_attr (name
, 0)) == 0
3509 || space
[ndim
].attr
->is_numeric
)
3511 unmark_used_attributes (list
, space
, ndim
);
3515 /* Add all remaining attribute values that refer to this attribute. */
3516 space
[ndim
].num_values
= 0;
3517 space
[ndim
].values
= 0;
3519 for (link
= list
; link
; link
= *prev
)
3520 if (! strcmp (XSTR (XEXP (link
, 0), 0), name
))
3522 space
[ndim
].num_values
++;
3523 *prev
= XEXP (link
, 1);
3524 XEXP (link
, 1) = space
[ndim
].values
;
3525 space
[ndim
].values
= link
;
3528 prev
= &XEXP (link
, 1);
3530 /* Add sufficient members to the list of values to make the list
3531 mutually exclusive and record the total size of the attribute
3533 total
*= add_values_to_cover (&space
[ndim
]);
3536 /* Sort the attribute space so that the attributes go from non-constant
3537 to constant and from most values to least values. */
3538 for (i
= 0; i
< ndim
; i
++)
3539 for (j
= ndim
- 1; j
> i
; j
--)
3540 if ((space
[j
-1].attr
->is_const
&& !space
[j
].attr
->is_const
)
3541 || space
[j
-1].num_values
< space
[j
].num_values
)
3543 struct dimension tmp
;
3545 space
[j
] = space
[j
- 1];
3549 /* Establish the initial current value. */
3550 for (i
= 0; i
< ndim
; i
++)
3551 space
[i
].current_value
= space
[i
].values
;
3553 condtest
= (rtx
*) xmalloc (total
* sizeof (rtx
));
3554 condval
= (rtx
*) xmalloc (total
* sizeof (rtx
));
3556 /* Expand the tests and values by iterating over all values in the
3560 condtest
[i
] = test_for_current_value (space
, ndim
);
3561 condval
[i
] = simplify_with_current_value (exp
, space
, ndim
);
3562 if (! increment_current_value (space
, ndim
))
3568 /* We are now finished with the original expression. */
3569 unmark_used_attributes (0, space
, ndim
);
3572 /* Find the most used constant value and make that the default. */
3574 for (i
= num_marks
= 0; i
< total
; i
++)
3575 if (GET_CODE (condval
[i
]) == CONST_STRING
3576 && ! ATTR_EQ_ATTR_P (condval
[i
]))
3578 /* Mark the unmarked constant value and count how many are marked. */
3579 ATTR_EQ_ATTR_P (condval
[i
]) = 1;
3580 for (j
= new_marks
= 0; j
< total
; j
++)
3581 if (GET_CODE (condval
[j
]) == CONST_STRING
3582 && ATTR_EQ_ATTR_P (condval
[j
]))
3584 if (new_marks
- num_marks
> most_tests
)
3586 most_tests
= new_marks
- num_marks
;
3587 defval
= condval
[i
];
3589 num_marks
= new_marks
;
3591 /* Clear all the marks. */
3592 for (i
= 0; i
< total
; i
++)
3593 ATTR_EQ_ATTR_P (condval
[i
]) = 0;
3595 /* Give up if nothing is constant. */
3599 /* If all values are the default, use that. */
3600 else if (total
== most_tests
)
3603 /* Make a COND with the most common constant value the default. (A more
3604 complex method where tests with the same value were combined didn't
3605 seem to improve things.) */
3608 condexp
= rtx_alloc (COND
);
3609 XVEC (condexp
, 0) = rtvec_alloc ((total
- most_tests
) * 2);
3610 XEXP (condexp
, 1) = defval
;
3611 for (i
= j
= 0; i
< total
; i
++)
3612 if (condval
[i
] != defval
)
3614 XVECEXP (condexp
, 0, 2 * j
) = condtest
[i
];
3615 XVECEXP (condexp
, 0, 2 * j
+ 1) = condval
[i
];
3625 /* Set the ATTR_EQ_ATTR_P flag for all EQ_ATTR expressions in EXP and
3626 verify that EXP can be simplified to a constant term if all the EQ_ATTR
3627 tests have known value. */
3630 find_and_mark_used_attributes (rtx exp
, rtx
*terms
, int *nterms
)
3634 switch (GET_CODE (exp
))
3637 if (! ATTR_EQ_ATTR_P (exp
))
3639 rtx link
= rtx_alloc (EXPR_LIST
);
3640 XEXP (link
, 0) = exp
;
3641 XEXP (link
, 1) = *terms
;
3644 ATTR_EQ_ATTR_P (exp
) = 1;
3653 if (! find_and_mark_used_attributes (XEXP (exp
, 2), terms
, nterms
))
3657 if (! find_and_mark_used_attributes (XEXP (exp
, 1), terms
, nterms
))
3660 if (! find_and_mark_used_attributes (XEXP (exp
, 0), terms
, nterms
))
3665 for (i
= 0; i
< XVECLEN (exp
, 0); i
++)
3666 if (! find_and_mark_used_attributes (XVECEXP (exp
, 0, i
), terms
, nterms
))
3668 if (! find_and_mark_used_attributes (XEXP (exp
, 1), terms
, nterms
))
3677 /* Clear the ATTR_EQ_ATTR_P flag in all EQ_ATTR expressions on LIST and
3678 in the values of the NDIM-dimensional attribute space SPACE. */
3681 unmark_used_attributes (rtx list
, struct dimension
*space
, int ndim
)
3686 for (i
= 0; i
< ndim
; i
++)
3687 unmark_used_attributes (space
[i
].values
, 0, 0);
3689 for (link
= list
; link
; link
= XEXP (link
, 1))
3691 exp
= XEXP (link
, 0);
3692 if (GET_CODE (exp
) == EQ_ATTR
)
3693 ATTR_EQ_ATTR_P (exp
) = 0;
3697 /* Update the attribute dimension DIM so that all values of the attribute
3698 are tested. Return the updated number of values. */
3701 add_values_to_cover (struct dimension
*dim
)
3703 struct attr_value
*av
;
3704 rtx exp
, link
, *prev
;
3707 for (av
= dim
->attr
->first_value
; av
; av
= av
->next
)
3708 if (GET_CODE (av
->value
) == CONST_STRING
)
3711 if (nalt
< dim
->num_values
)
3713 else if (nalt
== dim
->num_values
)
3716 else if (nalt
* 2 < dim
->num_values
* 3)
3718 /* Most all the values of the attribute are used, so add all the unused
3720 prev
= &dim
->values
;
3721 for (link
= dim
->values
; link
; link
= *prev
)
3722 prev
= &XEXP (link
, 1);
3724 for (av
= dim
->attr
->first_value
; av
; av
= av
->next
)
3725 if (GET_CODE (av
->value
) == CONST_STRING
)
3727 exp
= attr_eq (dim
->attr
->name
, XSTR (av
->value
, 0));
3728 if (ATTR_EQ_ATTR_P (exp
))
3731 link
= rtx_alloc (EXPR_LIST
);
3732 XEXP (link
, 0) = exp
;
3735 prev
= &XEXP (link
, 1);
3737 dim
->num_values
= nalt
;
3741 rtx orexp
= false_rtx
;
3743 /* Very few values are used, so compute a mutually exclusive
3744 expression. (We could do this for numeric values if that becomes
3746 prev
= &dim
->values
;
3747 for (link
= dim
->values
; link
; link
= *prev
)
3749 orexp
= insert_right_side (IOR
, orexp
, XEXP (link
, 0), -2, -2);
3750 prev
= &XEXP (link
, 1);
3752 link
= rtx_alloc (EXPR_LIST
);
3753 XEXP (link
, 0) = attr_rtx (NOT
, orexp
);
3758 return dim
->num_values
;
3761 /* Increment the current value for the NDIM-dimensional attribute space SPACE
3762 and return FALSE if the increment overflowed. */
3765 increment_current_value (struct dimension
*space
, int ndim
)
3769 for (i
= ndim
- 1; i
>= 0; i
--)
3771 if ((space
[i
].current_value
= XEXP (space
[i
].current_value
, 1)) == 0)
3772 space
[i
].current_value
= space
[i
].values
;
3779 /* Construct an expression corresponding to the current value for the
3780 NDIM-dimensional attribute space SPACE. */
3783 test_for_current_value (struct dimension
*space
, int ndim
)
3788 for (i
= 0; i
< ndim
; i
++)
3789 exp
= insert_right_side (AND
, exp
, XEXP (space
[i
].current_value
, 0),
3795 /* Given the current value of the NDIM-dimensional attribute space SPACE,
3796 set the corresponding EQ_ATTR expressions to that value and reduce
3797 the expression EXP as much as possible. On input [and output], all
3798 known EQ_ATTR expressions are set to FALSE. */
3801 simplify_with_current_value (rtx exp
, struct dimension
*space
, int ndim
)
3806 /* Mark each current value as TRUE. */
3807 for (i
= 0; i
< ndim
; i
++)
3809 x
= XEXP (space
[i
].current_value
, 0);
3810 if (GET_CODE (x
) == EQ_ATTR
)
3811 ATTR_EQ_ATTR_P (x
) = 0;
3814 exp
= simplify_with_current_value_aux (exp
);
3816 /* Change each current value back to FALSE. */
3817 for (i
= 0; i
< ndim
; i
++)
3819 x
= XEXP (space
[i
].current_value
, 0);
3820 if (GET_CODE (x
) == EQ_ATTR
)
3821 ATTR_EQ_ATTR_P (x
) = 1;
3827 /* Reduce the expression EXP based on the ATTR_EQ_ATTR_P settings of
3828 all EQ_ATTR expressions. */
3831 simplify_with_current_value_aux (rtx exp
)
3836 switch (GET_CODE (exp
))
3839 if (ATTR_EQ_ATTR_P (exp
))
3848 cond
= simplify_with_current_value_aux (XEXP (exp
, 0));
3849 if (cond
== true_rtx
)
3850 return simplify_with_current_value_aux (XEXP (exp
, 1));
3851 else if (cond
== false_rtx
)
3852 return simplify_with_current_value_aux (XEXP (exp
, 2));
3854 return attr_rtx (IF_THEN_ELSE
, cond
,
3855 simplify_with_current_value_aux (XEXP (exp
, 1)),
3856 simplify_with_current_value_aux (XEXP (exp
, 2)));
3859 cond
= simplify_with_current_value_aux (XEXP (exp
, 1));
3860 if (cond
== true_rtx
)
3862 else if (cond
== false_rtx
)
3863 return simplify_with_current_value_aux (XEXP (exp
, 0));
3865 return attr_rtx (IOR
, cond
,
3866 simplify_with_current_value_aux (XEXP (exp
, 0)));
3869 cond
= simplify_with_current_value_aux (XEXP (exp
, 1));
3870 if (cond
== true_rtx
)
3871 return simplify_with_current_value_aux (XEXP (exp
, 0));
3872 else if (cond
== false_rtx
)
3875 return attr_rtx (AND
, cond
,
3876 simplify_with_current_value_aux (XEXP (exp
, 0)));
3879 cond
= simplify_with_current_value_aux (XEXP (exp
, 0));
3880 if (cond
== true_rtx
)
3882 else if (cond
== false_rtx
)
3885 return attr_rtx (NOT
, cond
);
3888 for (i
= 0; i
< XVECLEN (exp
, 0); i
+= 2)
3890 cond
= simplify_with_current_value_aux (XVECEXP (exp
, 0, i
));
3891 if (cond
== true_rtx
)
3892 return simplify_with_current_value_aux (XVECEXP (exp
, 0, i
+ 1));
3893 else if (cond
== false_rtx
)
3896 abort (); /* With all EQ_ATTR's of known value, a case should
3897 have been selected. */
3899 return simplify_with_current_value_aux (XEXP (exp
, 1));
3906 /* Clear the ATTR_CURR_SIMPLIFIED_P flag in EXP and its subexpressions. */
3909 clear_struct_flag (rtx x
)
3916 ATTR_CURR_SIMPLIFIED_P (x
) = 0;
3917 if (ATTR_IND_SIMPLIFIED_P (x
))
3920 code
= GET_CODE (x
);
3941 /* Compare the elements. If any pair of corresponding elements
3942 fail to match, return 0 for the whole things. */
3944 fmt
= GET_RTX_FORMAT (code
);
3945 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
3951 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
3952 clear_struct_flag (XVECEXP (x
, i
, j
));
3956 clear_struct_flag (XEXP (x
, i
));
3962 /* Return the number of RTX objects making up the expression X.
3963 But if we count more than MAX objects, stop counting. */
3966 count_sub_rtxs (rtx x
, int max
)
3974 code
= GET_CODE (x
);
3995 /* Compare the elements. If any pair of corresponding elements
3996 fail to match, return 0 for the whole things. */
3998 fmt
= GET_RTX_FORMAT (code
);
3999 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
4008 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
4009 total
+= count_sub_rtxs (XVECEXP (x
, i
, j
), max
);
4013 total
+= count_sub_rtxs (XEXP (x
, i
), max
);
4021 /* Create table entries for DEFINE_ATTR. */
4024 gen_attr (rtx exp
, int lineno
)
4026 struct attr_desc
*attr
;
4027 struct attr_value
*av
;
4028 const char *name_ptr
;
4031 /* Make a new attribute structure. Check for duplicate by looking at
4032 attr->default_val, since it is initialized by this routine. */
4033 attr
= find_attr (XSTR (exp
, 0), 1);
4034 if (attr
->default_val
)
4036 message_with_line (lineno
, "duplicate definition for attribute %s",
4038 message_with_line (attr
->lineno
, "previous definition");
4042 attr
->lineno
= lineno
;
4044 if (*XSTR (exp
, 1) == '\0')
4045 attr
->is_numeric
= 1;
4048 name_ptr
= XSTR (exp
, 1);
4049 while ((p
= next_comma_elt (&name_ptr
)) != NULL
)
4051 av
= (struct attr_value
*) oballoc (sizeof (struct attr_value
));
4052 av
->value
= attr_rtx (CONST_STRING
, p
);
4053 av
->next
= attr
->first_value
;
4054 attr
->first_value
= av
;
4055 av
->first_insn
= NULL
;
4057 av
->has_asm_insn
= 0;
4061 if (GET_CODE (XEXP (exp
, 2)) == CONST
)
4064 if (attr
->is_numeric
)
4066 message_with_line (lineno
,
4067 "constant attributes may not take numeric values");
4071 /* Get rid of the CONST node. It is allowed only at top-level. */
4072 XEXP (exp
, 2) = XEXP (XEXP (exp
, 2), 0);
4075 if (! strcmp (attr
->name
, "length") && ! attr
->is_numeric
)
4077 message_with_line (lineno
,
4078 "`length' attribute must take numeric values");
4082 /* Set up the default value. */
4083 XEXP (exp
, 2) = check_attr_value (XEXP (exp
, 2), attr
);
4084 attr
->default_val
= get_attr_value (XEXP (exp
, 2), attr
, -2);
4087 /* Given a pattern for DEFINE_PEEPHOLE or DEFINE_INSN, return the number of
4088 alternatives in the constraints. Assume all MATCH_OPERANDs have the same
4089 number of alternatives as this should be checked elsewhere. */
4092 count_alternatives (rtx exp
)
4097 if (GET_CODE (exp
) == MATCH_OPERAND
)
4098 return n_comma_elts (XSTR (exp
, 2));
4100 for (i
= 0, fmt
= GET_RTX_FORMAT (GET_CODE (exp
));
4101 i
< GET_RTX_LENGTH (GET_CODE (exp
)); i
++)
4106 n
= count_alternatives (XEXP (exp
, i
));
4113 if (XVEC (exp
, i
) != NULL
)
4114 for (j
= 0; j
< XVECLEN (exp
, i
); j
++)
4116 n
= count_alternatives (XVECEXP (exp
, i
, j
));
4125 /* Returns nonzero if the given expression contains an EQ_ATTR with the
4126 `alternative' attribute. */
4129 compares_alternatives_p (rtx exp
)
4134 if (GET_CODE (exp
) == EQ_ATTR
&& XSTR (exp
, 0) == alternative_name
)
4137 for (i
= 0, fmt
= GET_RTX_FORMAT (GET_CODE (exp
));
4138 i
< GET_RTX_LENGTH (GET_CODE (exp
)); i
++)
4143 if (compares_alternatives_p (XEXP (exp
, i
)))
4148 for (j
= 0; j
< XVECLEN (exp
, i
); j
++)
4149 if (compares_alternatives_p (XVECEXP (exp
, i
, j
)))
4157 /* Returns nonzero is INNER is contained in EXP. */
4160 contained_in_p (rtx inner
, rtx exp
)
4165 if (rtx_equal_p (inner
, exp
))
4168 for (i
= 0, fmt
= GET_RTX_FORMAT (GET_CODE (exp
));
4169 i
< GET_RTX_LENGTH (GET_CODE (exp
)); i
++)
4174 if (contained_in_p (inner
, XEXP (exp
, i
)))
4179 for (j
= 0; j
< XVECLEN (exp
, i
); j
++)
4180 if (contained_in_p (inner
, XVECEXP (exp
, i
, j
)))
4188 /* Process DEFINE_PEEPHOLE, DEFINE_INSN, and DEFINE_ASM_ATTRIBUTES. */
4191 gen_insn (rtx exp
, int lineno
)
4193 struct insn_def
*id
;
4195 id
= (struct insn_def
*) oballoc (sizeof (struct insn_def
));
4199 id
->lineno
= lineno
;
4201 switch (GET_CODE (exp
))
4204 id
->insn_code
= insn_code_number
;
4205 id
->insn_index
= insn_index_number
;
4206 id
->num_alternatives
= count_alternatives (exp
);
4207 if (id
->num_alternatives
== 0)
4208 id
->num_alternatives
= 1;
4212 case DEFINE_PEEPHOLE
:
4213 id
->insn_code
= insn_code_number
;
4214 id
->insn_index
= insn_index_number
;
4215 id
->num_alternatives
= count_alternatives (exp
);
4216 if (id
->num_alternatives
== 0)
4217 id
->num_alternatives
= 1;
4221 case DEFINE_ASM_ATTRIBUTES
:
4223 id
->insn_index
= -1;
4224 id
->num_alternatives
= 1;
4226 got_define_asm_attributes
= 1;
4234 /* Process a DEFINE_DELAY. Validate the vector length, check if annul
4235 true or annul false is specified, and make a `struct delay_desc'. */
4238 gen_delay (rtx def
, int lineno
)
4240 struct delay_desc
*delay
;
4243 if (XVECLEN (def
, 1) % 3 != 0)
4245 message_with_line (lineno
,
4246 "number of elements in DEFINE_DELAY must be multiple of three");
4251 for (i
= 0; i
< XVECLEN (def
, 1); i
+= 3)
4253 if (XVECEXP (def
, 1, i
+ 1))
4254 have_annul_true
= 1;
4255 if (XVECEXP (def
, 1, i
+ 2))
4256 have_annul_false
= 1;
4259 delay
= (struct delay_desc
*) oballoc (sizeof (struct delay_desc
));
4261 delay
->num
= ++num_delays
;
4262 delay
->next
= delays
;
4263 delay
->lineno
= lineno
;
4267 /* Process a DEFINE_FUNCTION_UNIT.
4269 This gives information about a function unit contained in the CPU.
4270 We fill in a `struct function_unit_op' and a `struct function_unit'
4271 with information used later by `expand_unit'. */
4274 gen_unit (rtx def
, int lineno
)
4276 struct function_unit
*unit
;
4277 struct function_unit_op
*op
;
4278 const char *name
= XSTR (def
, 0);
4279 int multiplicity
= XINT (def
, 1);
4280 int simultaneity
= XINT (def
, 2);
4281 rtx condexp
= XEXP (def
, 3);
4282 int ready_cost
= MAX (XINT (def
, 4), 1);
4283 int issue_delay
= MAX (XINT (def
, 5), 1);
4285 /* See if we have already seen this function unit. If so, check that
4286 the multiplicity and simultaneity values are the same. If not, make
4287 a structure for this function unit. */
4288 for (unit
= units
; unit
; unit
= unit
->next
)
4289 if (! strcmp (unit
->name
, name
))
4291 if (unit
->multiplicity
!= multiplicity
4292 || unit
->simultaneity
!= simultaneity
)
4294 message_with_line (lineno
,
4295 "differing specifications given for function unit %s",
4297 message_with_line (unit
->first_lineno
, "previous definition");
4306 unit
= (struct function_unit
*) oballoc (sizeof (struct function_unit
));
4308 unit
->multiplicity
= multiplicity
;
4309 unit
->simultaneity
= simultaneity
;
4310 unit
->issue_delay
.min
= unit
->issue_delay
.max
= issue_delay
;
4311 unit
->num
= num_units
++;
4312 unit
->num_opclasses
= 0;
4313 unit
->condexp
= false_rtx
;
4316 unit
->first_lineno
= lineno
;
4320 /* Make a new operation class structure entry and initialize it. */
4321 op
= (struct function_unit_op
*) oballoc (sizeof (struct function_unit_op
));
4322 op
->condexp
= condexp
;
4323 op
->num
= unit
->num_opclasses
++;
4324 op
->ready
= ready_cost
;
4325 op
->issue_delay
= issue_delay
;
4326 op
->next
= unit
->ops
;
4327 op
->lineno
= lineno
;
4329 num_unit_opclasses
++;
4331 /* Set our issue expression based on whether or not an optional conflict
4332 vector was specified. */
4335 /* Compute the IOR of all the specified expressions. */
4336 rtx orexp
= false_rtx
;
4339 for (i
= 0; i
< XVECLEN (def
, 6); i
++)
4340 orexp
= insert_right_side (IOR
, orexp
, XVECEXP (def
, 6, i
), -2, -2);
4342 op
->conflict_exp
= orexp
;
4343 extend_range (&unit
->issue_delay
, 1, issue_delay
);
4347 op
->conflict_exp
= true_rtx
;
4348 extend_range (&unit
->issue_delay
, issue_delay
, issue_delay
);
4351 /* Merge our conditional into that of the function unit so we can determine
4352 which insns are used by the function unit. */
4353 unit
->condexp
= insert_right_side (IOR
, unit
->condexp
, op
->condexp
, -2, -2);
4356 /* Given a piece of RTX, print a C expression to test its truth value.
4357 We use AND and IOR both for logical and bit-wise operations, so
4358 interpret them as logical unless they are inside a comparison expression.
4359 The first bit of FLAGS will be nonzero in that case.
4361 Set the second bit of FLAGS to make references to attribute values use
4362 a cached local variable instead of calling a function. */
4365 write_test_expr (rtx exp
, int flags
)
4367 int comparison_operator
= 0;
4369 struct attr_desc
*attr
;
4371 /* In order not to worry about operator precedence, surround our part of
4372 the expression with parentheses. */
4375 code
= GET_CODE (exp
);
4378 /* Binary operators. */
4380 case GE
: case GT
: case GEU
: case GTU
:
4381 case LE
: case LT
: case LEU
: case LTU
:
4382 comparison_operator
= 1;
4384 case PLUS
: case MINUS
: case MULT
: case DIV
: case MOD
:
4385 case AND
: case IOR
: case XOR
:
4386 case ASHIFT
: case LSHIFTRT
: case ASHIFTRT
:
4387 write_test_expr (XEXP (exp
, 0), flags
| comparison_operator
);
4403 printf (" >= (unsigned) ");
4406 printf (" > (unsigned) ");
4415 printf (" <= (unsigned) ");
4418 printf (" < (unsigned) ");
4461 write_test_expr (XEXP (exp
, 1), flags
| comparison_operator
);
4465 /* Special-case (not (eq_attrq "alternative" "x")) */
4466 if (! (flags
& 1) && GET_CODE (XEXP (exp
, 0)) == EQ_ATTR
4467 && XSTR (XEXP (exp
, 0), 0) == alternative_name
)
4469 printf ("which_alternative != %s", XSTR (XEXP (exp
, 0), 1));
4473 /* Otherwise, fall through to normal unary operator. */
4475 /* Unary operators. */
4495 write_test_expr (XEXP (exp
, 0), flags
);
4498 /* Comparison test of an attribute with a value. Most of these will
4499 have been removed by optimization. Handle "alternative"
4500 specially and give error if EQ_ATTR present inside a comparison. */
4503 fatal ("EQ_ATTR not valid inside comparison");
4505 if (XSTR (exp
, 0) == alternative_name
)
4507 printf ("which_alternative == %s", XSTR (exp
, 1));
4511 attr
= find_attr (XSTR (exp
, 0), 0);
4515 /* Now is the time to expand the value of a constant attribute. */
4518 write_test_expr (evaluate_eq_attr (exp
, attr
->default_val
->value
,
4525 printf ("attr_%s", attr
->name
);
4527 printf ("get_attr_%s (insn)", attr
->name
);
4529 write_attr_valueq (attr
, XSTR (exp
, 1));
4533 /* Comparison test of flags for define_delays. */
4536 fatal ("ATTR_FLAG not valid inside comparison");
4537 printf ("(flags & ATTR_FLAG_%s) != 0", XSTR (exp
, 0));
4540 /* See if an operand matches a predicate. */
4542 /* If only a mode is given, just ensure the mode matches the operand.
4543 If neither a mode nor predicate is given, error. */
4544 if (XSTR (exp
, 1) == NULL
|| *XSTR (exp
, 1) == '\0')
4546 if (GET_MODE (exp
) == VOIDmode
)
4547 fatal ("null MATCH_OPERAND specified as test");
4549 printf ("GET_MODE (operands[%d]) == %smode",
4550 XINT (exp
, 0), GET_MODE_NAME (GET_MODE (exp
)));
4553 printf ("%s (operands[%d], %smode)",
4554 XSTR (exp
, 1), XINT (exp
, 0), GET_MODE_NAME (GET_MODE (exp
)));
4558 printf ("%s (insn)", XSTR (exp
, 0));
4561 /* Constant integer. */
4563 printf (HOST_WIDE_INT_PRINT_DEC
, XWINT (exp
, 0));
4566 /* A random C expression. */
4568 printf ("%s", XSTR (exp
, 0));
4571 /* The address of the branch target. */
4573 printf ("INSN_ADDRESSES_SET_P () ? INSN_ADDRESSES (INSN_UID (GET_CODE (operands[%d]) == LABEL_REF ? XEXP (operands[%d], 0) : operands[%d])) : 0",
4574 XINT (exp
, 0), XINT (exp
, 0), XINT (exp
, 0));
4578 /* The address of the current insn. We implement this actually as the
4579 address of the current insn for backward branches, but the last
4580 address of the next insn for forward branches, and both with
4581 adjustments that account for the worst-case possible stretching of
4582 intervening alignments between this insn and its destination. */
4583 printf ("insn_current_reference_address (insn)");
4587 printf ("%s", XSTR (exp
, 0));
4591 write_test_expr (XEXP (exp
, 0), flags
& 2);
4593 write_test_expr (XEXP (exp
, 1), flags
| 1);
4595 write_test_expr (XEXP (exp
, 2), flags
| 1);
4599 fatal ("bad RTX code `%s' in attribute calculation\n",
4600 GET_RTX_NAME (code
));
4606 /* Given an attribute value, return the maximum CONST_STRING argument
4607 encountered. Set *UNKNOWNP and return INT_MAX if the value is unknown. */
4610 max_attr_value (rtx exp
, int *unknownp
)
4615 switch (GET_CODE (exp
))
4618 current_max
= atoi (XSTR (exp
, 0));
4622 current_max
= max_attr_value (XEXP (exp
, 1), unknownp
);
4623 for (i
= 0; i
< XVECLEN (exp
, 0); i
+= 2)
4625 n
= max_attr_value (XVECEXP (exp
, 0, i
+ 1), unknownp
);
4626 if (n
> current_max
)
4632 current_max
= max_attr_value (XEXP (exp
, 1), unknownp
);
4633 n
= max_attr_value (XEXP (exp
, 2), unknownp
);
4634 if (n
> current_max
)
4640 current_max
= INT_MAX
;
4647 /* Given an attribute value, return the result of ORing together all
4648 CONST_STRING arguments encountered. Set *UNKNOWNP and return -1
4649 if the numeric value is not known. */
4652 or_attr_value (rtx exp
, int *unknownp
)
4657 switch (GET_CODE (exp
))
4660 current_or
= atoi (XSTR (exp
, 0));
4664 current_or
= or_attr_value (XEXP (exp
, 1), unknownp
);
4665 for (i
= 0; i
< XVECLEN (exp
, 0); i
+= 2)
4666 current_or
|= or_attr_value (XVECEXP (exp
, 0, i
+ 1), unknownp
);
4670 current_or
= or_attr_value (XEXP (exp
, 1), unknownp
);
4671 current_or
|= or_attr_value (XEXP (exp
, 2), unknownp
);
4683 /* Scan an attribute value, possibly a conditional, and record what actions
4684 will be required to do any conditional tests in it.
4687 `must_extract' if we need to extract the insn operands
4688 `must_constrain' if we must compute `which_alternative'
4689 `address_used' if an address expression was used
4690 `length_used' if an (eq_attr "length" ...) was used
4694 walk_attr_value (rtx exp
)
4703 code
= GET_CODE (exp
);
4707 if (! ATTR_IND_SIMPLIFIED_P (exp
))
4708 /* Since this is an arbitrary expression, it can look at anything.
4709 However, constant expressions do not depend on any particular
4711 must_extract
= must_constrain
= 1;
4719 if (XSTR (exp
, 0) == alternative_name
)
4720 must_extract
= must_constrain
= 1;
4721 else if (strcmp (XSTR (exp
, 0), "length") == 0)
4741 for (i
= 0, fmt
= GET_RTX_FORMAT (code
); i
< GET_RTX_LENGTH (code
); i
++)
4746 walk_attr_value (XEXP (exp
, i
));
4750 if (XVEC (exp
, i
) != NULL
)
4751 for (j
= 0; j
< XVECLEN (exp
, i
); j
++)
4752 walk_attr_value (XVECEXP (exp
, i
, j
));
4757 /* Write out a function to obtain the attribute for a given INSN. */
4760 write_attr_get (struct attr_desc
*attr
)
4762 struct attr_value
*av
, *common_av
;
4764 /* Find the most used attribute value. Handle that as the `default' of the
4765 switch we will generate. */
4766 common_av
= find_most_used (attr
);
4768 /* Write out start of function, then all values with explicit `case' lines,
4769 then a `default', then the value with the most uses. */
4770 if (!attr
->is_numeric
)
4771 printf ("enum attr_%s\n", attr
->name
);
4772 else if (attr
->unsigned_p
)
4773 printf ("unsigned int\n");
4777 /* If the attribute name starts with a star, the remainder is the name of
4778 the subroutine to use, instead of `get_attr_...'. */
4779 if (attr
->name
[0] == '*')
4780 printf ("%s (rtx insn ATTRIBUTE_UNUSED)\n", &attr
->name
[1]);
4781 else if (attr
->is_const
== 0)
4782 printf ("get_attr_%s (rtx insn ATTRIBUTE_UNUSED)\n", attr
->name
);
4785 printf ("get_attr_%s (void)\n", attr
->name
);
4788 for (av
= attr
->first_value
; av
; av
= av
->next
)
4789 if (av
->num_insns
!= 0)
4790 write_attr_set (attr
, 2, av
->value
, "return", ";",
4791 true_rtx
, av
->first_insn
->insn_code
,
4792 av
->first_insn
->insn_index
);
4800 if (GET_CODE (common_av
->value
) == FFS
)
4802 rtx p
= XEXP (common_av
->value
, 0);
4804 /* No need to emit code to abort if the insn is unrecognized; the
4805 other get_attr_foo functions will do that when we call them. */
4807 write_toplevel_expr (p
);
4809 printf ("\n if (accum && accum == (accum & -accum))\n");
4811 printf (" int i;\n");
4812 printf (" for (i = 0; accum >>= 1; ++i) continue;\n");
4813 printf (" accum = i;\n");
4814 printf (" }\n else\n");
4815 printf (" accum = ~accum;\n");
4816 printf (" return accum;\n}\n\n");
4820 printf (" switch (recog_memoized (insn))\n");
4823 for (av
= attr
->first_value
; av
; av
= av
->next
)
4824 if (av
!= common_av
)
4825 write_attr_case (attr
, av
, 1, "return", ";", 4, true_rtx
);
4827 write_attr_case (attr
, common_av
, 0, "return", ";", 4, true_rtx
);
4828 printf (" }\n}\n\n");
4832 /* Given an AND tree of known true terms (because we are inside an `if' with
4833 that as the condition or are in an `else' clause) and an expression,
4834 replace any known true terms with TRUE. Use `simplify_and_tree' to do
4835 the bulk of the work. */
4838 eliminate_known_true (rtx known_true
, rtx exp
, int insn_code
, int insn_index
)
4842 known_true
= SIMPLIFY_TEST_EXP (known_true
, insn_code
, insn_index
);
4844 if (GET_CODE (known_true
) == AND
)
4846 exp
= eliminate_known_true (XEXP (known_true
, 0), exp
,
4847 insn_code
, insn_index
);
4848 exp
= eliminate_known_true (XEXP (known_true
, 1), exp
,
4849 insn_code
, insn_index
);
4854 exp
= simplify_and_tree (exp
, &term
, insn_code
, insn_index
);
4860 /* Write out a series of tests and assignment statements to perform tests and
4861 sets of an attribute value. We are passed an indentation amount and prefix
4862 and suffix strings to write around each attribute value (e.g., "return"
4866 write_attr_set (struct attr_desc
*attr
, int indent
, rtx value
,
4867 const char *prefix
, const char *suffix
, rtx known_true
,
4868 int insn_code
, int insn_index
)
4870 if (GET_CODE (value
) == COND
)
4872 /* Assume the default value will be the default of the COND unless we
4873 find an always true expression. */
4874 rtx default_val
= XEXP (value
, 1);
4875 rtx our_known_true
= known_true
;
4880 for (i
= 0; i
< XVECLEN (value
, 0); i
+= 2)
4885 testexp
= eliminate_known_true (our_known_true
,
4886 XVECEXP (value
, 0, i
),
4887 insn_code
, insn_index
);
4888 newexp
= attr_rtx (NOT
, testexp
);
4889 newexp
= insert_right_side (AND
, our_known_true
, newexp
,
4890 insn_code
, insn_index
);
4892 /* If the test expression is always true or if the next `known_true'
4893 expression is always false, this is the last case, so break
4894 out and let this value be the `else' case. */
4895 if (testexp
== true_rtx
|| newexp
== false_rtx
)
4897 default_val
= XVECEXP (value
, 0, i
+ 1);
4901 /* Compute the expression to pass to our recursive call as being
4903 inner_true
= insert_right_side (AND
, our_known_true
,
4904 testexp
, insn_code
, insn_index
);
4906 /* If this is always false, skip it. */
4907 if (inner_true
== false_rtx
)
4910 write_indent (indent
);
4911 printf ("%sif ", first_if
? "" : "else ");
4913 write_test_expr (testexp
, 0);
4915 write_indent (indent
+ 2);
4918 write_attr_set (attr
, indent
+ 4,
4919 XVECEXP (value
, 0, i
+ 1), prefix
, suffix
,
4920 inner_true
, insn_code
, insn_index
);
4921 write_indent (indent
+ 2);
4923 our_known_true
= newexp
;
4928 write_indent (indent
);
4930 write_indent (indent
+ 2);
4934 write_attr_set (attr
, first_if
? indent
: indent
+ 4, default_val
,
4935 prefix
, suffix
, our_known_true
, insn_code
, insn_index
);
4939 write_indent (indent
+ 2);
4945 write_indent (indent
);
4946 printf ("%s ", prefix
);
4947 write_attr_value (attr
, value
);
4948 printf ("%s\n", suffix
);
4952 /* Write out the computation for one attribute value. */
4955 write_attr_case (struct attr_desc
*attr
, struct attr_value
*av
,
4956 int write_case_lines
, const char *prefix
, const char *suffix
,
4957 int indent
, rtx known_true
)
4959 struct insn_ent
*ie
;
4961 if (av
->num_insns
== 0)
4964 if (av
->has_asm_insn
)
4966 write_indent (indent
);
4967 printf ("case -1:\n");
4968 write_indent (indent
+ 2);
4969 printf ("if (GET_CODE (PATTERN (insn)) != ASM_INPUT\n");
4970 write_indent (indent
+ 2);
4971 printf (" && asm_noperands (PATTERN (insn)) < 0)\n");
4972 write_indent (indent
+ 2);
4973 printf (" fatal_insn_not_found (insn);\n");
4976 if (write_case_lines
)
4978 for (ie
= av
->first_insn
; ie
; ie
= ie
->next
)
4979 if (ie
->insn_code
!= -1)
4981 write_indent (indent
);
4982 printf ("case %d:\n", ie
->insn_code
);
4987 write_indent (indent
);
4988 printf ("default:\n");
4991 /* See what we have to do to output this value. */
4992 must_extract
= must_constrain
= address_used
= 0;
4993 walk_attr_value (av
->value
);
4997 write_indent (indent
+ 2);
4998 printf ("extract_constrain_insn_cached (insn);\n");
5000 else if (must_extract
)
5002 write_indent (indent
+ 2);
5003 printf ("extract_insn_cached (insn);\n");
5006 write_attr_set (attr
, indent
+ 2, av
->value
, prefix
, suffix
,
5007 known_true
, av
->first_insn
->insn_code
,
5008 av
->first_insn
->insn_index
);
5010 if (strncmp (prefix
, "return", 6))
5012 write_indent (indent
+ 2);
5013 printf ("break;\n");
5018 /* Search for uses of non-const attributes and write code to cache them. */
5021 write_expr_attr_cache (rtx p
, struct attr_desc
*attr
)
5026 if (GET_CODE (p
) == EQ_ATTR
)
5028 if (XSTR (p
, 0) != attr
->name
)
5031 if (!attr
->is_numeric
)
5032 printf (" enum attr_%s ", attr
->name
);
5033 else if (attr
->unsigned_p
)
5034 printf (" unsigned int ");
5038 printf ("attr_%s = get_attr_%s (insn);\n", attr
->name
, attr
->name
);
5042 fmt
= GET_RTX_FORMAT (GET_CODE (p
));
5043 ie
= GET_RTX_LENGTH (GET_CODE (p
));
5044 for (i
= 0; i
< ie
; i
++)
5049 if (write_expr_attr_cache (XEXP (p
, i
), attr
))
5054 je
= XVECLEN (p
, i
);
5055 for (j
= 0; j
< je
; ++j
)
5056 if (write_expr_attr_cache (XVECEXP (p
, i
, j
), attr
))
5065 /* Evaluate an expression at top level. A front end to write_test_expr,
5066 in which we cache attribute values and break up excessively large
5067 expressions to cater to older compilers. */
5070 write_toplevel_expr (rtx p
)
5072 struct attr_desc
*attr
;
5075 for (i
= 0; i
< MAX_ATTRS_INDEX
; ++i
)
5076 for (attr
= attrs
[i
]; attr
; attr
= attr
->next
)
5077 if (!attr
->is_const
)
5078 write_expr_attr_cache (p
, attr
);
5080 printf (" unsigned long accum = 0;\n\n");
5082 while (GET_CODE (p
) == IOR
)
5085 if (GET_CODE (XEXP (p
, 0)) == IOR
)
5086 e
= XEXP (p
, 1), p
= XEXP (p
, 0);
5088 e
= XEXP (p
, 0), p
= XEXP (p
, 1);
5090 printf (" accum |= ");
5091 write_test_expr (e
, 3);
5094 printf (" accum |= ");
5095 write_test_expr (p
, 3);
5099 /* Utilities to write names in various forms. */
5102 write_unit_name (const char *prefix
, int num
, const char *suffix
)
5104 struct function_unit
*unit
;
5106 for (unit
= units
; unit
; unit
= unit
->next
)
5107 if (unit
->num
== num
)
5109 printf ("%s%s%s", prefix
, unit
->name
, suffix
);
5113 printf ("%s<unknown>%s", prefix
, suffix
);
5117 write_attr_valueq (struct attr_desc
*attr
, const char *s
)
5119 if (attr
->is_numeric
)
5125 /* Make the blockage range values and function units used values easier
5127 if (attr
->func_units_p
)
5130 printf (" /* units: none */");
5132 write_unit_name (" /* units: ", num
, " */");
5136 const char *sep
= " /* units: ";
5137 for (i
= 0, num
= ~num
; num
; i
++, num
>>= 1)
5140 write_unit_name (sep
, i
, (num
== 1) ? " */" : "");
5146 else if (attr
->blockage_p
)
5147 printf (" /* min %d, max %d */", num
>> (HOST_BITS_PER_INT
/ 2),
5148 num
& ((1 << (HOST_BITS_PER_INT
/ 2)) - 1));
5150 else if (num
> 9 || num
< 0)
5151 printf (" /* 0x%x */", num
);
5155 write_upcase (attr
->name
);
5162 write_attr_value (struct attr_desc
*attr
, rtx value
)
5166 switch (GET_CODE (value
))
5169 write_attr_valueq (attr
, XSTR (value
, 0));
5173 printf (HOST_WIDE_INT_PRINT_DEC
, INTVAL (value
));
5177 fputs (XSTR (value
, 0), stdout
);
5182 struct attr_desc
*attr2
= find_attr (XSTR (value
, 0), 0);
5183 printf ("get_attr_%s (%s)", attr2
->name
,
5184 (attr2
->is_const
? "" : "insn"));
5205 write_attr_value (attr
, XEXP (value
, 0));
5209 write_attr_value (attr
, XEXP (value
, 1));
5218 write_upcase (const char *str
)
5222 /* The argument of TOUPPER should not have side effects. */
5223 putchar (TOUPPER(*str
));
5229 write_indent (int indent
)
5231 for (; indent
> 8; indent
-= 8)
5234 for (; indent
; indent
--)
5238 /* Write a subroutine that is given an insn that requires a delay slot, a
5239 delay slot ordinal, and a candidate insn. It returns nonzero if the
5240 candidate can be placed in the specified delay slot of the insn.
5242 We can write as many as three subroutines. `eligible_for_delay'
5243 handles normal delay slots, `eligible_for_annul_true' indicates that
5244 the specified insn can be annulled if the branch is true, and likewise
5245 for `eligible_for_annul_false'.
5247 KIND is a string distinguishing these three cases ("delay", "annul_true",
5248 or "annul_false"). */
5251 write_eligible_delay (const char *kind
)
5253 struct delay_desc
*delay
;
5256 struct attr_desc
*attr
;
5257 struct attr_value
*av
, *common_av
;
5260 /* Compute the maximum number of delay slots required. We use the delay
5261 ordinal times this number plus one, plus the slot number as an index into
5262 the appropriate predicate to test. */
5264 for (delay
= delays
, max_slots
= 0; delay
; delay
= delay
->next
)
5265 if (XVECLEN (delay
->def
, 1) / 3 > max_slots
)
5266 max_slots
= XVECLEN (delay
->def
, 1) / 3;
5268 /* Write function prelude. */
5271 printf ("eligible_for_%s (rtx delay_insn ATTRIBUTE_UNUSED, int slot, rtx candidate_insn, int flags ATTRIBUTE_UNUSED)\n",
5274 printf (" rtx insn;\n");
5276 printf (" if (slot >= %d)\n", max_slots
);
5277 printf (" abort ();\n");
5280 /* If more than one delay type, find out which type the delay insn is. */
5284 attr
= find_attr ("*delay_type", 0);
5287 common_av
= find_most_used (attr
);
5289 printf (" insn = delay_insn;\n");
5290 printf (" switch (recog_memoized (insn))\n");
5293 sprintf (str
, " * %d;\n break;", max_slots
);
5294 for (av
= attr
->first_value
; av
; av
= av
->next
)
5295 if (av
!= common_av
)
5296 write_attr_case (attr
, av
, 1, "slot +=", str
, 4, true_rtx
);
5298 write_attr_case (attr
, common_av
, 0, "slot +=", str
, 4, true_rtx
);
5301 /* Ensure matched. Otherwise, shouldn't have been called. */
5302 printf (" if (slot < %d)\n", max_slots
);
5303 printf (" abort ();\n\n");
5306 /* If just one type of delay slot, write simple switch. */
5307 if (num_delays
== 1 && max_slots
== 1)
5309 printf (" insn = candidate_insn;\n");
5310 printf (" switch (recog_memoized (insn))\n");
5313 attr
= find_attr ("*delay_1_0", 0);
5316 common_av
= find_most_used (attr
);
5318 for (av
= attr
->first_value
; av
; av
= av
->next
)
5319 if (av
!= common_av
)
5320 write_attr_case (attr
, av
, 1, "return", ";", 4, true_rtx
);
5322 write_attr_case (attr
, common_av
, 0, "return", ";", 4, true_rtx
);
5328 /* Write a nested CASE. The first indicates which condition we need to
5329 test, and the inner CASE tests the condition. */
5330 printf (" insn = candidate_insn;\n");
5331 printf (" switch (slot)\n");
5334 for (delay
= delays
; delay
; delay
= delay
->next
)
5335 for (i
= 0; i
< XVECLEN (delay
->def
, 1); i
+= 3)
5337 printf (" case %d:\n",
5338 (i
/ 3) + (num_delays
== 1 ? 0 : delay
->num
* max_slots
));
5339 printf (" switch (recog_memoized (insn))\n");
5342 sprintf (str
, "*%s_%d_%d", kind
, delay
->num
, i
/ 3);
5343 attr
= find_attr (str
, 0);
5346 common_av
= find_most_used (attr
);
5348 for (av
= attr
->first_value
; av
; av
= av
->next
)
5349 if (av
!= common_av
)
5350 write_attr_case (attr
, av
, 1, "return", ";", 8, true_rtx
);
5352 write_attr_case (attr
, common_av
, 0, "return", ";", 8, true_rtx
);
5356 printf (" default:\n");
5357 printf (" abort ();\n");
5364 /* Write routines to compute conflict cost for function units. Then write a
5365 table describing the available function units. */
5368 write_function_unit_info (void)
5370 struct function_unit
*unit
;
5373 /* Write out conflict routines for function units. Don't bother writing
5374 one if there is only one issue delay value. */
5376 for (unit
= units
; unit
; unit
= unit
->next
)
5378 if (unit
->needs_blockage_function
)
5379 write_complex_function (unit
, "blockage", "block");
5381 /* If the minimum and maximum conflict costs are the same, there
5382 is only one value, so we don't need a function. */
5383 if (! unit
->needs_conflict_function
)
5385 unit
->default_cost
= make_numeric_value (unit
->issue_delay
.max
);
5389 /* The function first computes the case from the candidate insn. */
5390 unit
->default_cost
= make_numeric_value (0);
5391 write_complex_function (unit
, "conflict_cost", "cost");
5394 /* Now that all functions have been written, write the table describing
5395 the function units. The name is included for documentation purposes
5398 printf ("const struct function_unit_desc function_units[] = {\n");
5400 /* Write out the descriptions in numeric order, but don't force that order
5401 on the list. Doing so increases the runtime of genattrtab.c. */
5402 for (i
= 0; i
< num_units
; i
++)
5404 for (unit
= units
; unit
; unit
= unit
->next
)
5408 printf (" {\"%s\", %d, %d, %d, %s, %d, %s_unit_ready_cost, ",
5409 unit
->name
, 1 << unit
->num
, unit
->multiplicity
,
5410 unit
->simultaneity
, XSTR (unit
->default_cost
, 0),
5411 unit
->issue_delay
.max
, unit
->name
);
5413 if (unit
->needs_conflict_function
)
5414 printf ("%s_unit_conflict_cost, ", unit
->name
);
5418 printf ("%d, ", unit
->max_blockage
);
5420 if (unit
->needs_range_function
)
5421 printf ("%s_unit_blockage_range, ", unit
->name
);
5425 if (unit
->needs_blockage_function
)
5426 printf ("%s_unit_blockage", unit
->name
);
5434 printf ("{\"dummy\", 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} /* a dummy element */");
5439 write_complex_function (struct function_unit
*unit
,
5441 const char *connection
)
5443 struct attr_desc
*case_attr
, *attr
;
5444 struct attr_value
*av
, *common_av
;
5450 printf ("static int\n");
5451 printf ("%s_unit_%s (rtx executing_insn, rtx candidate_insn)\n",
5454 printf (" rtx insn;\n");
5455 printf (" int casenum;\n\n");
5456 printf (" insn = executing_insn;\n");
5457 printf (" switch (recog_memoized (insn))\n");
5460 /* Write the `switch' statement to get the case value. */
5461 if (strlen (unit
->name
) + sizeof "*_cases" > 256)
5463 sprintf (str
, "*%s_cases", unit
->name
);
5464 case_attr
= find_attr (str
, 0);
5467 common_av
= find_most_used (case_attr
);
5469 for (av
= case_attr
->first_value
; av
; av
= av
->next
)
5470 if (av
!= common_av
)
5471 write_attr_case (case_attr
, av
, 1,
5472 "casenum =", ";", 4, unit
->condexp
);
5474 write_attr_case (case_attr
, common_av
, 0,
5475 "casenum =", ";", 4, unit
->condexp
);
5478 /* Now write an outer switch statement on each case. Then write
5479 the tests on the executing function within each. */
5480 printf (" insn = candidate_insn;\n");
5481 printf (" switch (casenum)\n");
5484 for (i
= 0; i
< unit
->num_opclasses
; i
++)
5486 /* Ensure using this case. */
5488 for (av
= case_attr
->first_value
; av
; av
= av
->next
)
5490 && contained_in_p (make_numeric_value (i
), av
->value
))
5496 printf (" case %d:\n", i
);
5497 sprintf (str
, "*%s_%s_%d", unit
->name
, connection
, i
);
5498 attr
= find_attr (str
, 0);
5502 /* If single value, just write it. */
5503 value
= find_single_value (attr
);
5505 write_attr_set (attr
, 6, value
, "return", ";\n", true_rtx
, -2, -2);
5508 common_av
= find_most_used (attr
);
5509 printf (" switch (recog_memoized (insn))\n");
5512 for (av
= attr
->first_value
; av
; av
= av
->next
)
5513 if (av
!= common_av
)
5514 write_attr_case (attr
, av
, 1,
5515 "return", ";", 8, unit
->condexp
);
5517 write_attr_case (attr
, common_av
, 0,
5518 "return", ";", 8, unit
->condexp
);
5523 /* This default case should not be needed, but gcc's analysis is not
5524 good enough to realize that the default case is not needed for the
5525 second switch statement. */
5526 printf (" default:\n abort ();\n");
5527 printf (" }\n}\n\n");
5530 /* This page contains miscellaneous utility routines. */
5532 /* Given a pointer to a (char *), return a malloc'ed string containing the
5533 next comma-separated element. Advance the pointer to after the string
5534 scanned, or the end-of-string. Return NULL if at end of string. */
5537 next_comma_elt (const char **pstr
)
5541 start
= scan_comma_elt (pstr
);
5546 return attr_string (start
, *pstr
- start
);
5549 /* Return a `struct attr_desc' pointer for a given named attribute. If CREATE
5550 is nonzero, build a new attribute, if one does not exist. */
5552 static struct attr_desc
*
5553 find_attr (const char *name
, int create
)
5555 struct attr_desc
*attr
;
5558 /* Before we resort to using `strcmp', see if the string address matches
5559 anywhere. In most cases, it should have been canonicalized to do so. */
5560 if (name
== alternative_name
)
5563 index
= name
[0] & (MAX_ATTRS_INDEX
- 1);
5564 for (attr
= attrs
[index
]; attr
; attr
= attr
->next
)
5565 if (name
== attr
->name
)
5568 /* Otherwise, do it the slow way. */
5569 for (attr
= attrs
[index
]; attr
; attr
= attr
->next
)
5570 if (name
[0] == attr
->name
[0] && ! strcmp (name
, attr
->name
))
5576 attr
= (struct attr_desc
*) oballoc (sizeof (struct attr_desc
));
5577 attr
->name
= attr_string (name
, strlen (name
));
5578 attr
->first_value
= attr
->default_val
= NULL
;
5579 attr
->is_numeric
= attr
->negative_ok
= attr
->is_const
= attr
->is_special
= 0;
5580 attr
->unsigned_p
= attr
->func_units_p
= attr
->blockage_p
= 0;
5581 attr
->next
= attrs
[index
];
5582 attrs
[index
] = attr
;
5587 /* Create internal attribute with the given default value. */
5590 make_internal_attr (const char *name
, rtx value
, int special
)
5592 struct attr_desc
*attr
;
5594 attr
= find_attr (name
, 1);
5595 if (attr
->default_val
)
5598 attr
->is_numeric
= 1;
5600 attr
->is_special
= (special
& 1) != 0;
5601 attr
->negative_ok
= (special
& 2) != 0;
5602 attr
->unsigned_p
= (special
& 4) != 0;
5603 attr
->func_units_p
= (special
& 8) != 0;
5604 attr
->blockage_p
= (special
& 16) != 0;
5605 attr
->default_val
= get_attr_value (value
, attr
, -2);
5608 /* Find the most used value of an attribute. */
5610 static struct attr_value
*
5611 find_most_used (struct attr_desc
*attr
)
5613 struct attr_value
*av
;
5614 struct attr_value
*most_used
;
5620 for (av
= attr
->first_value
; av
; av
= av
->next
)
5621 if (av
->num_insns
> nuses
)
5622 nuses
= av
->num_insns
, most_used
= av
;
5627 /* If an attribute only has a single value used, return it. Otherwise
5631 find_single_value (struct attr_desc
*attr
)
5633 struct attr_value
*av
;
5636 unique_value
= NULL
;
5637 for (av
= attr
->first_value
; av
; av
= av
->next
)
5643 unique_value
= av
->value
;
5646 return unique_value
;
5649 /* Return (attr_value "n") */
5652 make_numeric_value (int n
)
5654 static rtx int_values
[20];
5661 if (n
< 20 && int_values
[n
])
5662 return int_values
[n
];
5664 p
= attr_printf (MAX_DIGITS
, "%d", n
);
5665 exp
= attr_rtx (CONST_STRING
, p
);
5668 int_values
[n
] = exp
;
5674 extend_range (struct range
*range
, int min
, int max
)
5676 if (range
->min
> min
)
5678 if (range
->max
< max
)
5683 copy_rtx_unchanging (rtx orig
)
5685 if (ATTR_IND_SIMPLIFIED_P (orig
) || ATTR_CURR_SIMPLIFIED_P (orig
))
5688 ATTR_CURR_SIMPLIFIED_P (orig
) = 1;
5692 /* Determine if an insn has a constant number of delay slots, i.e., the
5693 number of delay slots is not a function of the length of the insn. */
5696 write_const_num_delay_slots (void)
5698 struct attr_desc
*attr
= find_attr ("*num_delay_slots", 0);
5699 struct attr_value
*av
;
5700 struct insn_ent
*ie
;
5704 printf ("int\nconst_num_delay_slots (rtx insn)\n");
5706 printf (" switch (recog_memoized (insn))\n");
5709 for (av
= attr
->first_value
; av
; av
= av
->next
)
5712 walk_attr_value (av
->value
);
5715 for (ie
= av
->first_insn
; ie
; ie
= ie
->next
)
5716 if (ie
->insn_code
!= -1)
5717 printf (" case %d:\n", ie
->insn_code
);
5718 printf (" return 0;\n");
5722 printf (" default:\n");
5723 printf (" return 1;\n");
5724 printf (" }\n}\n\n");
5729 main (int argc
, char **argv
)
5732 struct attr_desc
*attr
;
5733 struct insn_def
*id
;
5737 progname
= "genattrtab";
5740 fatal ("no input file name");
5742 if (init_md_reader_args (argc
, argv
) != SUCCESS_EXIT_CODE
)
5743 return (FATAL_EXIT_CODE
);
5745 obstack_init (hash_obstack
);
5746 obstack_init (temp_obstack
);
5748 /* Set up true and false rtx's */
5749 true_rtx
= rtx_alloc (CONST_INT
);
5750 XWINT (true_rtx
, 0) = 1;
5751 false_rtx
= rtx_alloc (CONST_INT
);
5752 XWINT (false_rtx
, 0) = 0;
5753 ATTR_IND_SIMPLIFIED_P (true_rtx
) = ATTR_IND_SIMPLIFIED_P (false_rtx
) = 1;
5754 ATTR_PERMANENT_P (true_rtx
) = ATTR_PERMANENT_P (false_rtx
) = 1;
5756 alternative_name
= attr_string ("alternative", strlen ("alternative"));
5758 printf ("/* Generated automatically by the program `genattrtab'\n\
5759 from the machine description file `md'. */\n\n");
5761 /* Read the machine description. */
5763 initiate_automaton_gen (argc
, argv
);
5768 desc
= read_md_rtx (&lineno
, &insn_code_number
);
5772 switch (GET_CODE (desc
))
5775 case DEFINE_PEEPHOLE
:
5776 case DEFINE_ASM_ATTRIBUTES
:
5777 gen_insn (desc
, lineno
);
5781 gen_attr (desc
, lineno
);
5785 gen_delay (desc
, lineno
);
5788 case DEFINE_FUNCTION_UNIT
:
5789 gen_unit (desc
, lineno
);
5792 case DEFINE_CPU_UNIT
:
5793 gen_cpu_unit (desc
);
5796 case DEFINE_QUERY_CPU_UNIT
:
5797 gen_query_cpu_unit (desc
);
5805 gen_excl_set (desc
);
5809 gen_presence_set (desc
);
5812 case FINAL_PRESENCE_SET
:
5813 gen_final_presence_set (desc
);
5817 gen_absence_set (desc
);
5820 case FINAL_ABSENCE_SET
:
5821 gen_final_absence_set (desc
);
5824 case DEFINE_AUTOMATON
:
5825 gen_automaton (desc
);
5828 case AUTOMATA_OPTION
:
5829 gen_automata_option (desc
);
5832 case DEFINE_RESERVATION
:
5836 case DEFINE_INSN_RESERVATION
:
5837 gen_insn_reserv (desc
);
5843 if (GET_CODE (desc
) != DEFINE_ASM_ATTRIBUTES
)
5844 insn_index_number
++;
5848 return FATAL_EXIT_CODE
;
5852 /* If we didn't have a DEFINE_ASM_ATTRIBUTES, make a null one. */
5853 if (! got_define_asm_attributes
)
5855 tem
= rtx_alloc (DEFINE_ASM_ATTRIBUTES
);
5856 XVEC (tem
, 0) = rtvec_alloc (0);
5860 /* Expand DEFINE_DELAY information into new attribute. */
5864 if (num_units
|| num_dfa_decls
)
5866 /* Expand DEFINE_FUNCTION_UNIT information into new attributes. */
5868 /* Build DFA, output some functions and expand DFA information
5869 into new attributes. */
5873 printf ("#include \"config.h\"\n");
5874 printf ("#include \"system.h\"\n");
5875 printf ("#include \"coretypes.h\"\n");
5876 printf ("#include \"tm.h\"\n");
5877 printf ("#include \"rtl.h\"\n");
5878 printf ("#include \"tm_p.h\"\n");
5879 printf ("#include \"insn-config.h\"\n");
5880 printf ("#include \"recog.h\"\n");
5881 printf ("#include \"regs.h\"\n");
5882 printf ("#include \"real.h\"\n");
5883 printf ("#include \"output.h\"\n");
5884 printf ("#include \"insn-attr.h\"\n");
5885 printf ("#include \"toplev.h\"\n");
5886 printf ("#include \"flags.h\"\n");
5887 printf ("#include \"function.h\"\n");
5889 printf ("#define operands recog_data.operand\n\n");
5891 /* Make `insn_alternatives'. */
5892 insn_alternatives
= (int *) oballoc (insn_code_number
* sizeof (int));
5893 for (id
= defs
; id
; id
= id
->next
)
5894 if (id
->insn_code
>= 0)
5895 insn_alternatives
[id
->insn_code
] = (1 << id
->num_alternatives
) - 1;
5897 /* Make `insn_n_alternatives'. */
5898 insn_n_alternatives
= (int *) oballoc (insn_code_number
* sizeof (int));
5899 for (id
= defs
; id
; id
= id
->next
)
5900 if (id
->insn_code
>= 0)
5901 insn_n_alternatives
[id
->insn_code
] = id
->num_alternatives
;
5903 /* Prepare to write out attribute subroutines by checking everything stored
5904 away and building the attribute cases. */
5908 for (i
= 0; i
< MAX_ATTRS_INDEX
; i
++)
5909 for (attr
= attrs
[i
]; attr
; attr
= attr
->next
)
5910 attr
->default_val
->value
5911 = check_attr_value (attr
->default_val
->value
, attr
);
5914 return FATAL_EXIT_CODE
;
5916 for (i
= 0; i
< MAX_ATTRS_INDEX
; i
++)
5917 for (attr
= attrs
[i
]; attr
; attr
= attr
->next
)
5920 /* Construct extra attributes for `length'. */
5921 make_length_attrs ();
5923 /* Perform any possible optimizations to speed up compilation. */
5926 /* Now write out all the `gen_attr_...' routines. Do these before the
5927 special routines (specifically before write_function_unit_info), so
5928 that they get defined before they are used. */
5930 for (i
= 0; i
< MAX_ATTRS_INDEX
; i
++)
5931 for (attr
= attrs
[i
]; attr
; attr
= attr
->next
)
5933 if (! attr
->is_special
&& ! attr
->is_const
)
5938 = (attr
->name
[0] == '*'
5939 && strcmp (&attr
->name
[1], INSN_ALTS_FUNC_NAME
) == 0);
5941 printf ("\n#if AUTOMATON_ALTS\n");
5942 write_attr_get (attr
);
5944 printf ("#endif\n\n");
5948 /* Write out delay eligibility information, if DEFINE_DELAY present.
5949 (The function to compute the number of delay slots will be written
5953 write_eligible_delay ("delay");
5954 if (have_annul_true
)
5955 write_eligible_delay ("annul_true");
5956 if (have_annul_false
)
5957 write_eligible_delay ("annul_false");
5960 if (num_units
|| num_dfa_decls
)
5962 /* Write out information about function units. */
5963 write_function_unit_info ();
5964 /* Output code for pipeline hazards recognition based on DFA
5965 (deterministic finite state automata. */
5969 /* Write out constant delay slot info. */
5970 write_const_num_delay_slots ();
5972 write_length_unit_log ();
5975 return (ferror (stdout
) != 0 ? FATAL_EXIT_CODE
: SUCCESS_EXIT_CODE
);
5978 /* Define this so we can link with print-rtl.o to get debug_rtx function. */
5980 get_insn_name (int code ATTRIBUTE_UNUSED
)