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 struct attr_value
*first_value
; /* First value of this attribute. */
179 struct attr_value
*default_val
; /* Default value for this attribute. */
180 int lineno
: 24; /* Line number. */
181 unsigned is_numeric
: 1; /* Values of this attribute are numeric. */
182 unsigned negative_ok
: 1; /* Allow negative numeric values. */
183 unsigned unsigned_p
: 1; /* Make the output function unsigned int. */
184 unsigned is_const
: 1; /* Attribute value constant for each run. */
185 unsigned is_special
: 1; /* Don't call `write_attr_set'. */
186 unsigned func_units_p
: 1; /* This is the function_units attribute. */
187 unsigned blockage_p
: 1; /* This is the blockage range function. */
188 unsigned static_p
: 1; /* Make the output function static. */
191 #define NULL_ATTR (struct attr_desc *) NULL
193 /* A range of values. */
201 /* Structure for each DEFINE_DELAY. */
205 rtx def
; /* DEFINE_DELAY expression. */
206 struct delay_desc
*next
; /* Next DEFINE_DELAY. */
207 int num
; /* Number of DEFINE_DELAY, starting at 1. */
208 int lineno
; /* Line number. */
211 /* Record information about each DEFINE_FUNCTION_UNIT. */
213 struct function_unit_op
215 rtx condexp
; /* Expression TRUE for applicable insn. */
216 struct function_unit_op
*next
; /* Next operation for this function unit. */
217 int num
; /* Ordinal for this operation type in unit. */
218 int ready
; /* Cost until data is ready. */
219 int issue_delay
; /* Cost until unit can accept another insn. */
220 rtx conflict_exp
; /* Expression TRUE for insns incurring issue delay. */
221 rtx issue_exp
; /* Expression computing issue delay. */
222 int lineno
; /* Line number. */
225 /* Record information about each function unit mentioned in a
226 DEFINE_FUNCTION_UNIT. */
230 const char *name
; /* Function unit name. */
231 struct function_unit
*next
; /* Next function unit. */
232 int num
; /* Ordinal of this unit type. */
233 int multiplicity
; /* Number of units of this type. */
234 int simultaneity
; /* Maximum number of simultaneous insns
235 on this function unit or 0 if unlimited. */
236 rtx condexp
; /* Expression TRUE for insn needing unit. */
237 int num_opclasses
; /* Number of different operation types. */
238 struct function_unit_op
*ops
; /* Pointer to first operation type. */
239 int needs_conflict_function
; /* Nonzero if a conflict function required. */
240 int needs_blockage_function
; /* Nonzero if a blockage function required. */
241 int needs_range_function
; /* Nonzero if blockage range function needed. */
242 rtx default_cost
; /* Conflict cost, if constant. */
243 struct range issue_delay
; /* Range of issue delay values. */
244 int max_blockage
; /* Maximum time an insn blocks the unit. */
245 int first_lineno
; /* First seen line number. */
248 /* Listheads of above structures. */
250 /* This one is indexed by the first character of the attribute name. */
251 #define MAX_ATTRS_INDEX 256
252 static struct attr_desc
*attrs
[MAX_ATTRS_INDEX
];
253 static struct insn_def
*defs
;
254 static struct delay_desc
*delays
;
255 static struct function_unit
*units
;
257 /* An expression where all the unknown terms are EQ_ATTR tests can be
258 rearranged into a COND provided we can enumerate all possible
259 combinations of the unknown values. The set of combinations become the
260 tests of the COND; the value of the expression given that combination is
261 computed and becomes the corresponding value. To do this, we must be
262 able to enumerate all values for each attribute used in the expression
263 (currently, we give up if we find a numeric attribute).
265 If the set of EQ_ATTR tests used in an expression tests the value of N
266 different attributes, the list of all possible combinations can be made
267 by walking the N-dimensional attribute space defined by those
268 attributes. We record each of these as a struct dimension.
270 The algorithm relies on sharing EQ_ATTR nodes: if two nodes in an
271 expression are the same, the will also have the same address. We find
272 all the EQ_ATTR nodes by marking them ATTR_EQ_ATTR_P. This bit later
273 represents the value of an EQ_ATTR node, so once all nodes are marked,
274 they are also given an initial value of FALSE.
276 We then separate the set of EQ_ATTR nodes into dimensions for each
277 attribute and put them on the VALUES list. Terms are added as needed by
278 `add_values_to_cover' so that all possible values of the attribute are
281 Each dimension also has a current value. This is the node that is
282 currently considered to be TRUE. If this is one of the nodes added by
283 `add_values_to_cover', all the EQ_ATTR tests in the original expression
284 will be FALSE. Otherwise, only the CURRENT_VALUE will be true.
286 NUM_VALUES is simply the length of the VALUES list and is there for
289 Once the dimensions are created, the algorithm enumerates all possible
290 values and computes the current value of the given expression. */
294 struct attr_desc
*attr
; /* Attribute for this dimension. */
295 rtx values
; /* List of attribute values used. */
296 rtx current_value
; /* Position in the list for the TRUE value. */
297 int num_values
; /* Length of the values list. */
300 /* Other variables. */
302 static int insn_code_number
;
303 static int insn_index_number
;
304 static int got_define_asm_attributes
;
305 static int must_extract
;
306 static int must_constrain
;
307 static int address_used
;
308 static int length_used
;
309 static int num_delays
;
310 static int have_annul_true
, have_annul_false
;
311 static int num_units
, num_unit_opclasses
;
312 static int num_insn_ents
;
316 /* Used as operand to `operate_exp': */
318 enum operator {PLUS_OP
, MINUS_OP
, POS_MINUS_OP
, EQ_OP
, OR_OP
, ORX_OP
, MAX_OP
, MIN_OP
, RANGE_OP
};
320 /* Stores, for each insn code, the number of constraint alternatives. */
322 static int *insn_n_alternatives
;
324 /* Stores, for each insn code, a bitmap that has bits on for each possible
327 static int *insn_alternatives
;
329 /* If nonzero, assume that the `alternative' attr has this value.
330 This is the hashed, unique string for the numeral
331 whose value is chosen alternative. */
333 static const char *current_alternative_string
;
335 /* Used to simplify expressions. */
337 static rtx true_rtx
, false_rtx
;
339 /* Used to reduce calls to `strcmp' */
341 static char *alternative_name
;
343 /* Indicate that REG_DEAD notes are valid if dead_or_set_p is ever
346 int reload_completed
= 0;
348 /* Some machines test `optimize' in macros called from rtlanal.c, so we need
349 to define it here. */
353 /* Simplify an expression. Only call the routine if there is something to
355 #define SIMPLIFY_TEST_EXP(EXP,INSN_CODE,INSN_INDEX) \
356 (ATTR_IND_SIMPLIFIED_P (EXP) || ATTR_CURR_SIMPLIFIED_P (EXP) ? (EXP) \
357 : simplify_test_exp (EXP, INSN_CODE, INSN_INDEX))
359 /* Simplify (eq_attr ("alternative") ...)
360 when we are working with a particular alternative. */
361 #define SIMPLIFY_ALTERNATIVE(EXP) \
362 if (current_alternative_string \
363 && GET_CODE ((EXP)) == EQ_ATTR \
364 && XSTR ((EXP), 0) == alternative_name) \
365 (EXP) = (XSTR ((EXP), 1) == current_alternative_string \
366 ? true_rtx : false_rtx);
368 /* These are referenced by rtlanal.c and hence need to be defined somewhere.
369 They won't actually be used. */
371 rtx global_rtl
[GR_MAX
];
372 rtx pic_offset_table_rtx
;
374 static void attr_hash_add_rtx (int, rtx
);
375 static void attr_hash_add_string (int, char *);
376 static rtx
attr_rtx (enum rtx_code
, ...);
377 static rtx
attr_rtx_1 (enum rtx_code
, va_list);
378 static char *attr_string (const char *, int);
379 static rtx
check_attr_value (rtx
, struct attr_desc
*);
380 static rtx
convert_set_attr_alternative (rtx
, struct insn_def
*);
381 static rtx
convert_set_attr (rtx
, struct insn_def
*);
382 static void check_defs (void);
383 static rtx
make_canonical (struct attr_desc
*, rtx
);
384 static struct attr_value
*get_attr_value (rtx
, struct attr_desc
*, int);
385 static rtx
copy_rtx_unchanging (rtx
);
386 static rtx
copy_boolean (rtx
);
387 static void expand_delays (void);
388 static rtx
operate_exp (enum operator, rtx
, rtx
);
389 static void expand_units (void);
390 static rtx
simplify_knowing (rtx
, rtx
);
391 static rtx
encode_units_mask (rtx
);
392 static void fill_attr (struct attr_desc
*);
393 static rtx
substitute_address (rtx
, rtx (*) (rtx
), rtx (*) (rtx
));
394 static void make_length_attrs (void);
395 static rtx
identity_fn (rtx
);
396 static rtx
zero_fn (rtx
);
397 static rtx
one_fn (rtx
);
398 static rtx
max_fn (rtx
);
399 static void write_length_unit_log (void);
400 static rtx
simplify_cond (rtx
, int, int);
401 static rtx
simplify_by_exploding (rtx
);
402 static int find_and_mark_used_attributes (rtx
, rtx
*, int *);
403 static void unmark_used_attributes (rtx
, struct dimension
*, int);
404 static int add_values_to_cover (struct dimension
*);
405 static int increment_current_value (struct dimension
*, int);
406 static rtx
test_for_current_value (struct dimension
*, int);
407 static rtx
simplify_with_current_value (rtx
, struct dimension
*, int);
408 static rtx
simplify_with_current_value_aux (rtx
);
409 static void clear_struct_flag (rtx
);
410 static int count_sub_rtxs (rtx
, int);
411 static void remove_insn_ent (struct attr_value
*, struct insn_ent
*);
412 static void insert_insn_ent (struct attr_value
*, struct insn_ent
*);
413 static rtx
insert_right_side (enum rtx_code
, rtx
, rtx
, int, int);
414 static rtx
make_alternative_compare (int);
415 static int compute_alternative_mask (rtx
, enum rtx_code
);
416 static rtx
evaluate_eq_attr (rtx
, rtx
, int, int);
417 static rtx
simplify_and_tree (rtx
, rtx
*, int, int);
418 static rtx
simplify_or_tree (rtx
, rtx
*, int, int);
419 static rtx
simplify_test_exp (rtx
, int, int);
420 static rtx
simplify_test_exp_in_temp (rtx
, int, int);
421 static void optimize_attrs (void);
422 static void gen_attr (rtx
, int);
423 static int count_alternatives (rtx
);
424 static int compares_alternatives_p (rtx
);
425 static int contained_in_p (rtx
, rtx
);
426 static void gen_insn (rtx
, int);
427 static void gen_delay (rtx
, int);
428 static void gen_unit (rtx
, int);
429 static void write_test_expr (rtx
, int);
430 static int max_attr_value (rtx
, int*);
431 static int or_attr_value (rtx
, int*);
432 static void walk_attr_value (rtx
);
433 static void write_attr_get (struct attr_desc
*);
434 static rtx
eliminate_known_true (rtx
, rtx
, int, int);
435 static void write_attr_set (struct attr_desc
*, int, rtx
,
436 const char *, const char *, rtx
,
438 static void write_attr_case (struct attr_desc
*, struct attr_value
*,
439 int, const char *, const char *, int, rtx
);
440 static void write_unit_name (const char *, int, const char *);
441 static void write_attr_valueq (struct attr_desc
*, const char *);
442 static void write_attr_value (struct attr_desc
*, rtx
);
443 static void write_upcase (const char *);
444 static void write_indent (int);
445 static void write_eligible_delay (const char *);
446 static void write_function_unit_info (void);
447 static void write_complex_function (struct function_unit
*, const char *,
449 static int write_expr_attr_cache (rtx
, struct attr_desc
*);
450 static void write_toplevel_expr (rtx
);
451 static void write_const_num_delay_slots (void);
452 static char *next_comma_elt (const char **);
453 static struct attr_desc
*find_attr (const char *, int);
454 static struct attr_value
*find_most_used (struct attr_desc
*);
455 static rtx
find_single_value (struct attr_desc
*);
456 static void extend_range (struct range
*, int, int);
457 static rtx
attr_eq (const char *, const char *);
458 static const char *attr_numeral (int);
459 static int attr_equal_p (rtx
, rtx
);
460 static rtx
attr_copy_rtx (rtx
);
461 static int attr_rtx_cost (rtx
);
463 #define oballoc(size) obstack_alloc (hash_obstack, size)
465 /* Hash table for sharing RTL and strings. */
467 /* Each hash table slot is a bucket containing a chain of these structures.
468 Strings are given negative hash codes; RTL expressions are given positive
473 struct attr_hash
*next
; /* Next structure in the bucket. */
474 int hashcode
; /* Hash code of this rtx or string. */
477 char *str
; /* The string (negative hash codes) */
478 rtx rtl
; /* or the RTL recorded here. */
482 /* Now here is the hash table. When recording an RTL, it is added to
483 the slot whose index is the hash code mod the table size. Note
484 that the hash table is used for several kinds of RTL (see attr_rtx)
485 and for strings. While all these live in the same table, they are
486 completely independent, and the hash code is computed differently
489 #define RTL_HASH_SIZE 4093
490 struct attr_hash
*attr_hash_table
[RTL_HASH_SIZE
];
492 /* Here is how primitive or already-shared RTL's hash
494 #define RTL_HASH(RTL) ((long) (RTL) & 0777777)
496 /* Add an entry to the hash table for RTL with hash code HASHCODE. */
499 attr_hash_add_rtx (int hashcode
, rtx rtl
)
503 h
= obstack_alloc (hash_obstack
, 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
= obstack_alloc (hash_obstack
, sizeof (struct attr_hash
));
518 h
->hashcode
= -hashcode
;
520 h
->next
= attr_hash_table
[hashcode
% RTL_HASH_SIZE
];
521 attr_hash_table
[hashcode
% RTL_HASH_SIZE
] = h
;
524 /* Generate an RTL expression, but avoid duplicates.
525 Set the ATTR_PERMANENT_P flag for these permanent objects.
527 In some cases we cannot uniquify; then we return an ordinary
528 impermanent rtx with ATTR_PERMANENT_P clear.
530 Args are like gen_rtx, but without the mode:
532 rtx attr_rtx (code, [element1, ..., elementn]) */
535 attr_rtx_1 (enum rtx_code code
, va_list p
)
537 rtx rt_val
= NULL_RTX
;/* RTX to return to caller... */
540 struct obstack
*old_obstack
= rtl_obstack
;
542 /* For each of several cases, search the hash table for an existing entry.
543 Use that entry if one is found; otherwise create a new RTL and add it
546 if (GET_RTX_CLASS (code
) == '1')
548 rtx arg0
= va_arg (p
, rtx
);
550 /* A permanent object cannot point to impermanent ones. */
551 if (! ATTR_PERMANENT_P (arg0
))
553 rt_val
= rtx_alloc (code
);
554 XEXP (rt_val
, 0) = arg0
;
558 hashcode
= ((HOST_WIDE_INT
) code
+ RTL_HASH (arg0
));
559 for (h
= attr_hash_table
[hashcode
% RTL_HASH_SIZE
]; h
; h
= h
->next
)
560 if (h
->hashcode
== hashcode
561 && GET_CODE (h
->u
.rtl
) == code
562 && XEXP (h
->u
.rtl
, 0) == arg0
)
567 rtl_obstack
= hash_obstack
;
568 rt_val
= rtx_alloc (code
);
569 XEXP (rt_val
, 0) = arg0
;
572 else if (GET_RTX_CLASS (code
) == 'c'
573 || GET_RTX_CLASS (code
) == '2'
574 || GET_RTX_CLASS (code
) == '<')
576 rtx arg0
= va_arg (p
, rtx
);
577 rtx arg1
= va_arg (p
, rtx
);
579 /* A permanent object cannot point to impermanent ones. */
580 if (! ATTR_PERMANENT_P (arg0
) || ! ATTR_PERMANENT_P (arg1
))
582 rt_val
= rtx_alloc (code
);
583 XEXP (rt_val
, 0) = arg0
;
584 XEXP (rt_val
, 1) = arg1
;
588 hashcode
= ((HOST_WIDE_INT
) code
+ RTL_HASH (arg0
) + RTL_HASH (arg1
));
589 for (h
= attr_hash_table
[hashcode
% RTL_HASH_SIZE
]; h
; h
= h
->next
)
590 if (h
->hashcode
== hashcode
591 && GET_CODE (h
->u
.rtl
) == code
592 && XEXP (h
->u
.rtl
, 0) == arg0
593 && XEXP (h
->u
.rtl
, 1) == arg1
)
598 rtl_obstack
= hash_obstack
;
599 rt_val
= rtx_alloc (code
);
600 XEXP (rt_val
, 0) = arg0
;
601 XEXP (rt_val
, 1) = arg1
;
604 else if (GET_RTX_LENGTH (code
) == 1
605 && GET_RTX_FORMAT (code
)[0] == 's')
607 char *arg0
= va_arg (p
, char *);
609 if (code
== SYMBOL_REF
)
610 arg0
= attr_string (arg0
, strlen (arg0
));
612 hashcode
= ((HOST_WIDE_INT
) code
+ RTL_HASH (arg0
));
613 for (h
= attr_hash_table
[hashcode
% RTL_HASH_SIZE
]; h
; h
= h
->next
)
614 if (h
->hashcode
== hashcode
615 && GET_CODE (h
->u
.rtl
) == code
616 && XSTR (h
->u
.rtl
, 0) == arg0
)
621 rtl_obstack
= hash_obstack
;
622 rt_val
= rtx_alloc (code
);
623 XSTR (rt_val
, 0) = arg0
;
626 else if (GET_RTX_LENGTH (code
) == 2
627 && GET_RTX_FORMAT (code
)[0] == 's'
628 && GET_RTX_FORMAT (code
)[1] == 's')
630 char *arg0
= va_arg (p
, char *);
631 char *arg1
= va_arg (p
, char *);
633 hashcode
= ((HOST_WIDE_INT
) code
+ RTL_HASH (arg0
) + RTL_HASH (arg1
));
634 for (h
= attr_hash_table
[hashcode
% RTL_HASH_SIZE
]; h
; h
= h
->next
)
635 if (h
->hashcode
== hashcode
636 && GET_CODE (h
->u
.rtl
) == code
637 && XSTR (h
->u
.rtl
, 0) == arg0
638 && XSTR (h
->u
.rtl
, 1) == arg1
)
643 rtl_obstack
= hash_obstack
;
644 rt_val
= rtx_alloc (code
);
645 XSTR (rt_val
, 0) = arg0
;
646 XSTR (rt_val
, 1) = arg1
;
649 else if (code
== CONST_INT
)
651 HOST_WIDE_INT arg0
= va_arg (p
, HOST_WIDE_INT
);
661 int i
; /* Array indices... */
662 const char *fmt
; /* Current rtx's format... */
664 rt_val
= rtx_alloc (code
); /* Allocate the storage space. */
666 fmt
= GET_RTX_FORMAT (code
); /* Find the right format... */
667 for (i
= 0; i
< GET_RTX_LENGTH (code
); i
++)
671 case '0': /* Unused field. */
674 case 'i': /* An integer? */
675 XINT (rt_val
, i
) = va_arg (p
, int);
678 case 'w': /* A wide integer? */
679 XWINT (rt_val
, i
) = va_arg (p
, HOST_WIDE_INT
);
682 case 's': /* A string? */
683 XSTR (rt_val
, i
) = va_arg (p
, char *);
686 case 'e': /* An expression? */
687 case 'u': /* An insn? Same except when printing. */
688 XEXP (rt_val
, i
) = va_arg (p
, rtx
);
691 case 'E': /* An RTX vector? */
692 XVEC (rt_val
, i
) = va_arg (p
, rtvec
);
702 rtl_obstack
= old_obstack
;
703 attr_hash_add_rtx (hashcode
, rt_val
);
704 ATTR_PERMANENT_P (rt_val
) = 1;
709 attr_rtx (enum rtx_code code
, ...)
715 result
= attr_rtx_1 (code
, p
);
720 /* Create a new string printed with the printf line arguments into a space
721 of at most LEN bytes:
723 rtx attr_printf (len, format, [arg1, ..., argn]) */
726 attr_printf (unsigned int len
, const char *fmt
, ...)
733 if (len
> sizeof str
- 1) /* Leave room for \0. */
736 vsprintf (str
, fmt
, p
);
739 return attr_string (str
, strlen (str
));
743 attr_eq (const char *name
, const char *value
)
745 return attr_rtx (EQ_ATTR
, attr_string (name
, strlen (name
)),
746 attr_string (value
, strlen (value
)));
752 return XSTR (make_numeric_value (n
), 0);
755 /* Return a permanent (possibly shared) copy of a string STR (not assumed
756 to be null terminated) with LEN bytes. */
759 attr_string (const char *str
, int len
)
766 /* Compute the hash code. */
767 hashcode
= (len
+ 1) * 613 + (unsigned) str
[0];
768 for (i
= 1; i
<= len
; i
+= 2)
769 hashcode
= ((hashcode
* 613) + (unsigned) str
[i
]);
771 hashcode
= -hashcode
;
773 /* Search the table for the string. */
774 for (h
= attr_hash_table
[hashcode
% RTL_HASH_SIZE
]; h
; h
= h
->next
)
775 if (h
->hashcode
== -hashcode
&& h
->u
.str
[0] == str
[0]
776 && !strncmp (h
->u
.str
, str
, len
))
777 return h
->u
.str
; /* <-- return if found. */
779 /* Not found; create a permanent copy and add it to the hash table. */
780 new_str
= obstack_alloc (hash_obstack
, len
+ 1);
781 memcpy (new_str
, str
, len
);
783 attr_hash_add_string (hashcode
, new_str
);
785 return new_str
; /* Return the new string. */
788 /* Check two rtx's for equality of contents,
789 taking advantage of the fact that if both are hashed
790 then they can't be equal unless they are the same object. */
793 attr_equal_p (rtx x
, rtx y
)
795 return (x
== y
|| (! (ATTR_PERMANENT_P (x
) && ATTR_PERMANENT_P (y
))
796 && rtx_equal_p (x
, y
)));
799 /* Copy an attribute value expression,
800 descending to all depths, but not copying any
801 permanent hashed subexpressions. */
804 attr_copy_rtx (rtx orig
)
809 const char *format_ptr
;
811 /* No need to copy a permanent object. */
812 if (ATTR_PERMANENT_P (orig
))
815 code
= GET_CODE (orig
);
834 copy
= rtx_alloc (code
);
835 PUT_MODE (copy
, GET_MODE (orig
));
836 ATTR_IND_SIMPLIFIED_P (copy
) = ATTR_IND_SIMPLIFIED_P (orig
);
837 ATTR_CURR_SIMPLIFIED_P (copy
) = ATTR_CURR_SIMPLIFIED_P (orig
);
838 ATTR_PERMANENT_P (copy
) = ATTR_PERMANENT_P (orig
);
839 ATTR_EQ_ATTR_P (copy
) = ATTR_EQ_ATTR_P (orig
);
841 format_ptr
= GET_RTX_FORMAT (GET_CODE (copy
));
843 for (i
= 0; i
< GET_RTX_LENGTH (GET_CODE (copy
)); i
++)
845 switch (*format_ptr
++)
848 XEXP (copy
, i
) = XEXP (orig
, i
);
849 if (XEXP (orig
, i
) != NULL
)
850 XEXP (copy
, i
) = attr_copy_rtx (XEXP (orig
, i
));
855 XVEC (copy
, i
) = XVEC (orig
, i
);
856 if (XVEC (orig
, i
) != NULL
)
858 XVEC (copy
, i
) = rtvec_alloc (XVECLEN (orig
, i
));
859 for (j
= 0; j
< XVECLEN (copy
, i
); j
++)
860 XVECEXP (copy
, i
, j
) = attr_copy_rtx (XVECEXP (orig
, i
, j
));
866 XINT (copy
, i
) = XINT (orig
, i
);
870 XWINT (copy
, i
) = XWINT (orig
, i
);
875 XSTR (copy
, i
) = XSTR (orig
, i
);
885 /* Given a test expression for an attribute, ensure it is validly formed.
886 IS_CONST indicates whether the expression is constant for each compiler
887 run (a constant expression may not test any particular insn).
889 Convert (eq_attr "att" "a1,a2") to (ior (eq_attr ... ) (eq_attrq ..))
890 and (eq_attr "att" "!a1") to (not (eq_attr "att" "a1")). Do the latter
891 test first so that (eq_attr "att" "!a1,a2,a3") works as expected.
893 Update the string address in EQ_ATTR expression to be the same used
894 in the attribute (or `alternative_name') to speed up subsequent
895 `find_attr' calls and eliminate most `strcmp' calls.
897 Return the new expression, if any. */
900 check_attr_test (rtx exp
, int is_const
, int lineno
)
902 struct attr_desc
*attr
;
903 struct attr_value
*av
;
904 const char *name_ptr
, *p
;
907 switch (GET_CODE (exp
))
910 /* Handle negation test. */
911 if (XSTR (exp
, 1)[0] == '!')
912 return check_attr_test (attr_rtx (NOT
,
913 attr_eq (XSTR (exp
, 0),
917 else if (n_comma_elts (XSTR (exp
, 1)) == 1)
919 attr
= find_attr (XSTR (exp
, 0), 0);
922 if (! strcmp (XSTR (exp
, 0), "alternative"))
924 XSTR (exp
, 0) = alternative_name
;
925 /* This can't be simplified any further. */
926 ATTR_IND_SIMPLIFIED_P (exp
) = 1;
930 fatal ("unknown attribute `%s' in EQ_ATTR", XSTR (exp
, 0));
933 if (is_const
&& ! attr
->is_const
)
934 fatal ("constant expression uses insn attribute `%s' in EQ_ATTR",
937 /* Copy this just to make it permanent,
938 so expressions using it can be permanent too. */
939 exp
= attr_eq (XSTR (exp
, 0), XSTR (exp
, 1));
941 /* It shouldn't be possible to simplify the value given to a
942 constant attribute, so don't expand this until it's time to
943 write the test expression. */
945 ATTR_IND_SIMPLIFIED_P (exp
) = 1;
947 if (attr
->is_numeric
)
949 for (p
= XSTR (exp
, 1); *p
; p
++)
951 fatal ("attribute `%s' takes only numeric values",
956 for (av
= attr
->first_value
; av
; av
= av
->next
)
957 if (GET_CODE (av
->value
) == CONST_STRING
958 && ! strcmp (XSTR (exp
, 1), XSTR (av
->value
, 0)))
962 fatal ("unknown value `%s' for `%s' attribute",
963 XSTR (exp
, 1), XSTR (exp
, 0));
968 /* Make an IOR tree of the possible values. */
970 name_ptr
= XSTR (exp
, 1);
971 while ((p
= next_comma_elt (&name_ptr
)) != NULL
)
973 newexp
= attr_eq (XSTR (exp
, 0), p
);
974 orexp
= insert_right_side (IOR
, orexp
, newexp
, -2, -2);
977 return check_attr_test (orexp
, is_const
, lineno
);
985 /* Either TRUE or FALSE. */
993 XEXP (exp
, 0) = check_attr_test (XEXP (exp
, 0), is_const
, lineno
);
994 XEXP (exp
, 1) = check_attr_test (XEXP (exp
, 1), is_const
, lineno
);
998 XEXP (exp
, 0) = check_attr_test (XEXP (exp
, 0), is_const
, lineno
);
1004 fatal ("RTL operator \"%s\" not valid in constant attribute test",
1005 GET_RTX_NAME (GET_CODE (exp
)));
1006 /* These cases can't be simplified. */
1007 ATTR_IND_SIMPLIFIED_P (exp
) = 1;
1010 case LE
: case LT
: case GT
: case GE
:
1011 case LEU
: case LTU
: case GTU
: case GEU
:
1013 if (GET_CODE (XEXP (exp
, 0)) == SYMBOL_REF
1014 && GET_CODE (XEXP (exp
, 1)) == SYMBOL_REF
)
1015 exp
= attr_rtx (GET_CODE (exp
),
1016 attr_rtx (SYMBOL_REF
, XSTR (XEXP (exp
, 0), 0)),
1017 attr_rtx (SYMBOL_REF
, XSTR (XEXP (exp
, 1), 0)));
1018 /* These cases can't be simplified. */
1019 ATTR_IND_SIMPLIFIED_P (exp
) = 1;
1025 /* These cases are valid for constant attributes, but can't be
1027 exp
= attr_rtx (SYMBOL_REF
, XSTR (exp
, 0));
1028 ATTR_IND_SIMPLIFIED_P (exp
) = 1;
1032 fatal ("RTL operator \"%s\" not valid in attribute test",
1033 GET_RTX_NAME (GET_CODE (exp
)));
1039 /* Given an expression, ensure that it is validly formed and that all named
1040 attribute values are valid for the given attribute. Issue a fatal error
1041 if not. If no attribute is specified, assume a numeric attribute.
1043 Return a perhaps modified replacement expression for the value. */
1046 check_attr_value (rtx exp
, struct attr_desc
*attr
)
1048 struct attr_value
*av
;
1052 switch (GET_CODE (exp
))
1055 if (attr
&& ! attr
->is_numeric
)
1057 message_with_line (attr
->lineno
,
1058 "CONST_INT not valid for non-numeric attribute %s",
1064 if (INTVAL (exp
) < 0 && ! attr
->negative_ok
)
1066 message_with_line (attr
->lineno
,
1067 "negative numeric value specified for attribute %s",
1075 if (! strcmp (XSTR (exp
, 0), "*"))
1078 if (attr
== 0 || attr
->is_numeric
)
1081 if (attr
&& attr
->negative_ok
&& *p
== '-')
1086 message_with_line (attr
? attr
->lineno
: 0,
1087 "non-numeric value for numeric attribute %s",
1088 attr
? attr
->name
: "internal");
1095 for (av
= attr
->first_value
; av
; av
= av
->next
)
1096 if (GET_CODE (av
->value
) == CONST_STRING
1097 && ! strcmp (XSTR (av
->value
, 0), XSTR (exp
, 0)))
1102 message_with_line (attr
->lineno
,
1103 "unknown value `%s' for `%s' attribute",
1104 XSTR (exp
, 0), attr
? attr
->name
: "internal");
1110 XEXP (exp
, 0) = check_attr_test (XEXP (exp
, 0),
1111 attr
? attr
->is_const
: 0,
1112 attr
? attr
->lineno
: 0);
1113 XEXP (exp
, 1) = check_attr_value (XEXP (exp
, 1), attr
);
1114 XEXP (exp
, 2) = check_attr_value (XEXP (exp
, 2), attr
);
1122 if (attr
&& !attr
->is_numeric
)
1124 message_with_line (attr
->lineno
,
1125 "invalid operation `%s' for non-numeric attribute value",
1126 GET_RTX_NAME (GET_CODE (exp
)));
1134 XEXP (exp
, 0) = check_attr_value (XEXP (exp
, 0), attr
);
1135 XEXP (exp
, 1) = check_attr_value (XEXP (exp
, 1), attr
);
1143 XEXP (exp
, 0) = check_attr_value (XEXP (exp
, 0), attr
);
1147 if (XVECLEN (exp
, 0) % 2 != 0)
1149 message_with_line (attr
->lineno
,
1150 "first operand of COND must have even length");
1155 for (i
= 0; i
< XVECLEN (exp
, 0); i
+= 2)
1157 XVECEXP (exp
, 0, i
) = check_attr_test (XVECEXP (exp
, 0, i
),
1158 attr
? attr
->is_const
: 0,
1159 attr
? attr
->lineno
: 0);
1160 XVECEXP (exp
, 0, i
+ 1)
1161 = check_attr_value (XVECEXP (exp
, 0, i
+ 1), attr
);
1164 XEXP (exp
, 1) = check_attr_value (XEXP (exp
, 1), attr
);
1169 struct attr_desc
*attr2
= find_attr (XSTR (exp
, 0), 0);
1172 message_with_line (attr
? attr
->lineno
: 0,
1173 "unknown attribute `%s' in ATTR",
1177 else if (attr
&& attr
->is_const
&& ! attr2
->is_const
)
1179 message_with_line (attr
->lineno
,
1180 "non-constant attribute `%s' referenced from `%s'",
1181 XSTR (exp
, 0), attr
->name
);
1185 && (attr
->is_numeric
!= attr2
->is_numeric
1186 || (! attr
->negative_ok
&& attr2
->negative_ok
)))
1188 message_with_line (attr
->lineno
,
1189 "numeric attribute mismatch calling `%s' from `%s'",
1190 XSTR (exp
, 0), attr
->name
);
1197 /* A constant SYMBOL_REF is valid as a constant attribute test and
1198 is expanded later by make_canonical into a COND. In a non-constant
1199 attribute test, it is left be. */
1200 return attr_rtx (SYMBOL_REF
, XSTR (exp
, 0));
1203 message_with_line (attr
? attr
->lineno
: 0,
1204 "invalid operation `%s' for attribute value",
1205 GET_RTX_NAME (GET_CODE (exp
)));
1213 /* Given an SET_ATTR_ALTERNATIVE expression, convert to the canonical SET.
1214 It becomes a COND with each test being (eq_attr "alternative "n") */
1217 convert_set_attr_alternative (rtx exp
, struct insn_def
*id
)
1219 int num_alt
= id
->num_alternatives
;
1223 if (XVECLEN (exp
, 1) != num_alt
)
1225 message_with_line (id
->lineno
,
1226 "bad number of entries in SET_ATTR_ALTERNATIVE");
1231 /* Make a COND with all tests but the last. Select the last value via the
1233 condexp
= rtx_alloc (COND
);
1234 XVEC (condexp
, 0) = rtvec_alloc ((num_alt
- 1) * 2);
1236 for (i
= 0; i
< num_alt
- 1; i
++)
1239 p
= attr_numeral (i
);
1241 XVECEXP (condexp
, 0, 2 * i
) = attr_eq (alternative_name
, p
);
1242 XVECEXP (condexp
, 0, 2 * i
+ 1) = XVECEXP (exp
, 1, i
);
1245 XEXP (condexp
, 1) = XVECEXP (exp
, 1, i
);
1247 return attr_rtx (SET
, attr_rtx (ATTR
, XSTR (exp
, 0)), condexp
);
1250 /* Given a SET_ATTR, convert to the appropriate SET. If a comma-separated
1251 list of values is given, convert to SET_ATTR_ALTERNATIVE first. */
1254 convert_set_attr (rtx exp
, struct insn_def
*id
)
1257 const char *name_ptr
;
1261 /* See how many alternative specified. */
1262 n
= n_comma_elts (XSTR (exp
, 1));
1264 return attr_rtx (SET
,
1265 attr_rtx (ATTR
, XSTR (exp
, 0)),
1266 attr_rtx (CONST_STRING
, XSTR (exp
, 1)));
1268 newexp
= rtx_alloc (SET_ATTR_ALTERNATIVE
);
1269 XSTR (newexp
, 0) = XSTR (exp
, 0);
1270 XVEC (newexp
, 1) = rtvec_alloc (n
);
1272 /* Process each comma-separated name. */
1273 name_ptr
= XSTR (exp
, 1);
1275 while ((p
= next_comma_elt (&name_ptr
)) != NULL
)
1276 XVECEXP (newexp
, 1, n
++) = attr_rtx (CONST_STRING
, p
);
1278 return convert_set_attr_alternative (newexp
, id
);
1281 /* Scan all definitions, checking for validity. Also, convert any SET_ATTR
1282 and SET_ATTR_ALTERNATIVE expressions to the corresponding SET
1288 struct insn_def
*id
;
1289 struct attr_desc
*attr
;
1293 for (id
= defs
; id
; id
= id
->next
)
1295 if (XVEC (id
->def
, id
->vec_idx
) == NULL
)
1298 for (i
= 0; i
< XVECLEN (id
->def
, id
->vec_idx
); i
++)
1300 value
= XVECEXP (id
->def
, id
->vec_idx
, i
);
1301 switch (GET_CODE (value
))
1304 if (GET_CODE (XEXP (value
, 0)) != ATTR
)
1306 message_with_line (id
->lineno
, "bad attribute set");
1312 case SET_ATTR_ALTERNATIVE
:
1313 value
= convert_set_attr_alternative (value
, id
);
1317 value
= convert_set_attr (value
, id
);
1321 message_with_line (id
->lineno
, "invalid attribute code %s",
1322 GET_RTX_NAME (GET_CODE (value
)));
1326 if (value
== NULL_RTX
)
1329 if ((attr
= find_attr (XSTR (XEXP (value
, 0), 0), 0)) == NULL
)
1331 message_with_line (id
->lineno
, "unknown attribute %s",
1332 XSTR (XEXP (value
, 0), 0));
1337 XVECEXP (id
->def
, id
->vec_idx
, i
) = value
;
1338 XEXP (value
, 1) = check_attr_value (XEXP (value
, 1), attr
);
1343 /* Given a valid expression for an attribute value, remove any IF_THEN_ELSE
1344 expressions by converting them into a COND. This removes cases from this
1345 program. Also, replace an attribute value of "*" with the default attribute
1349 make_canonical (struct attr_desc
*attr
, rtx exp
)
1354 switch (GET_CODE (exp
))
1357 exp
= make_numeric_value (INTVAL (exp
));
1361 if (! strcmp (XSTR (exp
, 0), "*"))
1363 if (attr
== 0 || attr
->default_val
== 0)
1364 fatal ("(attr_value \"*\") used in invalid context");
1365 exp
= attr
->default_val
->value
;
1371 if (!attr
->is_const
|| ATTR_IND_SIMPLIFIED_P (exp
))
1373 /* The SYMBOL_REF is constant for a given run, so mark it as unchanging.
1374 This makes the COND something that won't be considered an arbitrary
1375 expression by walk_attr_value. */
1376 ATTR_IND_SIMPLIFIED_P (exp
) = 1;
1377 exp
= check_attr_value (exp
, attr
);
1381 newexp
= rtx_alloc (COND
);
1382 XVEC (newexp
, 0) = rtvec_alloc (2);
1383 XVECEXP (newexp
, 0, 0) = XEXP (exp
, 0);
1384 XVECEXP (newexp
, 0, 1) = XEXP (exp
, 1);
1386 XEXP (newexp
, 1) = XEXP (exp
, 2);
1389 /* Fall through to COND case since this is now a COND. */
1396 /* First, check for degenerate COND. */
1397 if (XVECLEN (exp
, 0) == 0)
1398 return make_canonical (attr
, XEXP (exp
, 1));
1399 defval
= XEXP (exp
, 1) = make_canonical (attr
, XEXP (exp
, 1));
1401 for (i
= 0; i
< XVECLEN (exp
, 0); i
+= 2)
1403 XVECEXP (exp
, 0, i
) = copy_boolean (XVECEXP (exp
, 0, i
));
1404 XVECEXP (exp
, 0, i
+ 1)
1405 = make_canonical (attr
, XVECEXP (exp
, 0, i
+ 1));
1406 if (! rtx_equal_p (XVECEXP (exp
, 0, i
+ 1), defval
))
1422 copy_boolean (rtx exp
)
1424 if (GET_CODE (exp
) == AND
|| GET_CODE (exp
) == IOR
)
1425 return attr_rtx (GET_CODE (exp
), copy_boolean (XEXP (exp
, 0)),
1426 copy_boolean (XEXP (exp
, 1)));
1430 /* Given a value and an attribute description, return a `struct attr_value *'
1431 that represents that value. This is either an existing structure, if the
1432 value has been previously encountered, or a newly-created structure.
1434 `insn_code' is the code of an insn whose attribute has the specified
1435 value (-2 if not processing an insn). We ensure that all insns for
1436 a given value have the same number of alternatives if the value checks
1439 static struct attr_value
*
1440 get_attr_value (rtx value
, struct attr_desc
*attr
, int insn_code
)
1442 struct attr_value
*av
;
1445 value
= make_canonical (attr
, value
);
1446 if (compares_alternatives_p (value
))
1448 if (insn_code
< 0 || insn_alternatives
== NULL
)
1449 fatal ("(eq_attr \"alternatives\" ...) used in non-insn context");
1451 num_alt
= insn_alternatives
[insn_code
];
1454 for (av
= attr
->first_value
; av
; av
= av
->next
)
1455 if (rtx_equal_p (value
, av
->value
)
1456 && (num_alt
== 0 || av
->first_insn
== NULL
1457 || insn_alternatives
[av
->first_insn
->insn_code
]))
1460 av
= oballoc (sizeof (struct attr_value
));
1462 av
->next
= attr
->first_value
;
1463 attr
->first_value
= av
;
1464 av
->first_insn
= NULL
;
1466 av
->has_asm_insn
= 0;
1471 /* After all DEFINE_DELAYs have been read in, create internal attributes
1472 to generate the required routines.
1474 First, we compute the number of delay slots for each insn (as a COND of
1475 each of the test expressions in DEFINE_DELAYs). Then, if more than one
1476 delay type is specified, we compute a similar function giving the
1477 DEFINE_DELAY ordinal for each insn.
1479 Finally, for each [DEFINE_DELAY, slot #] pair, we compute an attribute that
1480 tells whether a given insn can be in that delay slot.
1482 Normal attribute filling and optimization expands these to contain the
1483 information needed to handle delay slots. */
1486 expand_delays (void)
1488 struct delay_desc
*delay
;
1494 /* First, generate data for `num_delay_slots' function. */
1496 condexp
= rtx_alloc (COND
);
1497 XVEC (condexp
, 0) = rtvec_alloc (num_delays
* 2);
1498 XEXP (condexp
, 1) = make_numeric_value (0);
1500 for (i
= 0, delay
= delays
; delay
; i
+= 2, delay
= delay
->next
)
1502 XVECEXP (condexp
, 0, i
) = XEXP (delay
->def
, 0);
1503 XVECEXP (condexp
, 0, i
+ 1)
1504 = make_numeric_value (XVECLEN (delay
->def
, 1) / 3);
1507 make_internal_attr ("*num_delay_slots", condexp
, ATTR_NONE
);
1509 /* If more than one delay type, do the same for computing the delay type. */
1512 condexp
= rtx_alloc (COND
);
1513 XVEC (condexp
, 0) = rtvec_alloc (num_delays
* 2);
1514 XEXP (condexp
, 1) = make_numeric_value (0);
1516 for (i
= 0, delay
= delays
; delay
; i
+= 2, delay
= delay
->next
)
1518 XVECEXP (condexp
, 0, i
) = XEXP (delay
->def
, 0);
1519 XVECEXP (condexp
, 0, i
+ 1) = make_numeric_value (delay
->num
);
1522 make_internal_attr ("*delay_type", condexp
, ATTR_SPECIAL
);
1525 /* For each delay possibility and delay slot, compute an eligibility
1526 attribute for non-annulled insns and for each type of annulled (annul
1527 if true and annul if false). */
1528 for (delay
= delays
; delay
; delay
= delay
->next
)
1530 for (i
= 0; i
< XVECLEN (delay
->def
, 1); i
+= 3)
1532 condexp
= XVECEXP (delay
->def
, 1, i
);
1534 condexp
= false_rtx
;
1535 newexp
= attr_rtx (IF_THEN_ELSE
, condexp
,
1536 make_numeric_value (1), make_numeric_value (0));
1538 p
= attr_printf (sizeof "*delay__" + MAX_DIGITS
* 2,
1539 "*delay_%d_%d", delay
->num
, i
/ 3);
1540 make_internal_attr (p
, newexp
, ATTR_SPECIAL
);
1542 if (have_annul_true
)
1544 condexp
= XVECEXP (delay
->def
, 1, i
+ 1);
1545 if (condexp
== 0) condexp
= false_rtx
;
1546 newexp
= attr_rtx (IF_THEN_ELSE
, condexp
,
1547 make_numeric_value (1),
1548 make_numeric_value (0));
1549 p
= attr_printf (sizeof "*annul_true__" + MAX_DIGITS
* 2,
1550 "*annul_true_%d_%d", delay
->num
, i
/ 3);
1551 make_internal_attr (p
, newexp
, ATTR_SPECIAL
);
1554 if (have_annul_false
)
1556 condexp
= XVECEXP (delay
->def
, 1, i
+ 2);
1557 if (condexp
== 0) condexp
= false_rtx
;
1558 newexp
= attr_rtx (IF_THEN_ELSE
, condexp
,
1559 make_numeric_value (1),
1560 make_numeric_value (0));
1561 p
= attr_printf (sizeof "*annul_false__" + MAX_DIGITS
* 2,
1562 "*annul_false_%d_%d", delay
->num
, i
/ 3);
1563 make_internal_attr (p
, newexp
, ATTR_SPECIAL
);
1569 /* This function is given a left and right side expression and an operator.
1570 Each side is a conditional expression, each alternative of which has a
1571 numerical value. The function returns another conditional expression
1572 which, for every possible set of condition values, returns a value that is
1573 the operator applied to the values of the two sides.
1575 Since this is called early, it must also support IF_THEN_ELSE. */
1578 operate_exp (enum operator op
, rtx left
, rtx right
)
1580 int left_value
, right_value
;
1584 /* If left is a string, apply operator to it and the right side. */
1585 if (GET_CODE (left
) == CONST_STRING
)
1587 /* If right is also a string, just perform the operation. */
1588 if (GET_CODE (right
) == CONST_STRING
)
1590 left_value
= atoi (XSTR (left
, 0));
1591 right_value
= atoi (XSTR (right
, 0));
1595 i
= left_value
+ right_value
;
1599 i
= left_value
- right_value
;
1602 case POS_MINUS_OP
: /* The positive part of LEFT - RIGHT. */
1603 if (left_value
> right_value
)
1604 i
= left_value
- right_value
;
1611 i
= left_value
| right_value
;
1615 i
= left_value
== right_value
;
1619 i
= (left_value
<< (HOST_BITS_PER_INT
/ 2)) | right_value
;
1623 if (left_value
> right_value
)
1630 if (left_value
< right_value
)
1640 if (i
== left_value
)
1642 if (i
== right_value
)
1644 return make_numeric_value (i
);
1646 else if (GET_CODE (right
) == IF_THEN_ELSE
)
1648 /* Apply recursively to all values within. */
1649 rtx newleft
= operate_exp (op
, left
, XEXP (right
, 1));
1650 rtx newright
= operate_exp (op
, left
, XEXP (right
, 2));
1651 if (rtx_equal_p (newleft
, newright
))
1653 return attr_rtx (IF_THEN_ELSE
, XEXP (right
, 0), newleft
, newright
);
1655 else if (GET_CODE (right
) == COND
)
1660 newexp
= rtx_alloc (COND
);
1661 XVEC (newexp
, 0) = rtvec_alloc (XVECLEN (right
, 0));
1662 defval
= XEXP (newexp
, 1) = operate_exp (op
, left
, XEXP (right
, 1));
1664 for (i
= 0; i
< XVECLEN (right
, 0); i
+= 2)
1666 XVECEXP (newexp
, 0, i
) = XVECEXP (right
, 0, i
);
1667 XVECEXP (newexp
, 0, i
+ 1)
1668 = operate_exp (op
, left
, XVECEXP (right
, 0, i
+ 1));
1669 if (! rtx_equal_p (XVECEXP (newexp
, 0, i
+ 1),
1674 /* If the resulting cond is trivial (all alternatives
1675 give the same value), optimize it away. */
1677 return operate_exp (op
, left
, XEXP (right
, 1));
1682 fatal ("badly formed attribute value");
1685 /* A hack to prevent expand_units from completely blowing up: ORX_OP does
1686 not associate through IF_THEN_ELSE. */
1687 else if (op
== ORX_OP
&& GET_CODE (right
) == IF_THEN_ELSE
)
1689 return attr_rtx (IOR
, left
, right
);
1692 /* Otherwise, do recursion the other way. */
1693 else if (GET_CODE (left
) == IF_THEN_ELSE
)
1695 rtx newleft
= operate_exp (op
, XEXP (left
, 1), right
);
1696 rtx newright
= operate_exp (op
, XEXP (left
, 2), right
);
1697 if (rtx_equal_p (newleft
, newright
))
1699 return attr_rtx (IF_THEN_ELSE
, XEXP (left
, 0), newleft
, newright
);
1701 else if (GET_CODE (left
) == COND
)
1706 newexp
= rtx_alloc (COND
);
1707 XVEC (newexp
, 0) = rtvec_alloc (XVECLEN (left
, 0));
1708 defval
= XEXP (newexp
, 1) = operate_exp (op
, XEXP (left
, 1), right
);
1710 for (i
= 0; i
< XVECLEN (left
, 0); i
+= 2)
1712 XVECEXP (newexp
, 0, i
) = XVECEXP (left
, 0, i
);
1713 XVECEXP (newexp
, 0, i
+ 1)
1714 = operate_exp (op
, XVECEXP (left
, 0, i
+ 1), right
);
1715 if (! rtx_equal_p (XVECEXP (newexp
, 0, i
+ 1),
1720 /* If the cond is trivial (all alternatives give the same value),
1721 optimize it away. */
1723 return operate_exp (op
, XEXP (left
, 1), right
);
1725 /* If the result is the same as the LEFT operand,
1727 if (rtx_equal_p (newexp
, left
))
1734 fatal ("badly formed attribute value");
1739 /* Once all attributes and DEFINE_FUNCTION_UNITs have been read, we
1740 construct a number of attributes.
1742 The first produces a function `function_units_used' which is given an
1743 insn and produces an encoding showing which function units are required
1744 for the execution of that insn. If the value is non-negative, the insn
1745 uses that unit; otherwise, the value is a one's complement mask of units
1748 The second produces a function `result_ready_cost' which is used to
1749 determine the time that the result of an insn will be ready and hence
1750 a worst-case schedule.
1752 Both of these produce quite complex expressions which are then set as the
1753 default value of internal attributes. Normal attribute simplification
1754 should produce reasonable expressions.
1756 For each unit, a `<name>_unit_ready_cost' function will take an
1757 insn and give the delay until that unit will be ready with the result
1758 and a `<name>_unit_conflict_cost' function is given an insn already
1759 executing on the unit and a candidate to execute and will give the
1760 cost from the time the executing insn started until the candidate
1761 can start (ignore limitations on the number of simultaneous insns).
1763 For each unit, a `<name>_unit_blockage' function is given an insn
1764 already executing on the unit and a candidate to execute and will
1765 give the delay incurred due to function unit conflicts. The range of
1766 blockage cost values for a given executing insn is given by the
1767 `<name>_unit_blockage_range' function. These values are encoded in
1768 an int where the upper half gives the minimum value and the lower
1769 half gives the maximum value. */
1774 struct function_unit
*unit
, **unit_num
;
1775 struct function_unit_op
*op
, **op_array
, ***unit_ops
;
1780 int i
, j
, u
, num
, nvalues
;
1782 /* Rebuild the condition for the unit to share the RTL expressions.
1783 Sharing is required by simplify_by_exploding. Build the issue delay
1784 expressions. Validate the expressions we were given for the conditions
1785 and conflict vector. Then make attributes for use in the conflict
1788 for (unit
= units
; unit
; unit
= unit
->next
)
1790 unit
->condexp
= check_attr_test (unit
->condexp
, 0, unit
->first_lineno
);
1792 for (op
= unit
->ops
; op
; op
= op
->next
)
1794 rtx issue_delay
= make_numeric_value (op
->issue_delay
);
1795 rtx issue_exp
= issue_delay
;
1797 /* Build, validate, and simplify the issue delay expression. */
1798 if (op
->conflict_exp
!= true_rtx
)
1799 issue_exp
= attr_rtx (IF_THEN_ELSE
, op
->conflict_exp
,
1800 issue_exp
, make_numeric_value (0));
1801 issue_exp
= check_attr_value (make_canonical (NULL_ATTR
,
1804 issue_exp
= simplify_knowing (issue_exp
, unit
->condexp
);
1805 op
->issue_exp
= issue_exp
;
1807 /* Make an attribute for use in the conflict function if needed. */
1808 unit
->needs_conflict_function
= (unit
->issue_delay
.min
1809 != unit
->issue_delay
.max
);
1810 if (unit
->needs_conflict_function
)
1812 str
= attr_printf ((strlen (unit
->name
) + sizeof "*_cost_"
1814 "*%s_cost_%d", unit
->name
, op
->num
);
1815 make_internal_attr (str
, issue_exp
, ATTR_SPECIAL
);
1818 /* Validate the condition. */
1819 op
->condexp
= check_attr_test (op
->condexp
, 0, op
->lineno
);
1823 /* Compute the mask of function units used. Initially, the unitsmask is
1824 zero. Set up a conditional to compute each unit's contribution. */
1825 unitsmask
= make_numeric_value (0);
1826 newexp
= rtx_alloc (IF_THEN_ELSE
);
1827 XEXP (newexp
, 2) = make_numeric_value (0);
1829 /* If we have just a few units, we may be all right expanding the whole
1830 thing. But the expansion is 2**N in space on the number of opclasses,
1831 so we can't do this for very long -- Alpha and MIPS in particular have
1832 problems with this. So in that situation, we fall back on an alternate
1833 implementation method. */
1834 #define NUM_UNITOP_CUTOFF 20
1836 if (num_unit_opclasses
< NUM_UNITOP_CUTOFF
)
1838 /* Merge each function unit into the unit mask attributes. */
1839 for (unit
= units
; unit
; unit
= unit
->next
)
1841 XEXP (newexp
, 0) = unit
->condexp
;
1842 XEXP (newexp
, 1) = make_numeric_value (1 << unit
->num
);
1843 unitsmask
= operate_exp (OR_OP
, unitsmask
, newexp
);
1848 /* Merge each function unit into the unit mask attributes. */
1849 for (unit
= units
; unit
; unit
= unit
->next
)
1851 XEXP (newexp
, 0) = unit
->condexp
;
1852 XEXP (newexp
, 1) = make_numeric_value (1 << unit
->num
);
1853 unitsmask
= operate_exp (ORX_OP
, unitsmask
, attr_copy_rtx (newexp
));
1857 /* Simplify the unit mask expression, encode it, and make an attribute
1858 for the function_units_used function. */
1859 unitsmask
= simplify_by_exploding (unitsmask
);
1861 if (num_unit_opclasses
< NUM_UNITOP_CUTOFF
)
1862 unitsmask
= encode_units_mask (unitsmask
);
1865 /* We can no longer encode unitsmask at compile time, so emit code to
1866 calculate it at runtime. Rather, put a marker for where we'd do
1867 the code, and actually output it in write_attr_get(). */
1868 unitsmask
= attr_rtx (FFS
, unitsmask
);
1871 make_internal_attr ("*function_units_used", unitsmask
,
1872 (ATTR_NEGATIVE_OK
| ATTR_FUNC_UNITS
));
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
= xmalloc ((num_units
+ 1) * sizeof (struct function_unit_op
**));
1877 unit_num
= xmalloc ((num_units
+ 1) * sizeof (struct function_unit
*));
1879 unit_num
[num_units
] = unit
= xmalloc (sizeof (struct function_unit
));
1880 unit
->num
= num_units
;
1881 unit
->num_opclasses
= 0;
1883 for (unit
= units
; unit
; unit
= unit
->next
)
1885 unit_num
[num_units
]->num_opclasses
+= unit
->num_opclasses
;
1886 unit_num
[unit
->num
] = unit
;
1887 unit_ops
[unit
->num
] = op_array
=
1888 xmalloc (unit
->num_opclasses
* sizeof (struct function_unit_op
*));
1890 for (op
= unit
->ops
; op
; op
= op
->next
)
1891 op_array
[op
->num
] = op
;
1894 /* Compose the array of ops for the extra unit. */
1895 unit_ops
[num_units
] = op_array
=
1896 xmalloc (unit_num
[num_units
]->num_opclasses
1897 * sizeof (struct function_unit_op
*));
1899 for (unit
= units
, i
= 0; unit
; i
+= unit
->num_opclasses
, unit
= unit
->next
)
1900 memcpy (&op_array
[i
], unit_ops
[unit
->num
],
1901 unit
->num_opclasses
* sizeof (struct function_unit_op
*));
1903 /* Compute the ready cost function for each unit by computing the
1904 condition for each non-default value. */
1905 for (u
= 0; u
<= num_units
; u
++)
1911 op_array
= unit_ops
[unit
->num
];
1912 num
= unit
->num_opclasses
;
1914 /* Sort the array of ops into increasing ready cost order. */
1915 for (i
= 0; i
< num
; i
++)
1916 for (j
= num
- 1; j
> i
; j
--)
1917 if (op_array
[j
- 1]->ready
< op_array
[j
]->ready
)
1920 op_array
[j
] = op_array
[j
- 1];
1921 op_array
[j
- 1] = op
;
1924 /* Determine how many distinct non-default ready cost values there
1925 are. We use a default ready cost value of 1. */
1926 nvalues
= 0; value
= 1;
1927 for (i
= num
- 1; i
>= 0; i
--)
1928 if (op_array
[i
]->ready
> value
)
1930 value
= op_array
[i
]->ready
;
1935 readycost
= make_numeric_value (1);
1938 /* Construct the ready cost expression as a COND of each value from
1939 the largest to the smallest. */
1940 readycost
= rtx_alloc (COND
);
1941 XVEC (readycost
, 0) = rtvec_alloc (nvalues
* 2);
1942 XEXP (readycost
, 1) = make_numeric_value (1);
1946 value
= op_array
[0]->ready
;
1947 for (i
= 0; i
< num
; i
++)
1952 else if (op
->ready
== value
)
1953 orexp
= insert_right_side (IOR
, orexp
, op
->condexp
, -2, -2);
1956 XVECEXP (readycost
, 0, nvalues
* 2) = orexp
;
1957 XVECEXP (readycost
, 0, nvalues
* 2 + 1)
1958 = make_numeric_value (value
);
1961 orexp
= op
->condexp
;
1964 XVECEXP (readycost
, 0, nvalues
* 2) = orexp
;
1965 XVECEXP (readycost
, 0, nvalues
* 2 + 1) = make_numeric_value (value
);
1970 rtx max_blockage
= 0, min_blockage
= 0;
1972 /* Simplify the readycost expression by only considering insns
1973 that use the unit. */
1974 readycost
= simplify_knowing (readycost
, unit
->condexp
);
1976 /* Determine the blockage cost the executing insn (E) given
1977 the candidate insn (C). This is the maximum of the issue
1978 delay, the pipeline delay, and the simultaneity constraint.
1979 Each function_unit_op represents the characteristics of the
1980 candidate insn, so in the expressions below, C is a known
1981 term and E is an unknown term.
1983 We compute the blockage cost for each E for every possible C.
1984 Thus OP represents E, and READYCOST is a list of values for
1987 The issue delay function for C is op->issue_exp and is used to
1988 write the `<name>_unit_conflict_cost' function. Symbolically
1989 this is "ISSUE-DELAY (E,C)".
1991 The pipeline delay results form the FIFO constraint on the
1992 function unit and is "READY-COST (E) + 1 - READY-COST (C)".
1994 The simultaneity constraint is based on how long it takes to
1995 fill the unit given the minimum issue delay. FILL-TIME is the
1996 constant "MIN (ISSUE-DELAY (*,*)) * (SIMULTANEITY - 1)", and
1997 the simultaneity constraint is "READY-COST (E) - FILL-TIME"
1998 if SIMULTANEITY is nonzero and zero otherwise.
2000 Thus, BLOCKAGE (E,C) when SIMULTANEITY is zero is
2002 MAX (ISSUE-DELAY (E,C),
2003 READY-COST (E) - (READY-COST (C) - 1))
2007 MAX (ISSUE-DELAY (E,C),
2008 READY-COST (E) - (READY-COST (C) - 1),
2009 READY-COST (E) - FILL-TIME)
2011 The `<name>_unit_blockage' function is computed by determining
2012 this value for each candidate insn. As these values are
2013 computed, we also compute the upper and lower bounds for
2014 BLOCKAGE (E,*). These are combined to form the function
2015 `<name>_unit_blockage_range'. Finally, the maximum blockage
2016 cost, MAX (BLOCKAGE (*,*)), is computed. */
2018 for (op
= unit
->ops
; op
; op
= op
->next
)
2020 rtx blockage
= op
->issue_exp
;
2021 blockage
= simplify_knowing (blockage
, unit
->condexp
);
2023 /* Add this op's contribution to MAX (BLOCKAGE (E,*)) and
2024 MIN (BLOCKAGE (E,*)). */
2025 if (max_blockage
== 0)
2026 max_blockage
= min_blockage
= blockage
;
2030 = simplify_knowing (operate_exp (MAX_OP
, max_blockage
,
2034 = simplify_knowing (operate_exp (MIN_OP
, min_blockage
,
2039 /* Make an attribute for use in the blockage function. */
2040 str
= attr_printf ((strlen (unit
->name
) + sizeof "*_block_"
2042 "*%s_block_%d", unit
->name
, op
->num
);
2043 make_internal_attr (str
, blockage
, ATTR_SPECIAL
);
2046 /* Record MAX (BLOCKAGE (*,*)). */
2049 unit
->max_blockage
= max_attr_value (max_blockage
, &unknown
);
2052 /* See if the upper and lower bounds of BLOCKAGE (E,*) are the
2053 same. If so, the blockage function carries no additional
2054 information and is not written. */
2055 newexp
= operate_exp (EQ_OP
, max_blockage
, min_blockage
);
2056 newexp
= simplify_knowing (newexp
, unit
->condexp
);
2057 unit
->needs_blockage_function
2058 = (GET_CODE (newexp
) != CONST_STRING
2059 || atoi (XSTR (newexp
, 0)) != 1);
2061 /* If the all values of BLOCKAGE (E,C) have the same value,
2062 neither blockage function is written. */
2063 unit
->needs_range_function
2064 = (unit
->needs_blockage_function
2065 || GET_CODE (max_blockage
) != CONST_STRING
);
2067 if (unit
->needs_range_function
)
2069 /* Compute the blockage range function and make an attribute
2070 for writing its value. */
2071 newexp
= operate_exp (RANGE_OP
, min_blockage
, max_blockage
);
2072 newexp
= simplify_knowing (newexp
, unit
->condexp
);
2074 str
= attr_printf ((strlen (unit
->name
)
2075 + sizeof "*_unit_blockage_range"),
2076 "*%s_unit_blockage_range", unit
->name
);
2077 make_internal_attr (str
, newexp
, (ATTR_STATIC
|ATTR_BLOCKAGE
|ATTR_UNSIGNED
));
2080 str
= attr_printf (strlen (unit
->name
) + sizeof "*_unit_ready_cost",
2081 "*%s_unit_ready_cost", unit
->name
);
2082 make_internal_attr (str
, readycost
, ATTR_STATIC
);
2086 /* Make an attribute for the ready_cost function. Simplifying
2087 further with simplify_by_exploding doesn't win. */
2088 str
= "*result_ready_cost";
2089 make_internal_attr (str
, readycost
, ATTR_NONE
);
2093 /* For each unit that requires a conflict cost function, make an attribute
2094 that maps insns to the operation number. */
2095 for (unit
= units
; unit
; unit
= unit
->next
)
2099 if (! unit
->needs_conflict_function
2100 && ! unit
->needs_blockage_function
)
2103 caseexp
= rtx_alloc (COND
);
2104 XVEC (caseexp
, 0) = rtvec_alloc ((unit
->num_opclasses
- 1) * 2);
2106 for (op
= unit
->ops
; op
; op
= op
->next
)
2108 /* Make our adjustment to the COND being computed. If we are the
2109 last operation class, place our values into the default of the
2111 if (op
->num
== unit
->num_opclasses
- 1)
2113 XEXP (caseexp
, 1) = make_numeric_value (op
->num
);
2117 XVECEXP (caseexp
, 0, op
->num
* 2) = op
->condexp
;
2118 XVECEXP (caseexp
, 0, op
->num
* 2 + 1)
2119 = make_numeric_value (op
->num
);
2123 /* Simplifying caseexp with simplify_by_exploding doesn't win. */
2124 str
= attr_printf (strlen (unit
->name
) + sizeof "*_cases",
2125 "*%s_cases", unit
->name
);
2126 make_internal_attr (str
, caseexp
, ATTR_SPECIAL
);
2130 /* Simplify EXP given KNOWN_TRUE. */
2133 simplify_knowing (rtx exp
, rtx known_true
)
2135 if (GET_CODE (exp
) != CONST_STRING
)
2137 int unknown
= 0, max
;
2138 max
= max_attr_value (exp
, &unknown
);
2141 exp
= attr_rtx (IF_THEN_ELSE
, known_true
, exp
,
2142 make_numeric_value (max
));
2143 exp
= simplify_by_exploding (exp
);
2149 /* Translate the CONST_STRING expressions in X to change the encoding of
2150 value. On input, the value is a bitmask with a one bit for each unit
2151 used; on output, the value is the unit number (zero based) if one
2152 and only one unit is used or the one's complement of the bitmask. */
2155 encode_units_mask (rtx x
)
2162 code
= GET_CODE (x
);
2167 i
= atoi (XSTR (x
, 0));
2169 /* The sign bit encodes a one's complement mask. */
2171 else if (i
!= 0 && i
== (i
& -i
))
2172 /* Only one bit is set, so yield that unit number. */
2173 for (j
= 0; (i
>>= 1) != 0; j
++)
2177 return attr_rtx (CONST_STRING
, attr_printf (MAX_DIGITS
, "%d", j
));
2195 /* Compare the elements. If any pair of corresponding elements
2196 fail to match, return 0 for the whole things. */
2198 fmt
= GET_RTX_FORMAT (code
);
2199 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
2205 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
2206 XVECEXP (x
, i
, j
) = encode_units_mask (XVECEXP (x
, i
, j
));
2210 XEXP (x
, i
) = encode_units_mask (XEXP (x
, i
));
2217 /* Once all attributes and insns have been read and checked, we construct for
2218 each attribute value a list of all the insns that have that value for
2222 fill_attr (struct attr_desc
*attr
)
2224 struct attr_value
*av
;
2225 struct insn_ent
*ie
;
2226 struct insn_def
*id
;
2230 /* Don't fill constant attributes. The value is independent of
2231 any particular insn. */
2235 for (id
= defs
; id
; id
= id
->next
)
2237 /* If no value is specified for this insn for this attribute, use the
2240 if (XVEC (id
->def
, id
->vec_idx
))
2241 for (i
= 0; i
< XVECLEN (id
->def
, id
->vec_idx
); i
++)
2242 if (! strcmp (XSTR (XEXP (XVECEXP (id
->def
, id
->vec_idx
, i
), 0), 0),
2244 value
= XEXP (XVECEXP (id
->def
, id
->vec_idx
, i
), 1);
2247 av
= attr
->default_val
;
2249 av
= get_attr_value (value
, attr
, id
->insn_code
);
2251 ie
= oballoc (sizeof (struct insn_ent
));
2252 ie
->insn_code
= id
->insn_code
;
2253 ie
->insn_index
= id
->insn_code
;
2254 insert_insn_ent (av
, ie
);
2258 /* Given an expression EXP, see if it is a COND or IF_THEN_ELSE that has a
2259 test that checks relative positions of insns (uses MATCH_DUP or PC).
2260 If so, replace it with what is obtained by passing the expression to
2261 ADDRESS_FN. If not but it is a COND or IF_THEN_ELSE, call this routine
2262 recursively on each value (including the default value). Otherwise,
2263 return the value returned by NO_ADDRESS_FN applied to EXP. */
2266 substitute_address (rtx exp
, rtx (*no_address_fn
) (rtx
),
2267 rtx (*address_fn
) (rtx
))
2272 if (GET_CODE (exp
) == COND
)
2274 /* See if any tests use addresses. */
2276 for (i
= 0; i
< XVECLEN (exp
, 0); i
+= 2)
2277 walk_attr_value (XVECEXP (exp
, 0, i
));
2280 return (*address_fn
) (exp
);
2282 /* Make a new copy of this COND, replacing each element. */
2283 newexp
= rtx_alloc (COND
);
2284 XVEC (newexp
, 0) = rtvec_alloc (XVECLEN (exp
, 0));
2285 for (i
= 0; i
< XVECLEN (exp
, 0); i
+= 2)
2287 XVECEXP (newexp
, 0, i
) = XVECEXP (exp
, 0, i
);
2288 XVECEXP (newexp
, 0, i
+ 1)
2289 = substitute_address (XVECEXP (exp
, 0, i
+ 1),
2290 no_address_fn
, address_fn
);
2293 XEXP (newexp
, 1) = substitute_address (XEXP (exp
, 1),
2294 no_address_fn
, address_fn
);
2299 else if (GET_CODE (exp
) == IF_THEN_ELSE
)
2302 walk_attr_value (XEXP (exp
, 0));
2304 return (*address_fn
) (exp
);
2306 return attr_rtx (IF_THEN_ELSE
,
2307 substitute_address (XEXP (exp
, 0),
2308 no_address_fn
, address_fn
),
2309 substitute_address (XEXP (exp
, 1),
2310 no_address_fn
, address_fn
),
2311 substitute_address (XEXP (exp
, 2),
2312 no_address_fn
, address_fn
));
2315 return (*no_address_fn
) (exp
);
2318 /* Make new attributes from the `length' attribute. The following are made,
2319 each corresponding to a function called from `shorten_branches' or
2322 *insn_default_length This is the length of the insn to be returned
2323 by `get_attr_length' before `shorten_branches'
2324 has been called. In each case where the length
2325 depends on relative addresses, the largest
2326 possible is used. This routine is also used
2327 to compute the initial size of the insn.
2329 *insn_variable_length_p This returns 1 if the insn's length depends
2330 on relative addresses, zero otherwise.
2332 *insn_current_length This is only called when it is known that the
2333 insn has a variable length and returns the
2334 current length, based on relative addresses.
2338 make_length_attrs (void)
2340 static const char *const new_names
[] = {"*insn_default_length",
2341 "*insn_variable_length_p",
2342 "*insn_current_length"};
2343 static rtx (*const no_address_fn
[]) (rtx
) = {identity_fn
, zero_fn
, zero_fn
};
2344 static rtx (*const address_fn
[]) (rtx
) = {max_fn
, one_fn
, identity_fn
};
2346 struct attr_desc
*length_attr
, *new_attr
;
2347 struct attr_value
*av
, *new_av
;
2348 struct insn_ent
*ie
, *new_ie
;
2350 /* See if length attribute is defined. If so, it must be numeric. Make
2351 it special so we don't output anything for it. */
2352 length_attr
= find_attr ("length", 0);
2353 if (length_attr
== 0)
2356 if (! length_attr
->is_numeric
)
2357 fatal ("length attribute must be numeric");
2359 length_attr
->is_const
= 0;
2360 length_attr
->is_special
= 1;
2362 /* Make each new attribute, in turn. */
2363 for (i
= 0; i
< ARRAY_SIZE (new_names
); i
++)
2365 make_internal_attr (new_names
[i
],
2366 substitute_address (length_attr
->default_val
->value
,
2367 no_address_fn
[i
], address_fn
[i
]),
2369 new_attr
= find_attr (new_names
[i
], 0);
2370 for (av
= length_attr
->first_value
; av
; av
= av
->next
)
2371 for (ie
= av
->first_insn
; ie
; ie
= ie
->next
)
2373 new_av
= get_attr_value (substitute_address (av
->value
,
2376 new_attr
, ie
->insn_code
);
2377 new_ie
= oballoc (sizeof (struct insn_ent
));
2378 new_ie
->insn_code
= ie
->insn_code
;
2379 new_ie
->insn_index
= ie
->insn_index
;
2380 insert_insn_ent (new_av
, new_ie
);
2385 /* Utility functions called from above routine. */
2388 identity_fn (rtx exp
)
2394 zero_fn (rtx exp ATTRIBUTE_UNUSED
)
2396 return make_numeric_value (0);
2400 one_fn (rtx exp ATTRIBUTE_UNUSED
)
2402 return make_numeric_value (1);
2409 return make_numeric_value (max_attr_value (exp
, &unknown
));
2413 write_length_unit_log (void)
2415 struct attr_desc
*length_attr
= find_attr ("length", 0);
2416 struct attr_value
*av
;
2417 struct insn_ent
*ie
;
2418 unsigned int length_unit_log
, length_or
;
2421 if (length_attr
== 0)
2423 length_or
= or_attr_value (length_attr
->default_val
->value
, &unknown
);
2424 for (av
= length_attr
->first_value
; av
; av
= av
->next
)
2425 for (ie
= av
->first_insn
; ie
; ie
= ie
->next
)
2426 length_or
|= or_attr_value (av
->value
, &unknown
);
2429 length_unit_log
= 0;
2432 length_or
= ~length_or
;
2433 for (length_unit_log
= 0; length_or
& 1; length_or
>>= 1)
2436 printf ("int length_unit_log = %u;\n", length_unit_log
);
2439 /* Take a COND expression and see if any of the conditions in it can be
2440 simplified. If any are known true or known false for the particular insn
2441 code, the COND can be further simplified.
2443 Also call ourselves on any COND operations that are values of this COND.
2445 We do not modify EXP; rather, we make and return a new rtx. */
2448 simplify_cond (rtx exp
, int insn_code
, int insn_index
)
2451 /* We store the desired contents here,
2452 then build a new expression if they don't match EXP. */
2453 rtx defval
= XEXP (exp
, 1);
2454 rtx new_defval
= XEXP (exp
, 1);
2455 int len
= XVECLEN (exp
, 0);
2456 rtx
*tests
= xmalloc (len
* sizeof (rtx
));
2460 /* This lets us free all storage allocated below, if appropriate. */
2461 obstack_finish (rtl_obstack
);
2463 memcpy (tests
, XVEC (exp
, 0)->elem
, len
* sizeof (rtx
));
2465 /* See if default value needs simplification. */
2466 if (GET_CODE (defval
) == COND
)
2467 new_defval
= simplify_cond (defval
, insn_code
, insn_index
);
2469 /* Simplify the subexpressions, and see what tests we can get rid of. */
2471 for (i
= 0; i
< len
; i
+= 2)
2473 rtx newtest
, newval
;
2475 /* Simplify this test. */
2476 newtest
= simplify_test_exp_in_temp (tests
[i
], insn_code
, insn_index
);
2479 newval
= tests
[i
+ 1];
2480 /* See if this value may need simplification. */
2481 if (GET_CODE (newval
) == COND
)
2482 newval
= simplify_cond (newval
, insn_code
, insn_index
);
2484 /* Look for ways to delete or combine this test. */
2485 if (newtest
== true_rtx
)
2487 /* If test is true, make this value the default
2488 and discard this + any following tests. */
2490 defval
= tests
[i
+ 1];
2491 new_defval
= newval
;
2494 else if (newtest
== false_rtx
)
2496 /* If test is false, discard it and its value. */
2497 for (j
= i
; j
< len
- 2; j
++)
2498 tests
[j
] = tests
[j
+ 2];
2502 else if (i
> 0 && attr_equal_p (newval
, tests
[i
- 1]))
2504 /* If this value and the value for the prev test are the same,
2508 = insert_right_side (IOR
, tests
[i
- 2], newtest
,
2509 insn_code
, insn_index
);
2511 /* Delete this test/value. */
2512 for (j
= i
; j
< len
- 2; j
++)
2513 tests
[j
] = tests
[j
+ 2];
2518 tests
[i
+ 1] = newval
;
2521 /* If the last test in a COND has the same value
2522 as the default value, that test isn't needed. */
2524 while (len
> 0 && attr_equal_p (tests
[len
- 1], new_defval
))
2527 /* See if we changed anything. */
2528 if (len
!= XVECLEN (exp
, 0) || new_defval
!= XEXP (exp
, 1))
2531 for (i
= 0; i
< len
; i
++)
2532 if (! attr_equal_p (tests
[i
], XVECEXP (exp
, 0, i
)))
2540 if (GET_CODE (defval
) == COND
)
2541 ret
= simplify_cond (defval
, insn_code
, insn_index
);
2549 rtx newexp
= rtx_alloc (COND
);
2551 XVEC (newexp
, 0) = rtvec_alloc (len
);
2552 memcpy (XVEC (newexp
, 0)->elem
, tests
, len
* sizeof (rtx
));
2553 XEXP (newexp
, 1) = new_defval
;
2560 /* Remove an insn entry from an attribute value. */
2563 remove_insn_ent (struct attr_value
*av
, struct insn_ent
*ie
)
2565 struct insn_ent
*previe
;
2567 if (av
->first_insn
== ie
)
2568 av
->first_insn
= ie
->next
;
2571 for (previe
= av
->first_insn
; previe
->next
!= ie
; previe
= previe
->next
)
2573 previe
->next
= ie
->next
;
2577 if (ie
->insn_code
== -1)
2578 av
->has_asm_insn
= 0;
2583 /* Insert an insn entry in an attribute value list. */
2586 insert_insn_ent (struct attr_value
*av
, struct insn_ent
*ie
)
2588 ie
->next
= av
->first_insn
;
2589 av
->first_insn
= ie
;
2591 if (ie
->insn_code
== -1)
2592 av
->has_asm_insn
= 1;
2597 /* This is a utility routine to take an expression that is a tree of either
2598 AND or IOR expressions and insert a new term. The new term will be
2599 inserted at the right side of the first node whose code does not match
2600 the root. A new node will be created with the root's code. Its left
2601 side will be the old right side and its right side will be the new
2604 If the `term' is itself a tree, all its leaves will be inserted. */
2607 insert_right_side (enum rtx_code code
, rtx exp
, rtx term
, int insn_code
, int insn_index
)
2611 /* Avoid consing in some special cases. */
2612 if (code
== AND
&& term
== true_rtx
)
2614 if (code
== AND
&& term
== false_rtx
)
2616 if (code
== AND
&& exp
== true_rtx
)
2618 if (code
== AND
&& exp
== false_rtx
)
2620 if (code
== IOR
&& term
== true_rtx
)
2622 if (code
== IOR
&& term
== false_rtx
)
2624 if (code
== IOR
&& exp
== true_rtx
)
2626 if (code
== IOR
&& exp
== false_rtx
)
2628 if (attr_equal_p (exp
, term
))
2631 if (GET_CODE (term
) == code
)
2633 exp
= insert_right_side (code
, exp
, XEXP (term
, 0),
2634 insn_code
, insn_index
);
2635 exp
= insert_right_side (code
, exp
, XEXP (term
, 1),
2636 insn_code
, insn_index
);
2641 if (GET_CODE (exp
) == code
)
2643 rtx
new = insert_right_side (code
, XEXP (exp
, 1),
2644 term
, insn_code
, insn_index
);
2645 if (new != XEXP (exp
, 1))
2646 /* Make a copy of this expression and call recursively. */
2647 newexp
= attr_rtx (code
, XEXP (exp
, 0), new);
2653 /* Insert the new term. */
2654 newexp
= attr_rtx (code
, exp
, term
);
2657 return simplify_test_exp_in_temp (newexp
, insn_code
, insn_index
);
2660 /* If we have an expression which AND's a bunch of
2661 (not (eq_attrq "alternative" "n"))
2662 terms, we may have covered all or all but one of the possible alternatives.
2663 If so, we can optimize. Similarly for IOR's of EQ_ATTR.
2665 This routine is passed an expression and either AND or IOR. It returns a
2666 bitmask indicating which alternatives are mentioned within EXP. */
2669 compute_alternative_mask (rtx exp
, enum rtx_code code
)
2672 if (GET_CODE (exp
) == code
)
2673 return compute_alternative_mask (XEXP (exp
, 0), code
)
2674 | compute_alternative_mask (XEXP (exp
, 1), code
);
2676 else if (code
== AND
&& GET_CODE (exp
) == NOT
2677 && GET_CODE (XEXP (exp
, 0)) == EQ_ATTR
2678 && XSTR (XEXP (exp
, 0), 0) == alternative_name
)
2679 string
= XSTR (XEXP (exp
, 0), 1);
2681 else if (code
== IOR
&& GET_CODE (exp
) == EQ_ATTR
2682 && XSTR (exp
, 0) == alternative_name
)
2683 string
= XSTR (exp
, 1);
2689 return 1 << (string
[0] - '0');
2690 return 1 << atoi (string
);
2693 /* Given I, a single-bit mask, return RTX to compare the `alternative'
2694 attribute with the value represented by that bit. */
2697 make_alternative_compare (int mask
)
2703 for (i
= 0; (mask
& (1 << i
)) == 0; i
++)
2706 newexp
= attr_rtx (EQ_ATTR
, alternative_name
, attr_numeral (i
));
2707 ATTR_IND_SIMPLIFIED_P (newexp
) = 1;
2712 /* If we are processing an (eq_attr "attr" "value") test, we find the value
2713 of "attr" for this insn code. From that value, we can compute a test
2714 showing when the EQ_ATTR will be true. This routine performs that
2715 computation. If a test condition involves an address, we leave the EQ_ATTR
2716 intact because addresses are only valid for the `length' attribute.
2718 EXP is the EQ_ATTR expression and VALUE is the value of that attribute
2719 for the insn corresponding to INSN_CODE and INSN_INDEX. */
2722 evaluate_eq_attr (rtx exp
, rtx value
, int insn_code
, int insn_index
)
2729 if (GET_CODE (value
) == CONST_STRING
)
2731 if (! strcmp (XSTR (value
, 0), XSTR (exp
, 1)))
2736 else if (GET_CODE (value
) == SYMBOL_REF
)
2741 if (GET_CODE (exp
) != EQ_ATTR
)
2744 if (strlen (XSTR (exp
, 0)) + strlen (XSTR (exp
, 1)) + 2 > 256)
2747 strcpy (string
, XSTR (exp
, 0));
2748 strcat (string
, "_");
2749 strcat (string
, XSTR (exp
, 1));
2750 for (p
= string
; *p
; p
++)
2753 newexp
= attr_rtx (EQ
, value
,
2754 attr_rtx (SYMBOL_REF
,
2755 attr_string (string
, strlen (string
))));
2757 else if (GET_CODE (value
) == COND
)
2759 /* We construct an IOR of all the cases for which the requested attribute
2760 value is present. Since we start with FALSE, if it is not present,
2761 FALSE will be returned.
2763 Each case is the AND of the NOT's of the previous conditions with the
2764 current condition; in the default case the current condition is TRUE.
2766 For each possible COND value, call ourselves recursively.
2768 The extra TRUE and FALSE expressions will be eliminated by another
2769 call to the simplification routine. */
2774 if (current_alternative_string
)
2775 clear_struct_flag (value
);
2777 for (i
= 0; i
< XVECLEN (value
, 0); i
+= 2)
2779 rtx
this = simplify_test_exp_in_temp (XVECEXP (value
, 0, i
),
2780 insn_code
, insn_index
);
2782 SIMPLIFY_ALTERNATIVE (this);
2784 right
= insert_right_side (AND
, andexp
, this,
2785 insn_code
, insn_index
);
2786 right
= insert_right_side (AND
, right
,
2787 evaluate_eq_attr (exp
,
2790 insn_code
, insn_index
),
2791 insn_code
, insn_index
);
2792 orexp
= insert_right_side (IOR
, orexp
, right
,
2793 insn_code
, insn_index
);
2795 /* Add this condition into the AND expression. */
2796 newexp
= attr_rtx (NOT
, this);
2797 andexp
= insert_right_side (AND
, andexp
, newexp
,
2798 insn_code
, insn_index
);
2801 /* Handle the default case. */
2802 right
= insert_right_side (AND
, andexp
,
2803 evaluate_eq_attr (exp
, XEXP (value
, 1),
2804 insn_code
, insn_index
),
2805 insn_code
, insn_index
);
2806 newexp
= insert_right_side (IOR
, orexp
, right
, insn_code
, insn_index
);
2811 /* If uses an address, must return original expression. But set the
2812 ATTR_IND_SIMPLIFIED_P bit so we don't try to simplify it again. */
2815 walk_attr_value (newexp
);
2819 /* This had `&& current_alternative_string', which seems to be wrong. */
2820 if (! ATTR_IND_SIMPLIFIED_P (exp
))
2821 return copy_rtx_unchanging (exp
);
2828 /* This routine is called when an AND of a term with a tree of AND's is
2829 encountered. If the term or its complement is present in the tree, it
2830 can be replaced with TRUE or FALSE, respectively.
2832 Note that (eq_attr "att" "v1") and (eq_attr "att" "v2") cannot both
2833 be true and hence are complementary.
2835 There is one special case: If we see
2836 (and (not (eq_attr "att" "v1"))
2837 (eq_attr "att" "v2"))
2838 this can be replaced by (eq_attr "att" "v2"). To do this we need to
2839 replace the term, not anything in the AND tree. So we pass a pointer to
2843 simplify_and_tree (rtx exp
, rtx
*pterm
, int insn_code
, int insn_index
)
2848 int left_eliminates_term
, right_eliminates_term
;
2850 if (GET_CODE (exp
) == AND
)
2852 left
= simplify_and_tree (XEXP (exp
, 0), pterm
, insn_code
, insn_index
);
2853 right
= simplify_and_tree (XEXP (exp
, 1), pterm
, insn_code
, insn_index
);
2854 if (left
!= XEXP (exp
, 0) || right
!= XEXP (exp
, 1))
2856 newexp
= attr_rtx (GET_CODE (exp
), left
, right
);
2858 exp
= simplify_test_exp_in_temp (newexp
, insn_code
, insn_index
);
2862 else if (GET_CODE (exp
) == IOR
)
2864 /* For the IOR case, we do the same as above, except that we can
2865 only eliminate `term' if both sides of the IOR would do so. */
2867 left
= simplify_and_tree (XEXP (exp
, 0), &temp
, insn_code
, insn_index
);
2868 left_eliminates_term
= (temp
== true_rtx
);
2871 right
= simplify_and_tree (XEXP (exp
, 1), &temp
, insn_code
, insn_index
);
2872 right_eliminates_term
= (temp
== true_rtx
);
2874 if (left_eliminates_term
&& right_eliminates_term
)
2877 if (left
!= XEXP (exp
, 0) || right
!= XEXP (exp
, 1))
2879 newexp
= attr_rtx (GET_CODE (exp
), left
, right
);
2881 exp
= simplify_test_exp_in_temp (newexp
, insn_code
, insn_index
);
2885 /* Check for simplifications. Do some extra checking here since this
2886 routine is called so many times. */
2891 else if (GET_CODE (exp
) == NOT
&& XEXP (exp
, 0) == *pterm
)
2894 else if (GET_CODE (*pterm
) == NOT
&& exp
== XEXP (*pterm
, 0))
2897 else if (GET_CODE (exp
) == EQ_ATTR
&& GET_CODE (*pterm
) == EQ_ATTR
)
2899 if (XSTR (exp
, 0) != XSTR (*pterm
, 0))
2902 if (! strcmp (XSTR (exp
, 1), XSTR (*pterm
, 1)))
2908 else if (GET_CODE (*pterm
) == EQ_ATTR
&& GET_CODE (exp
) == NOT
2909 && GET_CODE (XEXP (exp
, 0)) == EQ_ATTR
)
2911 if (XSTR (*pterm
, 0) != XSTR (XEXP (exp
, 0), 0))
2914 if (! strcmp (XSTR (*pterm
, 1), XSTR (XEXP (exp
, 0), 1)))
2920 else if (GET_CODE (exp
) == EQ_ATTR
&& GET_CODE (*pterm
) == NOT
2921 && GET_CODE (XEXP (*pterm
, 0)) == EQ_ATTR
)
2923 if (XSTR (exp
, 0) != XSTR (XEXP (*pterm
, 0), 0))
2926 if (! strcmp (XSTR (exp
, 1), XSTR (XEXP (*pterm
, 0), 1)))
2932 else if (GET_CODE (exp
) == NOT
&& GET_CODE (*pterm
) == NOT
)
2934 if (attr_equal_p (XEXP (exp
, 0), XEXP (*pterm
, 0)))
2938 else if (GET_CODE (exp
) == NOT
)
2940 if (attr_equal_p (XEXP (exp
, 0), *pterm
))
2944 else if (GET_CODE (*pterm
) == NOT
)
2946 if (attr_equal_p (XEXP (*pterm
, 0), exp
))
2950 else if (attr_equal_p (exp
, *pterm
))
2956 /* Similar to `simplify_and_tree', but for IOR trees. */
2959 simplify_or_tree (rtx exp
, rtx
*pterm
, int insn_code
, int insn_index
)
2964 int left_eliminates_term
, right_eliminates_term
;
2966 if (GET_CODE (exp
) == IOR
)
2968 left
= simplify_or_tree (XEXP (exp
, 0), pterm
, insn_code
, insn_index
);
2969 right
= simplify_or_tree (XEXP (exp
, 1), pterm
, insn_code
, insn_index
);
2970 if (left
!= XEXP (exp
, 0) || right
!= XEXP (exp
, 1))
2972 newexp
= attr_rtx (GET_CODE (exp
), left
, right
);
2974 exp
= simplify_test_exp_in_temp (newexp
, insn_code
, insn_index
);
2978 else if (GET_CODE (exp
) == AND
)
2980 /* For the AND case, we do the same as above, except that we can
2981 only eliminate `term' if both sides of the AND would do so. */
2983 left
= simplify_or_tree (XEXP (exp
, 0), &temp
, insn_code
, insn_index
);
2984 left_eliminates_term
= (temp
== false_rtx
);
2987 right
= simplify_or_tree (XEXP (exp
, 1), &temp
, insn_code
, insn_index
);
2988 right_eliminates_term
= (temp
== false_rtx
);
2990 if (left_eliminates_term
&& right_eliminates_term
)
2993 if (left
!= XEXP (exp
, 0) || right
!= XEXP (exp
, 1))
2995 newexp
= attr_rtx (GET_CODE (exp
), left
, right
);
2997 exp
= simplify_test_exp_in_temp (newexp
, insn_code
, insn_index
);
3001 if (attr_equal_p (exp
, *pterm
))
3004 else if (GET_CODE (exp
) == NOT
&& attr_equal_p (XEXP (exp
, 0), *pterm
))
3007 else if (GET_CODE (*pterm
) == NOT
&& attr_equal_p (XEXP (*pterm
, 0), exp
))
3010 else if (GET_CODE (*pterm
) == EQ_ATTR
&& GET_CODE (exp
) == NOT
3011 && GET_CODE (XEXP (exp
, 0)) == EQ_ATTR
3012 && XSTR (*pterm
, 0) == XSTR (XEXP (exp
, 0), 0))
3015 else if (GET_CODE (exp
) == EQ_ATTR
&& GET_CODE (*pterm
) == NOT
3016 && GET_CODE (XEXP (*pterm
, 0)) == EQ_ATTR
3017 && XSTR (exp
, 0) == XSTR (XEXP (*pterm
, 0), 0))
3023 /* Compute approximate cost of the expression. Used to decide whether
3024 expression is cheap enough for inline. */
3026 attr_rtx_cost (rtx x
)
3032 code
= GET_CODE (x
);
3041 /* Alternatives don't result into function call. */
3042 if (!strcmp (XSTR (x
, 0), "alternative"))
3049 const char *fmt
= GET_RTX_FORMAT (code
);
3050 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
3056 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
3057 cost
+= attr_rtx_cost (XVECEXP (x
, i
, j
));
3060 cost
+= attr_rtx_cost (XEXP (x
, i
));
3070 /* Simplify test expression and use temporary obstack in order to avoid
3071 memory bloat. Use ATTR_IND_SIMPLIFIED to avoid unnecessary simplifications
3072 and avoid unnecessary copying if possible. */
3075 simplify_test_exp_in_temp (rtx exp
, int insn_code
, int insn_index
)
3078 struct obstack
*old
;
3079 if (ATTR_IND_SIMPLIFIED_P (exp
))
3082 rtl_obstack
= temp_obstack
;
3083 x
= simplify_test_exp (exp
, insn_code
, insn_index
);
3085 if (x
== exp
|| rtl_obstack
== temp_obstack
)
3087 return attr_copy_rtx (x
);
3090 /* Given an expression, see if it can be simplified for a particular insn
3091 code based on the values of other attributes being tested. This can
3092 eliminate nested get_attr_... calls.
3094 Note that if an endless recursion is specified in the patterns, the
3095 optimization will loop. However, it will do so in precisely the cases where
3096 an infinite recursion loop could occur during compilation. It's better that
3100 simplify_test_exp (rtx exp
, int insn_code
, int insn_index
)
3103 struct attr_desc
*attr
;
3104 struct attr_value
*av
;
3105 struct insn_ent
*ie
;
3109 /* Don't re-simplify something we already simplified. */
3110 if (ATTR_IND_SIMPLIFIED_P (exp
) || ATTR_CURR_SIMPLIFIED_P (exp
))
3113 switch (GET_CODE (exp
))
3116 left
= SIMPLIFY_TEST_EXP (XEXP (exp
, 0), insn_code
, insn_index
);
3117 SIMPLIFY_ALTERNATIVE (left
);
3118 if (left
== false_rtx
)
3120 right
= SIMPLIFY_TEST_EXP (XEXP (exp
, 1), insn_code
, insn_index
);
3121 SIMPLIFY_ALTERNATIVE (right
);
3122 if (left
== false_rtx
)
3125 /* If either side is an IOR and we have (eq_attr "alternative" ..")
3126 present on both sides, apply the distributive law since this will
3127 yield simplifications. */
3128 if ((GET_CODE (left
) == IOR
|| GET_CODE (right
) == IOR
)
3129 && compute_alternative_mask (left
, IOR
)
3130 && compute_alternative_mask (right
, IOR
))
3132 if (GET_CODE (left
) == IOR
)
3139 newexp
= attr_rtx (IOR
,
3140 attr_rtx (AND
, left
, XEXP (right
, 0)),
3141 attr_rtx (AND
, left
, XEXP (right
, 1)));
3143 return SIMPLIFY_TEST_EXP (newexp
, insn_code
, insn_index
);
3146 /* Try with the term on both sides. */
3147 right
= simplify_and_tree (right
, &left
, insn_code
, insn_index
);
3148 if (left
== XEXP (exp
, 0) && right
== XEXP (exp
, 1))
3149 left
= simplify_and_tree (left
, &right
, insn_code
, insn_index
);
3151 if (left
== false_rtx
|| right
== false_rtx
)
3153 else if (left
== true_rtx
)
3157 else if (right
== true_rtx
)
3161 /* See if all or all but one of the insn's alternatives are specified
3162 in this tree. Optimize if so. */
3164 else if (insn_code
>= 0
3165 && (GET_CODE (left
) == AND
3166 || (GET_CODE (left
) == NOT
3167 && GET_CODE (XEXP (left
, 0)) == EQ_ATTR
3168 && XSTR (XEXP (left
, 0), 0) == alternative_name
)
3169 || GET_CODE (right
) == AND
3170 || (GET_CODE (right
) == NOT
3171 && GET_CODE (XEXP (right
, 0)) == EQ_ATTR
3172 && XSTR (XEXP (right
, 0), 0) == alternative_name
)))
3174 i
= compute_alternative_mask (exp
, AND
);
3175 if (i
& ~insn_alternatives
[insn_code
])
3176 fatal ("invalid alternative specified for pattern number %d",
3179 /* If all alternatives are excluded, this is false. */
3180 i
^= insn_alternatives
[insn_code
];
3183 else if ((i
& (i
- 1)) == 0 && insn_alternatives
[insn_code
] > 1)
3185 /* If just one excluded, AND a comparison with that one to the
3186 front of the tree. The others will be eliminated by
3187 optimization. We do not want to do this if the insn has one
3188 alternative and we have tested none of them! */
3189 left
= make_alternative_compare (i
);
3190 right
= simplify_and_tree (exp
, &left
, insn_code
, insn_index
);
3191 newexp
= attr_rtx (AND
, left
, right
);
3193 return SIMPLIFY_TEST_EXP (newexp
, insn_code
, insn_index
);
3197 if (left
!= XEXP (exp
, 0) || right
!= XEXP (exp
, 1))
3199 newexp
= attr_rtx (AND
, left
, right
);
3200 return SIMPLIFY_TEST_EXP (newexp
, insn_code
, insn_index
);
3205 left
= SIMPLIFY_TEST_EXP (XEXP (exp
, 0), insn_code
, insn_index
);
3206 SIMPLIFY_ALTERNATIVE (left
);
3207 if (left
== true_rtx
)
3209 right
= SIMPLIFY_TEST_EXP (XEXP (exp
, 1), insn_code
, insn_index
);
3210 SIMPLIFY_ALTERNATIVE (right
);
3211 if (right
== true_rtx
)
3214 right
= simplify_or_tree (right
, &left
, insn_code
, insn_index
);
3215 if (left
== XEXP (exp
, 0) && right
== XEXP (exp
, 1))
3216 left
= simplify_or_tree (left
, &right
, insn_code
, insn_index
);
3218 if (right
== true_rtx
|| left
== true_rtx
)
3220 else if (left
== false_rtx
)
3224 else if (right
== false_rtx
)
3229 /* Test for simple cases where the distributive law is useful. I.e.,
3230 convert (ior (and (x) (y))
3236 else if (GET_CODE (left
) == AND
&& GET_CODE (right
) == AND
3237 && attr_equal_p (XEXP (left
, 0), XEXP (right
, 0)))
3239 newexp
= attr_rtx (IOR
, XEXP (left
, 1), XEXP (right
, 1));
3241 left
= XEXP (left
, 0);
3243 newexp
= attr_rtx (AND
, left
, right
);
3244 return SIMPLIFY_TEST_EXP (newexp
, insn_code
, insn_index
);
3247 /* See if all or all but one of the insn's alternatives are specified
3248 in this tree. Optimize if so. */
3250 else if (insn_code
>= 0
3251 && (GET_CODE (left
) == IOR
3252 || (GET_CODE (left
) == EQ_ATTR
3253 && XSTR (left
, 0) == alternative_name
)
3254 || GET_CODE (right
) == IOR
3255 || (GET_CODE (right
) == EQ_ATTR
3256 && XSTR (right
, 0) == alternative_name
)))
3258 i
= compute_alternative_mask (exp
, IOR
);
3259 if (i
& ~insn_alternatives
[insn_code
])
3260 fatal ("invalid alternative specified for pattern number %d",
3263 /* If all alternatives are included, this is true. */
3264 i
^= insn_alternatives
[insn_code
];
3267 else if ((i
& (i
- 1)) == 0 && insn_alternatives
[insn_code
] > 1)
3269 /* If just one excluded, IOR a comparison with that one to the
3270 front of the tree. The others will be eliminated by
3271 optimization. We do not want to do this if the insn has one
3272 alternative and we have tested none of them! */
3273 left
= make_alternative_compare (i
);
3274 right
= simplify_and_tree (exp
, &left
, insn_code
, insn_index
);
3275 newexp
= attr_rtx (IOR
, attr_rtx (NOT
, left
), right
);
3277 return SIMPLIFY_TEST_EXP (newexp
, insn_code
, insn_index
);
3281 if (left
!= XEXP (exp
, 0) || right
!= XEXP (exp
, 1))
3283 newexp
= attr_rtx (IOR
, left
, right
);
3284 return SIMPLIFY_TEST_EXP (newexp
, insn_code
, insn_index
);
3289 if (GET_CODE (XEXP (exp
, 0)) == NOT
)
3291 left
= SIMPLIFY_TEST_EXP (XEXP (XEXP (exp
, 0), 0),
3292 insn_code
, insn_index
);
3293 SIMPLIFY_ALTERNATIVE (left
);
3297 left
= SIMPLIFY_TEST_EXP (XEXP (exp
, 0), insn_code
, insn_index
);
3298 SIMPLIFY_ALTERNATIVE (left
);
3299 if (GET_CODE (left
) == NOT
)
3300 return XEXP (left
, 0);
3302 if (left
== false_rtx
)
3304 else if (left
== true_rtx
)
3307 /* Try to apply De`Morgan's laws. */
3308 else if (GET_CODE (left
) == IOR
)
3310 newexp
= attr_rtx (AND
,
3311 attr_rtx (NOT
, XEXP (left
, 0)),
3312 attr_rtx (NOT
, XEXP (left
, 1)));
3314 newexp
= SIMPLIFY_TEST_EXP (newexp
, insn_code
, insn_index
);
3316 else if (GET_CODE (left
) == AND
)
3318 newexp
= attr_rtx (IOR
,
3319 attr_rtx (NOT
, XEXP (left
, 0)),
3320 attr_rtx (NOT
, XEXP (left
, 1)));
3322 newexp
= SIMPLIFY_TEST_EXP (newexp
, insn_code
, insn_index
);
3324 else if (left
!= XEXP (exp
, 0))
3326 newexp
= attr_rtx (NOT
, left
);
3331 if (current_alternative_string
&& XSTR (exp
, 0) == alternative_name
)
3332 return (XSTR (exp
, 1) == current_alternative_string
3333 ? true_rtx
: false_rtx
);
3335 /* Look at the value for this insn code in the specified attribute.
3336 We normally can replace this comparison with the condition that
3337 would give this insn the values being tested for. */
3338 if (XSTR (exp
, 0) != alternative_name
3339 && (attr
= find_attr (XSTR (exp
, 0), 0)) != NULL
)
3340 for (av
= attr
->first_value
; av
; av
= av
->next
)
3341 for (ie
= av
->first_insn
; ie
; ie
= ie
->next
)
3342 if (ie
->insn_code
== insn_code
)
3345 x
= evaluate_eq_attr (exp
, av
->value
, insn_code
, insn_index
);
3346 x
= SIMPLIFY_TEST_EXP (x
, insn_code
, insn_index
);
3347 if (attr_rtx_cost(x
) < 20)
3356 /* We have already simplified this expression. Simplifying it again
3357 won't buy anything unless we weren't given a valid insn code
3358 to process (i.e., we are canonicalizing something.). */
3359 if (insn_code
!= -2 /* Seems wrong: && current_alternative_string. */
3360 && ! ATTR_IND_SIMPLIFIED_P (newexp
))
3361 return copy_rtx_unchanging (newexp
);
3366 /* Optimize the attribute lists by seeing if we can determine conditional
3367 values from the known values of other attributes. This will save subroutine
3368 calls during the compilation. */
3371 optimize_attrs (void)
3373 struct attr_desc
*attr
;
3374 struct attr_value
*av
;
3375 struct insn_ent
*ie
;
3378 struct attr_value_list
3380 struct attr_value
*av
;
3381 struct insn_ent
*ie
;
3382 struct attr_desc
*attr
;
3383 struct attr_value_list
*next
;
3385 struct attr_value_list
**insn_code_values
;
3386 struct attr_value_list
*ivbuf
;
3387 struct attr_value_list
*iv
;
3389 /* For each insn code, make a list of all the insn_ent's for it,
3390 for all values for all attributes. */
3392 if (num_insn_ents
== 0)
3395 /* Make 2 extra elements, for "code" values -2 and -1. */
3396 insn_code_values
= xcalloc ((insn_code_number
+ 2),
3397 sizeof (struct attr_value_list
*));
3399 /* Offset the table address so we can index by -2 or -1. */
3400 insn_code_values
+= 2;
3402 iv
= ivbuf
= xmalloc (num_insn_ents
* sizeof (struct attr_value_list
));
3404 for (i
= 0; i
< MAX_ATTRS_INDEX
; i
++)
3405 for (attr
= attrs
[i
]; attr
; attr
= attr
->next
)
3406 for (av
= attr
->first_value
; av
; av
= av
->next
)
3407 for (ie
= av
->first_insn
; ie
; ie
= ie
->next
)
3412 iv
->next
= insn_code_values
[ie
->insn_code
];
3413 insn_code_values
[ie
->insn_code
] = iv
;
3417 /* Sanity check on num_insn_ents. */
3418 if (iv
!= ivbuf
+ num_insn_ents
)
3421 /* Process one insn code at a time. */
3422 for (i
= -2; i
< insn_code_number
; i
++)
3424 /* Clear the ATTR_CURR_SIMPLIFIED_P flag everywhere relevant.
3425 We use it to mean "already simplified for this insn". */
3426 for (iv
= insn_code_values
[i
]; iv
; iv
= iv
->next
)
3427 clear_struct_flag (iv
->av
->value
);
3429 for (iv
= insn_code_values
[i
]; iv
; iv
= iv
->next
)
3431 struct obstack
*old
= rtl_obstack
;
3436 if (GET_CODE (av
->value
) != COND
)
3439 rtl_obstack
= temp_obstack
;
3441 while (GET_CODE (newexp
) == COND
)
3443 rtx newexp2
= simplify_cond (newexp
, ie
->insn_code
,
3445 if (newexp2
== newexp
)
3451 if (newexp
!= av
->value
)
3453 newexp
= attr_copy_rtx (newexp
);
3454 remove_insn_ent (av
, ie
);
3455 av
= get_attr_value (newexp
, attr
, ie
->insn_code
);
3457 insert_insn_ent (av
, ie
);
3463 free (insn_code_values
- 2);
3466 /* If EXP is a suitable expression, reorganize it by constructing an
3467 equivalent expression that is a COND with the tests being all combinations
3468 of attribute values and the values being simple constants. */
3471 simplify_by_exploding (rtx exp
)
3473 rtx list
= 0, link
, condexp
, defval
= NULL_RTX
;
3474 struct dimension
*space
;
3475 rtx
*condtest
, *condval
;
3476 int i
, j
, total
, ndim
= 0;
3477 int most_tests
, num_marks
, new_marks
;
3480 /* Locate all the EQ_ATTR expressions. */
3481 if (! find_and_mark_used_attributes (exp
, &list
, &ndim
) || ndim
== 0)
3483 unmark_used_attributes (list
, 0, 0);
3487 /* Create an attribute space from the list of used attributes. For each
3488 dimension in the attribute space, record the attribute, list of values
3489 used, and number of values used. Add members to the list of values to
3490 cover the domain of the attribute. This makes the expanded COND form
3491 order independent. */
3493 space
= xmalloc (ndim
* sizeof (struct dimension
));
3496 for (ndim
= 0; list
; ndim
++)
3498 /* Pull the first attribute value from the list and record that
3499 attribute as another dimension in the attribute space. */
3500 const char *name
= XSTR (XEXP (list
, 0), 0);
3503 if ((space
[ndim
].attr
= find_attr (name
, 0)) == 0
3504 || space
[ndim
].attr
->is_numeric
)
3506 unmark_used_attributes (list
, space
, ndim
);
3510 /* Add all remaining attribute values that refer to this attribute. */
3511 space
[ndim
].num_values
= 0;
3512 space
[ndim
].values
= 0;
3514 for (link
= list
; link
; link
= *prev
)
3515 if (! strcmp (XSTR (XEXP (link
, 0), 0), name
))
3517 space
[ndim
].num_values
++;
3518 *prev
= XEXP (link
, 1);
3519 XEXP (link
, 1) = space
[ndim
].values
;
3520 space
[ndim
].values
= link
;
3523 prev
= &XEXP (link
, 1);
3525 /* Add sufficient members to the list of values to make the list
3526 mutually exclusive and record the total size of the attribute
3528 total
*= add_values_to_cover (&space
[ndim
]);
3531 /* Sort the attribute space so that the attributes go from non-constant
3532 to constant and from most values to least values. */
3533 for (i
= 0; i
< ndim
; i
++)
3534 for (j
= ndim
- 1; j
> i
; j
--)
3535 if ((space
[j
-1].attr
->is_const
&& !space
[j
].attr
->is_const
)
3536 || space
[j
-1].num_values
< space
[j
].num_values
)
3538 struct dimension tmp
;
3540 space
[j
] = space
[j
- 1];
3544 /* Establish the initial current value. */
3545 for (i
= 0; i
< ndim
; i
++)
3546 space
[i
].current_value
= space
[i
].values
;
3548 condtest
= xmalloc (total
* sizeof (rtx
));
3549 condval
= xmalloc (total
* sizeof (rtx
));
3551 /* Expand the tests and values by iterating over all values in the
3555 condtest
[i
] = test_for_current_value (space
, ndim
);
3556 condval
[i
] = simplify_with_current_value (exp
, space
, ndim
);
3557 if (! increment_current_value (space
, ndim
))
3563 /* We are now finished with the original expression. */
3564 unmark_used_attributes (0, space
, ndim
);
3567 /* Find the most used constant value and make that the default. */
3569 for (i
= num_marks
= 0; i
< total
; i
++)
3570 if (GET_CODE (condval
[i
]) == CONST_STRING
3571 && ! ATTR_EQ_ATTR_P (condval
[i
]))
3573 /* Mark the unmarked constant value and count how many are marked. */
3574 ATTR_EQ_ATTR_P (condval
[i
]) = 1;
3575 for (j
= new_marks
= 0; j
< total
; j
++)
3576 if (GET_CODE (condval
[j
]) == CONST_STRING
3577 && ATTR_EQ_ATTR_P (condval
[j
]))
3579 if (new_marks
- num_marks
> most_tests
)
3581 most_tests
= new_marks
- num_marks
;
3582 defval
= condval
[i
];
3584 num_marks
= new_marks
;
3586 /* Clear all the marks. */
3587 for (i
= 0; i
< total
; i
++)
3588 ATTR_EQ_ATTR_P (condval
[i
]) = 0;
3590 /* Give up if nothing is constant. */
3594 /* If all values are the default, use that. */
3595 else if (total
== most_tests
)
3598 /* Make a COND with the most common constant value the default. (A more
3599 complex method where tests with the same value were combined didn't
3600 seem to improve things.) */
3603 condexp
= rtx_alloc (COND
);
3604 XVEC (condexp
, 0) = rtvec_alloc ((total
- most_tests
) * 2);
3605 XEXP (condexp
, 1) = defval
;
3606 for (i
= j
= 0; i
< total
; i
++)
3607 if (condval
[i
] != defval
)
3609 XVECEXP (condexp
, 0, 2 * j
) = condtest
[i
];
3610 XVECEXP (condexp
, 0, 2 * j
+ 1) = condval
[i
];
3620 /* Set the ATTR_EQ_ATTR_P flag for all EQ_ATTR expressions in EXP and
3621 verify that EXP can be simplified to a constant term if all the EQ_ATTR
3622 tests have known value. */
3625 find_and_mark_used_attributes (rtx exp
, rtx
*terms
, int *nterms
)
3629 switch (GET_CODE (exp
))
3632 if (! ATTR_EQ_ATTR_P (exp
))
3634 rtx link
= rtx_alloc (EXPR_LIST
);
3635 XEXP (link
, 0) = exp
;
3636 XEXP (link
, 1) = *terms
;
3639 ATTR_EQ_ATTR_P (exp
) = 1;
3648 if (! find_and_mark_used_attributes (XEXP (exp
, 2), terms
, nterms
))
3652 if (! find_and_mark_used_attributes (XEXP (exp
, 1), terms
, nterms
))
3655 if (! find_and_mark_used_attributes (XEXP (exp
, 0), terms
, nterms
))
3660 for (i
= 0; i
< XVECLEN (exp
, 0); i
++)
3661 if (! find_and_mark_used_attributes (XVECEXP (exp
, 0, i
), terms
, nterms
))
3663 if (! find_and_mark_used_attributes (XEXP (exp
, 1), terms
, nterms
))
3672 /* Clear the ATTR_EQ_ATTR_P flag in all EQ_ATTR expressions on LIST and
3673 in the values of the NDIM-dimensional attribute space SPACE. */
3676 unmark_used_attributes (rtx list
, struct dimension
*space
, int ndim
)
3681 for (i
= 0; i
< ndim
; i
++)
3682 unmark_used_attributes (space
[i
].values
, 0, 0);
3684 for (link
= list
; link
; link
= XEXP (link
, 1))
3686 exp
= XEXP (link
, 0);
3687 if (GET_CODE (exp
) == EQ_ATTR
)
3688 ATTR_EQ_ATTR_P (exp
) = 0;
3692 /* Update the attribute dimension DIM so that all values of the attribute
3693 are tested. Return the updated number of values. */
3696 add_values_to_cover (struct dimension
*dim
)
3698 struct attr_value
*av
;
3699 rtx exp
, link
, *prev
;
3702 for (av
= dim
->attr
->first_value
; av
; av
= av
->next
)
3703 if (GET_CODE (av
->value
) == CONST_STRING
)
3706 if (nalt
< dim
->num_values
)
3708 else if (nalt
== dim
->num_values
)
3711 else if (nalt
* 2 < dim
->num_values
* 3)
3713 /* Most all the values of the attribute are used, so add all the unused
3715 prev
= &dim
->values
;
3716 for (link
= dim
->values
; link
; link
= *prev
)
3717 prev
= &XEXP (link
, 1);
3719 for (av
= dim
->attr
->first_value
; av
; av
= av
->next
)
3720 if (GET_CODE (av
->value
) == CONST_STRING
)
3722 exp
= attr_eq (dim
->attr
->name
, XSTR (av
->value
, 0));
3723 if (ATTR_EQ_ATTR_P (exp
))
3726 link
= rtx_alloc (EXPR_LIST
);
3727 XEXP (link
, 0) = exp
;
3730 prev
= &XEXP (link
, 1);
3732 dim
->num_values
= nalt
;
3736 rtx orexp
= false_rtx
;
3738 /* Very few values are used, so compute a mutually exclusive
3739 expression. (We could do this for numeric values if that becomes
3741 prev
= &dim
->values
;
3742 for (link
= dim
->values
; link
; link
= *prev
)
3744 orexp
= insert_right_side (IOR
, orexp
, XEXP (link
, 0), -2, -2);
3745 prev
= &XEXP (link
, 1);
3747 link
= rtx_alloc (EXPR_LIST
);
3748 XEXP (link
, 0) = attr_rtx (NOT
, orexp
);
3753 return dim
->num_values
;
3756 /* Increment the current value for the NDIM-dimensional attribute space SPACE
3757 and return FALSE if the increment overflowed. */
3760 increment_current_value (struct dimension
*space
, int ndim
)
3764 for (i
= ndim
- 1; i
>= 0; i
--)
3766 if ((space
[i
].current_value
= XEXP (space
[i
].current_value
, 1)) == 0)
3767 space
[i
].current_value
= space
[i
].values
;
3774 /* Construct an expression corresponding to the current value for the
3775 NDIM-dimensional attribute space SPACE. */
3778 test_for_current_value (struct dimension
*space
, int ndim
)
3783 for (i
= 0; i
< ndim
; i
++)
3784 exp
= insert_right_side (AND
, exp
, XEXP (space
[i
].current_value
, 0),
3790 /* Given the current value of the NDIM-dimensional attribute space SPACE,
3791 set the corresponding EQ_ATTR expressions to that value and reduce
3792 the expression EXP as much as possible. On input [and output], all
3793 known EQ_ATTR expressions are set to FALSE. */
3796 simplify_with_current_value (rtx exp
, struct dimension
*space
, int ndim
)
3801 /* Mark each current value as TRUE. */
3802 for (i
= 0; i
< ndim
; i
++)
3804 x
= XEXP (space
[i
].current_value
, 0);
3805 if (GET_CODE (x
) == EQ_ATTR
)
3806 ATTR_EQ_ATTR_P (x
) = 0;
3809 exp
= simplify_with_current_value_aux (exp
);
3811 /* Change each current value back to FALSE. */
3812 for (i
= 0; i
< ndim
; i
++)
3814 x
= XEXP (space
[i
].current_value
, 0);
3815 if (GET_CODE (x
) == EQ_ATTR
)
3816 ATTR_EQ_ATTR_P (x
) = 1;
3822 /* Reduce the expression EXP based on the ATTR_EQ_ATTR_P settings of
3823 all EQ_ATTR expressions. */
3826 simplify_with_current_value_aux (rtx exp
)
3831 switch (GET_CODE (exp
))
3834 if (ATTR_EQ_ATTR_P (exp
))
3843 cond
= simplify_with_current_value_aux (XEXP (exp
, 0));
3844 if (cond
== true_rtx
)
3845 return simplify_with_current_value_aux (XEXP (exp
, 1));
3846 else if (cond
== false_rtx
)
3847 return simplify_with_current_value_aux (XEXP (exp
, 2));
3849 return attr_rtx (IF_THEN_ELSE
, cond
,
3850 simplify_with_current_value_aux (XEXP (exp
, 1)),
3851 simplify_with_current_value_aux (XEXP (exp
, 2)));
3854 cond
= simplify_with_current_value_aux (XEXP (exp
, 1));
3855 if (cond
== true_rtx
)
3857 else if (cond
== false_rtx
)
3858 return simplify_with_current_value_aux (XEXP (exp
, 0));
3860 return attr_rtx (IOR
, cond
,
3861 simplify_with_current_value_aux (XEXP (exp
, 0)));
3864 cond
= simplify_with_current_value_aux (XEXP (exp
, 1));
3865 if (cond
== true_rtx
)
3866 return simplify_with_current_value_aux (XEXP (exp
, 0));
3867 else if (cond
== false_rtx
)
3870 return attr_rtx (AND
, cond
,
3871 simplify_with_current_value_aux (XEXP (exp
, 0)));
3874 cond
= simplify_with_current_value_aux (XEXP (exp
, 0));
3875 if (cond
== true_rtx
)
3877 else if (cond
== false_rtx
)
3880 return attr_rtx (NOT
, cond
);
3883 for (i
= 0; i
< XVECLEN (exp
, 0); i
+= 2)
3885 cond
= simplify_with_current_value_aux (XVECEXP (exp
, 0, i
));
3886 if (cond
== true_rtx
)
3887 return simplify_with_current_value_aux (XVECEXP (exp
, 0, i
+ 1));
3888 else if (cond
== false_rtx
)
3891 abort (); /* With all EQ_ATTR's of known value, a case should
3892 have been selected. */
3894 return simplify_with_current_value_aux (XEXP (exp
, 1));
3901 /* Clear the ATTR_CURR_SIMPLIFIED_P flag in EXP and its subexpressions. */
3904 clear_struct_flag (rtx x
)
3911 ATTR_CURR_SIMPLIFIED_P (x
) = 0;
3912 if (ATTR_IND_SIMPLIFIED_P (x
))
3915 code
= GET_CODE (x
);
3936 /* Compare the elements. If any pair of corresponding elements
3937 fail to match, return 0 for the whole things. */
3939 fmt
= GET_RTX_FORMAT (code
);
3940 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
3946 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
3947 clear_struct_flag (XVECEXP (x
, i
, j
));
3951 clear_struct_flag (XEXP (x
, i
));
3957 /* Return the number of RTX objects making up the expression X.
3958 But if we count more than MAX objects, stop counting. */
3961 count_sub_rtxs (rtx x
, int max
)
3969 code
= GET_CODE (x
);
3990 /* Compare the elements. If any pair of corresponding elements
3991 fail to match, return 0 for the whole things. */
3993 fmt
= GET_RTX_FORMAT (code
);
3994 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
4003 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
4004 total
+= count_sub_rtxs (XVECEXP (x
, i
, j
), max
);
4008 total
+= count_sub_rtxs (XEXP (x
, i
), max
);
4016 /* Create table entries for DEFINE_ATTR. */
4019 gen_attr (rtx exp
, int lineno
)
4021 struct attr_desc
*attr
;
4022 struct attr_value
*av
;
4023 const char *name_ptr
;
4026 /* Make a new attribute structure. Check for duplicate by looking at
4027 attr->default_val, since it is initialized by this routine. */
4028 attr
= find_attr (XSTR (exp
, 0), 1);
4029 if (attr
->default_val
)
4031 message_with_line (lineno
, "duplicate definition for attribute %s",
4033 message_with_line (attr
->lineno
, "previous definition");
4037 attr
->lineno
= lineno
;
4039 if (*XSTR (exp
, 1) == '\0')
4040 attr
->is_numeric
= 1;
4043 name_ptr
= XSTR (exp
, 1);
4044 while ((p
= next_comma_elt (&name_ptr
)) != NULL
)
4046 av
= oballoc (sizeof (struct attr_value
));
4047 av
->value
= attr_rtx (CONST_STRING
, p
);
4048 av
->next
= attr
->first_value
;
4049 attr
->first_value
= av
;
4050 av
->first_insn
= NULL
;
4052 av
->has_asm_insn
= 0;
4056 if (GET_CODE (XEXP (exp
, 2)) == CONST
)
4059 if (attr
->is_numeric
)
4061 message_with_line (lineno
,
4062 "constant attributes may not take numeric values");
4066 /* Get rid of the CONST node. It is allowed only at top-level. */
4067 XEXP (exp
, 2) = XEXP (XEXP (exp
, 2), 0);
4070 if (! strcmp (attr
->name
, "length") && ! attr
->is_numeric
)
4072 message_with_line (lineno
,
4073 "`length' attribute must take numeric values");
4077 /* Set up the default value. */
4078 XEXP (exp
, 2) = check_attr_value (XEXP (exp
, 2), attr
);
4079 attr
->default_val
= get_attr_value (XEXP (exp
, 2), attr
, -2);
4082 /* Given a pattern for DEFINE_PEEPHOLE or DEFINE_INSN, return the number of
4083 alternatives in the constraints. Assume all MATCH_OPERANDs have the same
4084 number of alternatives as this should be checked elsewhere. */
4087 count_alternatives (rtx exp
)
4092 if (GET_CODE (exp
) == MATCH_OPERAND
)
4093 return n_comma_elts (XSTR (exp
, 2));
4095 for (i
= 0, fmt
= GET_RTX_FORMAT (GET_CODE (exp
));
4096 i
< GET_RTX_LENGTH (GET_CODE (exp
)); i
++)
4101 n
= count_alternatives (XEXP (exp
, i
));
4108 if (XVEC (exp
, i
) != NULL
)
4109 for (j
= 0; j
< XVECLEN (exp
, i
); j
++)
4111 n
= count_alternatives (XVECEXP (exp
, i
, j
));
4120 /* Returns nonzero if the given expression contains an EQ_ATTR with the
4121 `alternative' attribute. */
4124 compares_alternatives_p (rtx exp
)
4129 if (GET_CODE (exp
) == EQ_ATTR
&& XSTR (exp
, 0) == alternative_name
)
4132 for (i
= 0, fmt
= GET_RTX_FORMAT (GET_CODE (exp
));
4133 i
< GET_RTX_LENGTH (GET_CODE (exp
)); i
++)
4138 if (compares_alternatives_p (XEXP (exp
, i
)))
4143 for (j
= 0; j
< XVECLEN (exp
, i
); j
++)
4144 if (compares_alternatives_p (XVECEXP (exp
, i
, j
)))
4152 /* Returns nonzero is INNER is contained in EXP. */
4155 contained_in_p (rtx inner
, rtx exp
)
4160 if (rtx_equal_p (inner
, exp
))
4163 for (i
= 0, fmt
= GET_RTX_FORMAT (GET_CODE (exp
));
4164 i
< GET_RTX_LENGTH (GET_CODE (exp
)); i
++)
4169 if (contained_in_p (inner
, XEXP (exp
, i
)))
4174 for (j
= 0; j
< XVECLEN (exp
, i
); j
++)
4175 if (contained_in_p (inner
, XVECEXP (exp
, i
, j
)))
4183 /* Process DEFINE_PEEPHOLE, DEFINE_INSN, and DEFINE_ASM_ATTRIBUTES. */
4186 gen_insn (rtx exp
, int lineno
)
4188 struct insn_def
*id
;
4190 id
= oballoc (sizeof (struct insn_def
));
4194 id
->lineno
= lineno
;
4196 switch (GET_CODE (exp
))
4199 id
->insn_code
= insn_code_number
;
4200 id
->insn_index
= insn_index_number
;
4201 id
->num_alternatives
= count_alternatives (exp
);
4202 if (id
->num_alternatives
== 0)
4203 id
->num_alternatives
= 1;
4207 case DEFINE_PEEPHOLE
:
4208 id
->insn_code
= insn_code_number
;
4209 id
->insn_index
= insn_index_number
;
4210 id
->num_alternatives
= count_alternatives (exp
);
4211 if (id
->num_alternatives
== 0)
4212 id
->num_alternatives
= 1;
4216 case DEFINE_ASM_ATTRIBUTES
:
4218 id
->insn_index
= -1;
4219 id
->num_alternatives
= 1;
4221 got_define_asm_attributes
= 1;
4229 /* Process a DEFINE_DELAY. Validate the vector length, check if annul
4230 true or annul false is specified, and make a `struct delay_desc'. */
4233 gen_delay (rtx def
, int lineno
)
4235 struct delay_desc
*delay
;
4238 if (XVECLEN (def
, 1) % 3 != 0)
4240 message_with_line (lineno
,
4241 "number of elements in DEFINE_DELAY must be multiple of three");
4246 for (i
= 0; i
< XVECLEN (def
, 1); i
+= 3)
4248 if (XVECEXP (def
, 1, i
+ 1))
4249 have_annul_true
= 1;
4250 if (XVECEXP (def
, 1, i
+ 2))
4251 have_annul_false
= 1;
4254 delay
= oballoc (sizeof (struct delay_desc
));
4256 delay
->num
= ++num_delays
;
4257 delay
->next
= delays
;
4258 delay
->lineno
= lineno
;
4262 /* Process a DEFINE_FUNCTION_UNIT.
4264 This gives information about a function unit contained in the CPU.
4265 We fill in a `struct function_unit_op' and a `struct function_unit'
4266 with information used later by `expand_unit'. */
4269 gen_unit (rtx def
, int lineno
)
4271 struct function_unit
*unit
;
4272 struct function_unit_op
*op
;
4273 const char *name
= XSTR (def
, 0);
4274 int multiplicity
= XINT (def
, 1);
4275 int simultaneity
= XINT (def
, 2);
4276 rtx condexp
= XEXP (def
, 3);
4277 int ready_cost
= MAX (XINT (def
, 4), 1);
4278 int issue_delay
= MAX (XINT (def
, 5), 1);
4280 /* See if we have already seen this function unit. If so, check that
4281 the multiplicity and simultaneity values are the same. If not, make
4282 a structure for this function unit. */
4283 for (unit
= units
; unit
; unit
= unit
->next
)
4284 if (! strcmp (unit
->name
, name
))
4286 if (unit
->multiplicity
!= multiplicity
4287 || unit
->simultaneity
!= simultaneity
)
4289 message_with_line (lineno
,
4290 "differing specifications given for function unit %s",
4292 message_with_line (unit
->first_lineno
, "previous definition");
4301 unit
= oballoc (sizeof (struct function_unit
));
4303 unit
->multiplicity
= multiplicity
;
4304 unit
->simultaneity
= simultaneity
;
4305 unit
->issue_delay
.min
= unit
->issue_delay
.max
= issue_delay
;
4306 unit
->num
= num_units
++;
4307 unit
->num_opclasses
= 0;
4308 unit
->condexp
= false_rtx
;
4311 unit
->first_lineno
= lineno
;
4315 /* Make a new operation class structure entry and initialize it. */
4316 op
= oballoc (sizeof (struct function_unit_op
));
4317 op
->condexp
= condexp
;
4318 op
->num
= unit
->num_opclasses
++;
4319 op
->ready
= ready_cost
;
4320 op
->issue_delay
= issue_delay
;
4321 op
->next
= unit
->ops
;
4322 op
->lineno
= lineno
;
4324 num_unit_opclasses
++;
4326 /* Set our issue expression based on whether or not an optional conflict
4327 vector was specified. */
4330 /* Compute the IOR of all the specified expressions. */
4331 rtx orexp
= false_rtx
;
4334 for (i
= 0; i
< XVECLEN (def
, 6); i
++)
4335 orexp
= insert_right_side (IOR
, orexp
, XVECEXP (def
, 6, i
), -2, -2);
4337 op
->conflict_exp
= orexp
;
4338 extend_range (&unit
->issue_delay
, 1, issue_delay
);
4342 op
->conflict_exp
= true_rtx
;
4343 extend_range (&unit
->issue_delay
, issue_delay
, issue_delay
);
4346 /* Merge our conditional into that of the function unit so we can determine
4347 which insns are used by the function unit. */
4348 unit
->condexp
= insert_right_side (IOR
, unit
->condexp
, op
->condexp
, -2, -2);
4351 /* Given a piece of RTX, print a C expression to test its truth value.
4352 We use AND and IOR both for logical and bit-wise operations, so
4353 interpret them as logical unless they are inside a comparison expression.
4354 The first bit of FLAGS will be nonzero in that case.
4356 Set the second bit of FLAGS to make references to attribute values use
4357 a cached local variable instead of calling a function. */
4360 write_test_expr (rtx exp
, int flags
)
4362 int comparison_operator
= 0;
4364 struct attr_desc
*attr
;
4366 /* In order not to worry about operator precedence, surround our part of
4367 the expression with parentheses. */
4370 code
= GET_CODE (exp
);
4373 /* Binary operators. */
4375 case GE
: case GT
: case GEU
: case GTU
:
4376 case LE
: case LT
: case LEU
: case LTU
:
4377 comparison_operator
= 1;
4379 case PLUS
: case MINUS
: case MULT
: case DIV
: case MOD
:
4380 case AND
: case IOR
: case XOR
:
4381 case ASHIFT
: case LSHIFTRT
: case ASHIFTRT
:
4382 write_test_expr (XEXP (exp
, 0), flags
| comparison_operator
);
4398 printf (" >= (unsigned) ");
4401 printf (" > (unsigned) ");
4410 printf (" <= (unsigned) ");
4413 printf (" < (unsigned) ");
4456 write_test_expr (XEXP (exp
, 1), flags
| comparison_operator
);
4460 /* Special-case (not (eq_attrq "alternative" "x")) */
4461 if (! (flags
& 1) && GET_CODE (XEXP (exp
, 0)) == EQ_ATTR
4462 && XSTR (XEXP (exp
, 0), 0) == alternative_name
)
4464 printf ("which_alternative != %s", XSTR (XEXP (exp
, 0), 1));
4468 /* Otherwise, fall through to normal unary operator. */
4470 /* Unary operators. */
4490 write_test_expr (XEXP (exp
, 0), flags
);
4493 /* Comparison test of an attribute with a value. Most of these will
4494 have been removed by optimization. Handle "alternative"
4495 specially and give error if EQ_ATTR present inside a comparison. */
4498 fatal ("EQ_ATTR not valid inside comparison");
4500 if (XSTR (exp
, 0) == alternative_name
)
4502 printf ("which_alternative == %s", XSTR (exp
, 1));
4506 attr
= find_attr (XSTR (exp
, 0), 0);
4510 /* Now is the time to expand the value of a constant attribute. */
4513 write_test_expr (evaluate_eq_attr (exp
, attr
->default_val
->value
,
4520 printf ("attr_%s", attr
->name
);
4522 printf ("get_attr_%s (insn)", attr
->name
);
4524 write_attr_valueq (attr
, XSTR (exp
, 1));
4528 /* Comparison test of flags for define_delays. */
4531 fatal ("ATTR_FLAG not valid inside comparison");
4532 printf ("(flags & ATTR_FLAG_%s) != 0", XSTR (exp
, 0));
4535 /* See if an operand matches a predicate. */
4537 /* If only a mode is given, just ensure the mode matches the operand.
4538 If neither a mode nor predicate is given, error. */
4539 if (XSTR (exp
, 1) == NULL
|| *XSTR (exp
, 1) == '\0')
4541 if (GET_MODE (exp
) == VOIDmode
)
4542 fatal ("null MATCH_OPERAND specified as test");
4544 printf ("GET_MODE (operands[%d]) == %smode",
4545 XINT (exp
, 0), GET_MODE_NAME (GET_MODE (exp
)));
4548 printf ("%s (operands[%d], %smode)",
4549 XSTR (exp
, 1), XINT (exp
, 0), GET_MODE_NAME (GET_MODE (exp
)));
4553 printf ("%s (insn)", XSTR (exp
, 0));
4556 /* Constant integer. */
4558 printf (HOST_WIDE_INT_PRINT_DEC
, XWINT (exp
, 0));
4561 /* A random C expression. */
4563 printf ("%s", XSTR (exp
, 0));
4566 /* The address of the branch target. */
4568 printf ("INSN_ADDRESSES_SET_P () ? INSN_ADDRESSES (INSN_UID (GET_CODE (operands[%d]) == LABEL_REF ? XEXP (operands[%d], 0) : operands[%d])) : 0",
4569 XINT (exp
, 0), XINT (exp
, 0), XINT (exp
, 0));
4573 /* The address of the current insn. We implement this actually as the
4574 address of the current insn for backward branches, but the last
4575 address of the next insn for forward branches, and both with
4576 adjustments that account for the worst-case possible stretching of
4577 intervening alignments between this insn and its destination. */
4578 printf ("insn_current_reference_address (insn)");
4582 printf ("%s", XSTR (exp
, 0));
4586 write_test_expr (XEXP (exp
, 0), flags
& 2);
4588 write_test_expr (XEXP (exp
, 1), flags
| 1);
4590 write_test_expr (XEXP (exp
, 2), flags
| 1);
4594 fatal ("bad RTX code `%s' in attribute calculation\n",
4595 GET_RTX_NAME (code
));
4601 /* Given an attribute value, return the maximum CONST_STRING argument
4602 encountered. Set *UNKNOWNP and return INT_MAX if the value is unknown. */
4605 max_attr_value (rtx exp
, int *unknownp
)
4610 switch (GET_CODE (exp
))
4613 current_max
= atoi (XSTR (exp
, 0));
4617 current_max
= max_attr_value (XEXP (exp
, 1), unknownp
);
4618 for (i
= 0; i
< XVECLEN (exp
, 0); i
+= 2)
4620 n
= max_attr_value (XVECEXP (exp
, 0, i
+ 1), unknownp
);
4621 if (n
> current_max
)
4627 current_max
= max_attr_value (XEXP (exp
, 1), unknownp
);
4628 n
= max_attr_value (XEXP (exp
, 2), unknownp
);
4629 if (n
> current_max
)
4635 current_max
= INT_MAX
;
4642 /* Given an attribute value, return the result of ORing together all
4643 CONST_STRING arguments encountered. Set *UNKNOWNP and return -1
4644 if the numeric value is not known. */
4647 or_attr_value (rtx exp
, int *unknownp
)
4652 switch (GET_CODE (exp
))
4655 current_or
= atoi (XSTR (exp
, 0));
4659 current_or
= or_attr_value (XEXP (exp
, 1), unknownp
);
4660 for (i
= 0; i
< XVECLEN (exp
, 0); i
+= 2)
4661 current_or
|= or_attr_value (XVECEXP (exp
, 0, i
+ 1), unknownp
);
4665 current_or
= or_attr_value (XEXP (exp
, 1), unknownp
);
4666 current_or
|= or_attr_value (XEXP (exp
, 2), unknownp
);
4678 /* Scan an attribute value, possibly a conditional, and record what actions
4679 will be required to do any conditional tests in it.
4682 `must_extract' if we need to extract the insn operands
4683 `must_constrain' if we must compute `which_alternative'
4684 `address_used' if an address expression was used
4685 `length_used' if an (eq_attr "length" ...) was used
4689 walk_attr_value (rtx exp
)
4698 code
= GET_CODE (exp
);
4702 if (! ATTR_IND_SIMPLIFIED_P (exp
))
4703 /* Since this is an arbitrary expression, it can look at anything.
4704 However, constant expressions do not depend on any particular
4706 must_extract
= must_constrain
= 1;
4714 if (XSTR (exp
, 0) == alternative_name
)
4715 must_extract
= must_constrain
= 1;
4716 else if (strcmp (XSTR (exp
, 0), "length") == 0)
4736 for (i
= 0, fmt
= GET_RTX_FORMAT (code
); i
< GET_RTX_LENGTH (code
); i
++)
4741 walk_attr_value (XEXP (exp
, i
));
4745 if (XVEC (exp
, i
) != NULL
)
4746 for (j
= 0; j
< XVECLEN (exp
, i
); j
++)
4747 walk_attr_value (XVECEXP (exp
, i
, j
));
4752 /* Write out a function to obtain the attribute for a given INSN. */
4755 write_attr_get (struct attr_desc
*attr
)
4757 struct attr_value
*av
, *common_av
;
4759 /* Find the most used attribute value. Handle that as the `default' of the
4760 switch we will generate. */
4761 common_av
= find_most_used (attr
);
4763 /* Write out start of function, then all values with explicit `case' lines,
4764 then a `default', then the value with the most uses. */
4767 if (!attr
->is_numeric
)
4768 printf ("enum attr_%s\n", attr
->name
);
4769 else if (attr
->unsigned_p
)
4770 printf ("unsigned int\n");
4774 /* If the attribute name starts with a star, the remainder is the name of
4775 the subroutine to use, instead of `get_attr_...'. */
4776 if (attr
->name
[0] == '*')
4777 printf ("%s (rtx insn ATTRIBUTE_UNUSED)\n", &attr
->name
[1]);
4778 else if (attr
->is_const
== 0)
4779 printf ("get_attr_%s (rtx insn ATTRIBUTE_UNUSED)\n", attr
->name
);
4782 printf ("get_attr_%s (void)\n", attr
->name
);
4785 for (av
= attr
->first_value
; av
; av
= av
->next
)
4786 if (av
->num_insns
!= 0)
4787 write_attr_set (attr
, 2, av
->value
, "return", ";",
4788 true_rtx
, av
->first_insn
->insn_code
,
4789 av
->first_insn
->insn_index
);
4797 if (GET_CODE (common_av
->value
) == FFS
)
4799 rtx p
= XEXP (common_av
->value
, 0);
4801 /* No need to emit code to abort if the insn is unrecognized; the
4802 other get_attr_foo functions will do that when we call them. */
4804 write_toplevel_expr (p
);
4806 printf ("\n if (accum && accum == (accum & -accum))\n");
4808 printf (" int i;\n");
4809 printf (" for (i = 0; accum >>= 1; ++i) continue;\n");
4810 printf (" accum = i;\n");
4811 printf (" }\n else\n");
4812 printf (" accum = ~accum;\n");
4813 printf (" return accum;\n}\n\n");
4817 printf (" switch (recog_memoized (insn))\n");
4820 for (av
= attr
->first_value
; av
; av
= av
->next
)
4821 if (av
!= common_av
)
4822 write_attr_case (attr
, av
, 1, "return", ";", 4, true_rtx
);
4824 write_attr_case (attr
, common_av
, 0, "return", ";", 4, true_rtx
);
4825 printf (" }\n}\n\n");
4829 /* Given an AND tree of known true terms (because we are inside an `if' with
4830 that as the condition or are in an `else' clause) and an expression,
4831 replace any known true terms with TRUE. Use `simplify_and_tree' to do
4832 the bulk of the work. */
4835 eliminate_known_true (rtx known_true
, rtx exp
, int insn_code
, int insn_index
)
4839 known_true
= SIMPLIFY_TEST_EXP (known_true
, insn_code
, insn_index
);
4841 if (GET_CODE (known_true
) == AND
)
4843 exp
= eliminate_known_true (XEXP (known_true
, 0), exp
,
4844 insn_code
, insn_index
);
4845 exp
= eliminate_known_true (XEXP (known_true
, 1), exp
,
4846 insn_code
, insn_index
);
4851 exp
= simplify_and_tree (exp
, &term
, insn_code
, insn_index
);
4857 /* Write out a series of tests and assignment statements to perform tests and
4858 sets of an attribute value. We are passed an indentation amount and prefix
4859 and suffix strings to write around each attribute value (e.g., "return"
4863 write_attr_set (struct attr_desc
*attr
, int indent
, rtx value
,
4864 const char *prefix
, const char *suffix
, rtx known_true
,
4865 int insn_code
, int insn_index
)
4867 if (GET_CODE (value
) == COND
)
4869 /* Assume the default value will be the default of the COND unless we
4870 find an always true expression. */
4871 rtx default_val
= XEXP (value
, 1);
4872 rtx our_known_true
= known_true
;
4877 for (i
= 0; i
< XVECLEN (value
, 0); i
+= 2)
4882 testexp
= eliminate_known_true (our_known_true
,
4883 XVECEXP (value
, 0, i
),
4884 insn_code
, insn_index
);
4885 newexp
= attr_rtx (NOT
, testexp
);
4886 newexp
= insert_right_side (AND
, our_known_true
, newexp
,
4887 insn_code
, insn_index
);
4889 /* If the test expression is always true or if the next `known_true'
4890 expression is always false, this is the last case, so break
4891 out and let this value be the `else' case. */
4892 if (testexp
== true_rtx
|| newexp
== false_rtx
)
4894 default_val
= XVECEXP (value
, 0, i
+ 1);
4898 /* Compute the expression to pass to our recursive call as being
4900 inner_true
= insert_right_side (AND
, our_known_true
,
4901 testexp
, insn_code
, insn_index
);
4903 /* If this is always false, skip it. */
4904 if (inner_true
== false_rtx
)
4907 write_indent (indent
);
4908 printf ("%sif ", first_if
? "" : "else ");
4910 write_test_expr (testexp
, 0);
4912 write_indent (indent
+ 2);
4915 write_attr_set (attr
, indent
+ 4,
4916 XVECEXP (value
, 0, i
+ 1), prefix
, suffix
,
4917 inner_true
, insn_code
, insn_index
);
4918 write_indent (indent
+ 2);
4920 our_known_true
= newexp
;
4925 write_indent (indent
);
4927 write_indent (indent
+ 2);
4931 write_attr_set (attr
, first_if
? indent
: indent
+ 4, default_val
,
4932 prefix
, suffix
, our_known_true
, insn_code
, insn_index
);
4936 write_indent (indent
+ 2);
4942 write_indent (indent
);
4943 printf ("%s ", prefix
);
4944 write_attr_value (attr
, value
);
4945 printf ("%s\n", suffix
);
4949 /* Write out the computation for one attribute value. */
4952 write_attr_case (struct attr_desc
*attr
, struct attr_value
*av
,
4953 int write_case_lines
, const char *prefix
, const char *suffix
,
4954 int indent
, rtx known_true
)
4956 struct insn_ent
*ie
;
4958 if (av
->num_insns
== 0)
4961 if (av
->has_asm_insn
)
4963 write_indent (indent
);
4964 printf ("case -1:\n");
4965 write_indent (indent
+ 2);
4966 printf ("if (GET_CODE (PATTERN (insn)) != ASM_INPUT\n");
4967 write_indent (indent
+ 2);
4968 printf (" && asm_noperands (PATTERN (insn)) < 0)\n");
4969 write_indent (indent
+ 2);
4970 printf (" fatal_insn_not_found (insn);\n");
4973 if (write_case_lines
)
4975 for (ie
= av
->first_insn
; ie
; ie
= ie
->next
)
4976 if (ie
->insn_code
!= -1)
4978 write_indent (indent
);
4979 printf ("case %d:\n", ie
->insn_code
);
4984 write_indent (indent
);
4985 printf ("default:\n");
4988 /* See what we have to do to output this value. */
4989 must_extract
= must_constrain
= address_used
= 0;
4990 walk_attr_value (av
->value
);
4994 write_indent (indent
+ 2);
4995 printf ("extract_constrain_insn_cached (insn);\n");
4997 else if (must_extract
)
4999 write_indent (indent
+ 2);
5000 printf ("extract_insn_cached (insn);\n");
5003 write_attr_set (attr
, indent
+ 2, av
->value
, prefix
, suffix
,
5004 known_true
, av
->first_insn
->insn_code
,
5005 av
->first_insn
->insn_index
);
5007 if (strncmp (prefix
, "return", 6))
5009 write_indent (indent
+ 2);
5010 printf ("break;\n");
5015 /* Search for uses of non-const attributes and write code to cache them. */
5018 write_expr_attr_cache (rtx p
, struct attr_desc
*attr
)
5023 if (GET_CODE (p
) == EQ_ATTR
)
5025 if (XSTR (p
, 0) != attr
->name
)
5028 if (!attr
->is_numeric
)
5029 printf (" enum attr_%s ", attr
->name
);
5030 else if (attr
->unsigned_p
)
5031 printf (" unsigned int ");
5035 printf ("attr_%s = get_attr_%s (insn);\n", attr
->name
, attr
->name
);
5039 fmt
= GET_RTX_FORMAT (GET_CODE (p
));
5040 ie
= GET_RTX_LENGTH (GET_CODE (p
));
5041 for (i
= 0; i
< ie
; i
++)
5046 if (write_expr_attr_cache (XEXP (p
, i
), attr
))
5051 je
= XVECLEN (p
, i
);
5052 for (j
= 0; j
< je
; ++j
)
5053 if (write_expr_attr_cache (XVECEXP (p
, i
, j
), attr
))
5062 /* Evaluate an expression at top level. A front end to write_test_expr,
5063 in which we cache attribute values and break up excessively large
5064 expressions to cater to older compilers. */
5067 write_toplevel_expr (rtx p
)
5069 struct attr_desc
*attr
;
5072 for (i
= 0; i
< MAX_ATTRS_INDEX
; ++i
)
5073 for (attr
= attrs
[i
]; attr
; attr
= attr
->next
)
5074 if (!attr
->is_const
)
5075 write_expr_attr_cache (p
, attr
);
5077 printf (" unsigned long accum = 0;\n\n");
5079 while (GET_CODE (p
) == IOR
)
5082 if (GET_CODE (XEXP (p
, 0)) == IOR
)
5083 e
= XEXP (p
, 1), p
= XEXP (p
, 0);
5085 e
= XEXP (p
, 0), p
= XEXP (p
, 1);
5087 printf (" accum |= ");
5088 write_test_expr (e
, 3);
5091 printf (" accum |= ");
5092 write_test_expr (p
, 3);
5096 /* Utilities to write names in various forms. */
5099 write_unit_name (const char *prefix
, int num
, const char *suffix
)
5101 struct function_unit
*unit
;
5103 for (unit
= units
; unit
; unit
= unit
->next
)
5104 if (unit
->num
== num
)
5106 printf ("%s%s%s", prefix
, unit
->name
, suffix
);
5110 printf ("%s<unknown>%s", prefix
, suffix
);
5114 write_attr_valueq (struct attr_desc
*attr
, const char *s
)
5116 if (attr
->is_numeric
)
5122 /* Make the blockage range values and function units used values easier
5124 if (attr
->func_units_p
)
5127 printf (" /* units: none */");
5129 write_unit_name (" /* units: ", num
, " */");
5133 const char *sep
= " /* units: ";
5134 for (i
= 0, num
= ~num
; num
; i
++, num
>>= 1)
5137 write_unit_name (sep
, i
, (num
== 1) ? " */" : "");
5143 else if (attr
->blockage_p
)
5144 printf (" /* min %d, max %d */", num
>> (HOST_BITS_PER_INT
/ 2),
5145 num
& ((1 << (HOST_BITS_PER_INT
/ 2)) - 1));
5147 else if (num
> 9 || num
< 0)
5148 printf (" /* 0x%x */", num
);
5152 write_upcase (attr
->name
);
5159 write_attr_value (struct attr_desc
*attr
, rtx value
)
5163 switch (GET_CODE (value
))
5166 write_attr_valueq (attr
, XSTR (value
, 0));
5170 printf (HOST_WIDE_INT_PRINT_DEC
, INTVAL (value
));
5174 fputs (XSTR (value
, 0), stdout
);
5179 struct attr_desc
*attr2
= find_attr (XSTR (value
, 0), 0);
5180 printf ("get_attr_%s (%s)", attr2
->name
,
5181 (attr2
->is_const
? "" : "insn"));
5202 write_attr_value (attr
, XEXP (value
, 0));
5206 write_attr_value (attr
, XEXP (value
, 1));
5215 write_upcase (const char *str
)
5219 /* The argument of TOUPPER should not have side effects. */
5220 putchar (TOUPPER(*str
));
5226 write_indent (int indent
)
5228 for (; indent
> 8; indent
-= 8)
5231 for (; indent
; indent
--)
5235 /* Write a subroutine that is given an insn that requires a delay slot, a
5236 delay slot ordinal, and a candidate insn. It returns nonzero if the
5237 candidate can be placed in the specified delay slot of the insn.
5239 We can write as many as three subroutines. `eligible_for_delay'
5240 handles normal delay slots, `eligible_for_annul_true' indicates that
5241 the specified insn can be annulled if the branch is true, and likewise
5242 for `eligible_for_annul_false'.
5244 KIND is a string distinguishing these three cases ("delay", "annul_true",
5245 or "annul_false"). */
5248 write_eligible_delay (const char *kind
)
5250 struct delay_desc
*delay
;
5253 struct attr_desc
*attr
;
5254 struct attr_value
*av
, *common_av
;
5257 /* Compute the maximum number of delay slots required. We use the delay
5258 ordinal times this number plus one, plus the slot number as an index into
5259 the appropriate predicate to test. */
5261 for (delay
= delays
, max_slots
= 0; delay
; delay
= delay
->next
)
5262 if (XVECLEN (delay
->def
, 1) / 3 > max_slots
)
5263 max_slots
= XVECLEN (delay
->def
, 1) / 3;
5265 /* Write function prelude. */
5268 printf ("eligible_for_%s (rtx delay_insn ATTRIBUTE_UNUSED, int slot, rtx candidate_insn, int flags ATTRIBUTE_UNUSED)\n",
5271 printf (" rtx insn;\n");
5273 printf (" if (slot >= %d)\n", max_slots
);
5274 printf (" abort ();\n");
5277 /* If more than one delay type, find out which type the delay insn is. */
5281 attr
= find_attr ("*delay_type", 0);
5284 common_av
= find_most_used (attr
);
5286 printf (" insn = delay_insn;\n");
5287 printf (" switch (recog_memoized (insn))\n");
5290 sprintf (str
, " * %d;\n break;", max_slots
);
5291 for (av
= attr
->first_value
; av
; av
= av
->next
)
5292 if (av
!= common_av
)
5293 write_attr_case (attr
, av
, 1, "slot +=", str
, 4, true_rtx
);
5295 write_attr_case (attr
, common_av
, 0, "slot +=", str
, 4, true_rtx
);
5298 /* Ensure matched. Otherwise, shouldn't have been called. */
5299 printf (" if (slot < %d)\n", max_slots
);
5300 printf (" abort ();\n\n");
5303 /* If just one type of delay slot, write simple switch. */
5304 if (num_delays
== 1 && max_slots
== 1)
5306 printf (" insn = candidate_insn;\n");
5307 printf (" switch (recog_memoized (insn))\n");
5310 attr
= find_attr ("*delay_1_0", 0);
5313 common_av
= find_most_used (attr
);
5315 for (av
= attr
->first_value
; av
; av
= av
->next
)
5316 if (av
!= common_av
)
5317 write_attr_case (attr
, av
, 1, "return", ";", 4, true_rtx
);
5319 write_attr_case (attr
, common_av
, 0, "return", ";", 4, true_rtx
);
5325 /* Write a nested CASE. The first indicates which condition we need to
5326 test, and the inner CASE tests the condition. */
5327 printf (" insn = candidate_insn;\n");
5328 printf (" switch (slot)\n");
5331 for (delay
= delays
; delay
; delay
= delay
->next
)
5332 for (i
= 0; i
< XVECLEN (delay
->def
, 1); i
+= 3)
5334 printf (" case %d:\n",
5335 (i
/ 3) + (num_delays
== 1 ? 0 : delay
->num
* max_slots
));
5336 printf (" switch (recog_memoized (insn))\n");
5339 sprintf (str
, "*%s_%d_%d", kind
, delay
->num
, i
/ 3);
5340 attr
= find_attr (str
, 0);
5343 common_av
= find_most_used (attr
);
5345 for (av
= attr
->first_value
; av
; av
= av
->next
)
5346 if (av
!= common_av
)
5347 write_attr_case (attr
, av
, 1, "return", ";", 8, true_rtx
);
5349 write_attr_case (attr
, common_av
, 0, "return", ";", 8, true_rtx
);
5353 printf (" default:\n");
5354 printf (" abort ();\n");
5361 /* Write routines to compute conflict cost for function units. Then write a
5362 table describing the available function units. */
5365 write_function_unit_info (void)
5367 struct function_unit
*unit
;
5370 /* Write out conflict routines for function units. Don't bother writing
5371 one if there is only one issue delay value. */
5373 for (unit
= units
; unit
; unit
= unit
->next
)
5375 if (unit
->needs_blockage_function
)
5376 write_complex_function (unit
, "blockage", "block");
5378 /* If the minimum and maximum conflict costs are the same, there
5379 is only one value, so we don't need a function. */
5380 if (! unit
->needs_conflict_function
)
5382 unit
->default_cost
= make_numeric_value (unit
->issue_delay
.max
);
5386 /* The function first computes the case from the candidate insn. */
5387 unit
->default_cost
= make_numeric_value (0);
5388 write_complex_function (unit
, "conflict_cost", "cost");
5391 /* Now that all functions have been written, write the table describing
5392 the function units. The name is included for documentation purposes
5395 printf ("const struct function_unit_desc function_units[] = {\n");
5397 /* Write out the descriptions in numeric order, but don't force that order
5398 on the list. Doing so increases the runtime of genattrtab.c. */
5399 for (i
= 0; i
< num_units
; i
++)
5401 for (unit
= units
; unit
; unit
= unit
->next
)
5405 printf (" {\"%s\", %d, %d, %d, %s, %d, %s_unit_ready_cost, ",
5406 unit
->name
, 1 << unit
->num
, unit
->multiplicity
,
5407 unit
->simultaneity
, XSTR (unit
->default_cost
, 0),
5408 unit
->issue_delay
.max
, unit
->name
);
5410 if (unit
->needs_conflict_function
)
5411 printf ("%s_unit_conflict_cost, ", unit
->name
);
5415 printf ("%d, ", unit
->max_blockage
);
5417 if (unit
->needs_range_function
)
5418 printf ("%s_unit_blockage_range, ", unit
->name
);
5422 if (unit
->needs_blockage_function
)
5423 printf ("%s_unit_blockage", unit
->name
);
5431 printf ("{\"dummy\", 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} /* a dummy element */");
5436 write_complex_function (struct function_unit
*unit
,
5438 const char *connection
)
5440 struct attr_desc
*case_attr
, *attr
;
5441 struct attr_value
*av
, *common_av
;
5447 printf ("static int\n");
5448 printf ("%s_unit_%s (rtx executing_insn, rtx candidate_insn)\n",
5451 printf (" rtx insn;\n");
5452 printf (" int casenum;\n\n");
5453 printf (" insn = executing_insn;\n");
5454 printf (" switch (recog_memoized (insn))\n");
5457 /* Write the `switch' statement to get the case value. */
5458 if (strlen (unit
->name
) + sizeof "*_cases" > 256)
5460 sprintf (str
, "*%s_cases", unit
->name
);
5461 case_attr
= find_attr (str
, 0);
5464 common_av
= find_most_used (case_attr
);
5466 for (av
= case_attr
->first_value
; av
; av
= av
->next
)
5467 if (av
!= common_av
)
5468 write_attr_case (case_attr
, av
, 1,
5469 "casenum =", ";", 4, unit
->condexp
);
5471 write_attr_case (case_attr
, common_av
, 0,
5472 "casenum =", ";", 4, unit
->condexp
);
5475 /* Now write an outer switch statement on each case. Then write
5476 the tests on the executing function within each. */
5477 printf (" insn = candidate_insn;\n");
5478 printf (" switch (casenum)\n");
5481 for (i
= 0; i
< unit
->num_opclasses
; i
++)
5483 /* Ensure using this case. */
5485 for (av
= case_attr
->first_value
; av
; av
= av
->next
)
5487 && contained_in_p (make_numeric_value (i
), av
->value
))
5493 printf (" case %d:\n", i
);
5494 sprintf (str
, "*%s_%s_%d", unit
->name
, connection
, i
);
5495 attr
= find_attr (str
, 0);
5499 /* If single value, just write it. */
5500 value
= find_single_value (attr
);
5502 write_attr_set (attr
, 6, value
, "return", ";\n", true_rtx
, -2, -2);
5505 common_av
= find_most_used (attr
);
5506 printf (" switch (recog_memoized (insn))\n");
5509 for (av
= attr
->first_value
; av
; av
= av
->next
)
5510 if (av
!= common_av
)
5511 write_attr_case (attr
, av
, 1,
5512 "return", ";", 8, unit
->condexp
);
5514 write_attr_case (attr
, common_av
, 0,
5515 "return", ";", 8, unit
->condexp
);
5520 /* This default case should not be needed, but gcc's analysis is not
5521 good enough to realize that the default case is not needed for the
5522 second switch statement. */
5523 printf (" default:\n abort ();\n");
5524 printf (" }\n}\n\n");
5527 /* This page contains miscellaneous utility routines. */
5529 /* Given a pointer to a (char *), return a malloc'ed string containing the
5530 next comma-separated element. Advance the pointer to after the string
5531 scanned, or the end-of-string. Return NULL if at end of string. */
5534 next_comma_elt (const char **pstr
)
5538 start
= scan_comma_elt (pstr
);
5543 return attr_string (start
, *pstr
- start
);
5546 /* Return a `struct attr_desc' pointer for a given named attribute. If CREATE
5547 is nonzero, build a new attribute, if one does not exist. */
5549 static struct attr_desc
*
5550 find_attr (const char *name
, int create
)
5552 struct attr_desc
*attr
;
5555 /* Before we resort to using `strcmp', see if the string address matches
5556 anywhere. In most cases, it should have been canonicalized to do so. */
5557 if (name
== alternative_name
)
5560 index
= name
[0] & (MAX_ATTRS_INDEX
- 1);
5561 for (attr
= attrs
[index
]; attr
; attr
= attr
->next
)
5562 if (name
== attr
->name
)
5565 /* Otherwise, do it the slow way. */
5566 for (attr
= attrs
[index
]; attr
; attr
= attr
->next
)
5567 if (name
[0] == attr
->name
[0] && ! strcmp (name
, attr
->name
))
5573 attr
= oballoc (sizeof (struct attr_desc
));
5574 attr
->name
= attr_string (name
, strlen (name
));
5575 attr
->first_value
= attr
->default_val
= NULL
;
5576 attr
->is_numeric
= attr
->negative_ok
= attr
->is_const
= attr
->is_special
= 0;
5577 attr
->unsigned_p
= attr
->func_units_p
= attr
->blockage_p
= attr
->static_p
= 0;
5578 attr
->next
= attrs
[index
];
5579 attrs
[index
] = attr
;
5584 /* Create internal attribute with the given default value. */
5587 make_internal_attr (const char *name
, rtx value
, int special
)
5589 struct attr_desc
*attr
;
5591 attr
= find_attr (name
, 1);
5592 if (attr
->default_val
)
5595 attr
->is_numeric
= 1;
5597 attr
->is_special
= (special
& ATTR_SPECIAL
) != 0;
5598 attr
->negative_ok
= (special
& ATTR_NEGATIVE_OK
) != 0;
5599 attr
->unsigned_p
= (special
& ATTR_UNSIGNED
) != 0;
5600 attr
->func_units_p
= (special
& ATTR_FUNC_UNITS
) != 0;
5601 attr
->blockage_p
= (special
& ATTR_BLOCKAGE
) != 0;
5602 attr
->static_p
= (special
& ATTR_STATIC
) != 0;
5603 attr
->default_val
= get_attr_value (value
, attr
, -2);
5606 /* Find the most used value of an attribute. */
5608 static struct attr_value
*
5609 find_most_used (struct attr_desc
*attr
)
5611 struct attr_value
*av
;
5612 struct attr_value
*most_used
;
5618 for (av
= attr
->first_value
; av
; av
= av
->next
)
5619 if (av
->num_insns
> nuses
)
5620 nuses
= av
->num_insns
, most_used
= av
;
5625 /* If an attribute only has a single value used, return it. Otherwise
5629 find_single_value (struct attr_desc
*attr
)
5631 struct attr_value
*av
;
5634 unique_value
= NULL
;
5635 for (av
= attr
->first_value
; av
; av
= av
->next
)
5641 unique_value
= av
->value
;
5644 return unique_value
;
5647 /* Return (attr_value "n") */
5650 make_numeric_value (int n
)
5652 static rtx int_values
[20];
5659 if (n
< 20 && int_values
[n
])
5660 return int_values
[n
];
5662 p
= attr_printf (MAX_DIGITS
, "%d", n
);
5663 exp
= attr_rtx (CONST_STRING
, p
);
5666 int_values
[n
] = exp
;
5672 extend_range (struct range
*range
, int min
, int max
)
5674 if (range
->min
> min
)
5676 if (range
->max
< max
)
5681 copy_rtx_unchanging (rtx orig
)
5683 if (ATTR_IND_SIMPLIFIED_P (orig
) || ATTR_CURR_SIMPLIFIED_P (orig
))
5686 ATTR_CURR_SIMPLIFIED_P (orig
) = 1;
5690 /* Determine if an insn has a constant number of delay slots, i.e., the
5691 number of delay slots is not a function of the length of the insn. */
5694 write_const_num_delay_slots (void)
5696 struct attr_desc
*attr
= find_attr ("*num_delay_slots", 0);
5697 struct attr_value
*av
;
5698 struct insn_ent
*ie
;
5702 printf ("int\nconst_num_delay_slots (rtx insn)\n");
5704 printf (" switch (recog_memoized (insn))\n");
5707 for (av
= attr
->first_value
; av
; av
= av
->next
)
5710 walk_attr_value (av
->value
);
5713 for (ie
= av
->first_insn
; ie
; ie
= ie
->next
)
5714 if (ie
->insn_code
!= -1)
5715 printf (" case %d:\n", ie
->insn_code
);
5716 printf (" return 0;\n");
5720 printf (" default:\n");
5721 printf (" return 1;\n");
5722 printf (" }\n}\n\n");
5727 main (int argc
, char **argv
)
5730 struct attr_desc
*attr
;
5731 struct insn_def
*id
;
5735 progname
= "genattrtab";
5738 fatal ("no input file name");
5740 if (init_md_reader_args (argc
, argv
) != SUCCESS_EXIT_CODE
)
5741 return (FATAL_EXIT_CODE
);
5743 obstack_init (hash_obstack
);
5744 obstack_init (temp_obstack
);
5746 /* Set up true and false rtx's */
5747 true_rtx
= rtx_alloc (CONST_INT
);
5748 XWINT (true_rtx
, 0) = 1;
5749 false_rtx
= rtx_alloc (CONST_INT
);
5750 XWINT (false_rtx
, 0) = 0;
5751 ATTR_IND_SIMPLIFIED_P (true_rtx
) = ATTR_IND_SIMPLIFIED_P (false_rtx
) = 1;
5752 ATTR_PERMANENT_P (true_rtx
) = ATTR_PERMANENT_P (false_rtx
) = 1;
5754 alternative_name
= attr_string ("alternative", strlen ("alternative"));
5756 printf ("/* Generated automatically by the program `genattrtab'\n\
5757 from the machine description file `md'. */\n\n");
5759 /* Read the machine description. */
5761 initiate_automaton_gen (argc
, argv
);
5766 desc
= read_md_rtx (&lineno
, &insn_code_number
);
5770 switch (GET_CODE (desc
))
5773 case DEFINE_PEEPHOLE
:
5774 case DEFINE_ASM_ATTRIBUTES
:
5775 gen_insn (desc
, lineno
);
5779 gen_attr (desc
, lineno
);
5783 gen_delay (desc
, lineno
);
5786 case DEFINE_FUNCTION_UNIT
:
5787 gen_unit (desc
, lineno
);
5790 case DEFINE_CPU_UNIT
:
5791 gen_cpu_unit (desc
);
5794 case DEFINE_QUERY_CPU_UNIT
:
5795 gen_query_cpu_unit (desc
);
5803 gen_excl_set (desc
);
5807 gen_presence_set (desc
);
5810 case FINAL_PRESENCE_SET
:
5811 gen_final_presence_set (desc
);
5815 gen_absence_set (desc
);
5818 case FINAL_ABSENCE_SET
:
5819 gen_final_absence_set (desc
);
5822 case DEFINE_AUTOMATON
:
5823 gen_automaton (desc
);
5826 case AUTOMATA_OPTION
:
5827 gen_automata_option (desc
);
5830 case DEFINE_RESERVATION
:
5834 case DEFINE_INSN_RESERVATION
:
5835 gen_insn_reserv (desc
);
5841 if (GET_CODE (desc
) != DEFINE_ASM_ATTRIBUTES
)
5842 insn_index_number
++;
5846 return FATAL_EXIT_CODE
;
5850 /* If we didn't have a DEFINE_ASM_ATTRIBUTES, make a null one. */
5851 if (! got_define_asm_attributes
)
5853 tem
= rtx_alloc (DEFINE_ASM_ATTRIBUTES
);
5854 XVEC (tem
, 0) = rtvec_alloc (0);
5858 /* Expand DEFINE_DELAY information into new attribute. */
5862 if (num_units
|| num_dfa_decls
)
5864 /* Expand DEFINE_FUNCTION_UNIT information into new attributes. */
5866 /* Build DFA, output some functions and expand DFA information
5867 into new attributes. */
5871 printf ("#include \"config.h\"\n");
5872 printf ("#include \"system.h\"\n");
5873 printf ("#include \"coretypes.h\"\n");
5874 printf ("#include \"tm.h\"\n");
5875 printf ("#include \"rtl.h\"\n");
5876 printf ("#include \"tm_p.h\"\n");
5877 printf ("#include \"insn-config.h\"\n");
5878 printf ("#include \"recog.h\"\n");
5879 printf ("#include \"regs.h\"\n");
5880 printf ("#include \"real.h\"\n");
5881 printf ("#include \"output.h\"\n");
5882 printf ("#include \"insn-attr.h\"\n");
5883 printf ("#include \"toplev.h\"\n");
5884 printf ("#include \"flags.h\"\n");
5885 printf ("#include \"function.h\"\n");
5887 printf ("#define operands recog_data.operand\n\n");
5889 /* Make `insn_alternatives'. */
5890 insn_alternatives
= oballoc (insn_code_number
* sizeof (int));
5891 for (id
= defs
; id
; id
= id
->next
)
5892 if (id
->insn_code
>= 0)
5893 insn_alternatives
[id
->insn_code
] = (1 << id
->num_alternatives
) - 1;
5895 /* Make `insn_n_alternatives'. */
5896 insn_n_alternatives
= oballoc (insn_code_number
* sizeof (int));
5897 for (id
= defs
; id
; id
= id
->next
)
5898 if (id
->insn_code
>= 0)
5899 insn_n_alternatives
[id
->insn_code
] = id
->num_alternatives
;
5901 /* Prepare to write out attribute subroutines by checking everything stored
5902 away and building the attribute cases. */
5906 for (i
= 0; i
< MAX_ATTRS_INDEX
; i
++)
5907 for (attr
= attrs
[i
]; attr
; attr
= attr
->next
)
5908 attr
->default_val
->value
5909 = check_attr_value (attr
->default_val
->value
, attr
);
5912 return FATAL_EXIT_CODE
;
5914 for (i
= 0; i
< MAX_ATTRS_INDEX
; i
++)
5915 for (attr
= attrs
[i
]; attr
; attr
= attr
->next
)
5918 /* Construct extra attributes for `length'. */
5919 make_length_attrs ();
5921 /* Perform any possible optimizations to speed up compilation. */
5924 /* Now write out all the `gen_attr_...' routines. Do these before the
5925 special routines (specifically before write_function_unit_info), so
5926 that they get defined before they are used. */
5928 for (i
= 0; i
< MAX_ATTRS_INDEX
; i
++)
5929 for (attr
= attrs
[i
]; attr
; attr
= attr
->next
)
5931 if (! attr
->is_special
&& ! attr
->is_const
)
5936 = (attr
->name
[0] == '*'
5937 && strcmp (&attr
->name
[1], INSN_ALTS_FUNC_NAME
) == 0);
5939 printf ("\n#if AUTOMATON_ALTS\n");
5940 write_attr_get (attr
);
5942 printf ("#endif\n\n");
5946 /* Write out delay eligibility information, if DEFINE_DELAY present.
5947 (The function to compute the number of delay slots will be written
5951 write_eligible_delay ("delay");
5952 if (have_annul_true
)
5953 write_eligible_delay ("annul_true");
5954 if (have_annul_false
)
5955 write_eligible_delay ("annul_false");
5958 if (num_units
|| num_dfa_decls
)
5960 /* Write out information about function units. */
5961 write_function_unit_info ();
5962 /* Output code for pipeline hazards recognition based on DFA
5963 (deterministic finite state automata. */
5967 /* Write out constant delay slot info. */
5968 write_const_num_delay_slots ();
5970 write_length_unit_log ();
5973 return (ferror (stdout
) != 0 ? FATAL_EXIT_CODE
: SUCCESS_EXIT_CODE
);
5976 /* Define this so we can link with print-rtl.o to get debug_rtx function. */
5978 get_insn_name (int code ATTRIBUTE_UNUSED
)