1 /* Generate code from machine description to compute values of attributes.
2 Copyright (C) 1991-2014 Free Software Foundation, Inc.
3 Contributed by Richard Kenner (kenner@vlsi1.ultra.nyu.edu)
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 3, or (at your option) any later
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
21 /* This program handles insn attributes and the DEFINE_DELAY and
22 DEFINE_INSN_RESERVATION definitions.
24 It produces a series of functions named `get_attr_...', one for each insn
25 attribute. Each of these is given the rtx for an insn and returns a member
26 of the enum for the attribute.
28 These subroutines have the form of a `switch' on the INSN_CODE (via
29 `recog_memoized'). Each case either returns a constant attribute value
30 or a value that depends on tests on other attributes, the form of
31 operands, or some random C expression (encoded with a SYMBOL_REF
34 If the attribute `alternative', or a random C expression is present,
35 `constrain_operands' is called. If either of these cases of a reference to
36 an operand is found, `extract_insn' is called.
38 The special attribute `length' is also recognized. For this operand,
39 expressions involving the address of an operand or the current insn,
40 (address (pc)), are valid. In this case, an initial pass is made to
41 set all lengths that do not depend on address. Those that do are set to
42 the maximum length. Then each insn that depends on an address is checked
43 and possibly has its length changed. The process repeats until no further
44 changed are made. The resulting lengths are saved for use by
47 A special form of DEFINE_ATTR, where the expression for default value is a
48 CONST expression, indicates an attribute that is constant for a given run
49 of the compiler. The subroutine generated for these attributes has no
50 parameters as it does not depend on any particular insn. Constant
51 attributes are typically used to specify which variety of processor is
54 Internal attributes are defined to handle DEFINE_DELAY and
55 DEFINE_INSN_RESERVATION. Special routines are output for these cases.
57 This program works by keeping a list of possible values for each attribute.
58 These include the basic attribute choices, default values for attribute, and
59 all derived quantities.
61 As the description file is read, the definition for each insn is saved in a
62 `struct insn_def'. When the file reading is complete, a `struct insn_ent'
63 is created for each insn and chained to the corresponding attribute value,
64 either that specified, or the default.
66 An optimization phase is then run. This simplifies expressions for each
67 insn. EQ_ATTR tests are resolved, whenever possible, to a test that
68 indicates when the attribute has the specified value for the insn. This
69 avoids recursive calls during compilation.
71 The strategy used when processing DEFINE_DELAY definitions is to create
72 arbitrarily complex expressions and have the optimization simplify them.
74 Once optimization is complete, any required routines and definitions
77 An optimization that is not yet implemented is to hoist the constant
78 expressions entirely out of the routines and definitions that are written.
79 A way to do this is to iterate over all possible combinations of values
80 for constant attributes and generate a set of functions for that given
81 combination. An initialization function would be written that evaluates
82 the attributes and installs the corresponding set of routines and
83 definitions (each would be accessed through a pointer).
85 We use the flags in an RTX as follows:
86 `unchanging' (ATTR_IND_SIMPLIFIED_P): This rtx is fully simplified
87 independent of the insn code.
88 `in_struct' (ATTR_CURR_SIMPLIFIED_P): This rtx is fully simplified
89 for the insn code currently being processed (see optimize_attrs).
90 `return_val' (ATTR_PERMANENT_P): This rtx is permanent and unique
93 #define ATTR_IND_SIMPLIFIED_P(RTX) (RTX_FLAG ((RTX), unchanging))
94 #define ATTR_CURR_SIMPLIFIED_P(RTX) (RTX_FLAG ((RTX), in_struct))
95 #define ATTR_PERMANENT_P(RTX) (RTX_FLAG ((RTX), return_val))
98 #define strcmp_check(S1, S2) ((S1) == (S2) \
100 : (gcc_assert (strcmp ((S1), (S2))), 1))
102 #define strcmp_check(S1, S2) ((S1) != (S2))
107 #include "coretypes.h"
113 #include "gensupport.h"
118 /* Flags for make_internal_attr's `special' parameter. */
120 #define ATTR_SPECIAL (1 << 0)
122 static struct obstack obstack1
, obstack2
;
123 static struct obstack
*hash_obstack
= &obstack1
;
124 static 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 number in file, for errors. */
142 const char *filename
; /* Filename. */
143 int lineno
; /* Line number. */
144 int num_alternatives
; /* Number of alternatives. */
145 int vec_idx
; /* Index of attribute vector in `def'. */
148 /* Once everything has been read in, we store in each attribute value a list
149 of insn codes that have that value. Here is the structure used for the
154 struct insn_ent
*next
; /* Next in chain. */
155 struct insn_def
*def
; /* Instruction definition. */
158 /* Each value of an attribute (either constant or computed) is assigned a
159 structure which is used as the listhead of the insns that have that
164 rtx value
; /* Value of attribute. */
165 struct attr_value
*next
; /* Next attribute value in chain. */
166 struct insn_ent
*first_insn
; /* First insn with this value. */
167 int num_insns
; /* Number of insns with this value. */
168 int has_asm_insn
; /* True if this value used for `asm' insns */
171 /* Structure for each attribute. */
175 char *name
; /* Name of attribute. */
176 const char *enum_name
; /* Enum name for DEFINE_ENUM_NAME. */
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 is_const
: 1; /* Attribute value constant for each run. */
183 unsigned is_special
: 1; /* Don't call `write_attr_set'. */
186 /* Structure for each DEFINE_DELAY. */
190 rtx def
; /* DEFINE_DELAY expression. */
191 struct delay_desc
*next
; /* Next DEFINE_DELAY. */
192 int num
; /* Number of DEFINE_DELAY, starting at 1. */
193 int lineno
; /* Line number. */
196 struct attr_value_list
198 struct attr_value
*av
;
200 struct attr_desc
*attr
;
201 struct attr_value_list
*next
;
204 /* Listheads of above structures. */
206 /* This one is indexed by the first character of the attribute name. */
207 #define MAX_ATTRS_INDEX 256
208 static struct attr_desc
*attrs
[MAX_ATTRS_INDEX
];
209 static struct insn_def
*defs
;
210 static struct delay_desc
*delays
;
211 struct attr_value_list
**insn_code_values
;
213 /* Other variables. */
215 static int insn_code_number
;
216 static int insn_index_number
;
217 static int got_define_asm_attributes
;
218 static int must_extract
;
219 static int must_constrain
;
220 static int address_used
;
221 static int length_used
;
222 static int num_delays
;
223 static int have_annul_true
, have_annul_false
;
224 static int num_insn_ents
;
226 /* Stores, for each insn code, the number of constraint alternatives. */
228 static int *insn_n_alternatives
;
230 /* Stores, for each insn code, a bitmap that has bits on for each possible
233 static int *insn_alternatives
;
235 /* Used to simplify expressions. */
237 static rtx true_rtx
, false_rtx
;
239 /* Used to reduce calls to `strcmp' */
241 static const char *alternative_name
;
242 static const char *length_str
;
243 static const char *delay_type_str
;
244 static const char *delay_1_0_str
;
245 static const char *num_delay_slots_str
;
247 /* Simplify an expression. Only call the routine if there is something to
249 #define SIMPLIFY_TEST_EXP(EXP,INSN_CODE,INSN_INDEX) \
250 (ATTR_IND_SIMPLIFIED_P (EXP) || ATTR_CURR_SIMPLIFIED_P (EXP) ? (EXP) \
251 : simplify_test_exp (EXP, INSN_CODE, INSN_INDEX))
253 #define DEF_ATTR_STRING(S) (attr_string ((S), strlen (S)))
255 /* Forward declarations of functions used before their definitions, only. */
256 static char *attr_string (const char *, int);
257 static char *attr_printf (unsigned int, const char *, ...)
259 static rtx
make_numeric_value (int);
260 static struct attr_desc
*find_attr (const char **, int);
261 static rtx
mk_attr_alt (int);
262 static char *next_comma_elt (const char **);
263 static rtx
insert_right_side (enum rtx_code
, rtx
, rtx
, int, int);
264 static rtx
copy_boolean (rtx
);
265 static int compares_alternatives_p (rtx
);
266 static void make_internal_attr (const char *, rtx
, int);
267 static void insert_insn_ent (struct attr_value
*, struct insn_ent
*);
268 static void walk_attr_value (rtx
);
269 static int max_attr_value (rtx
, int*);
270 static int min_attr_value (rtx
, int*);
271 static int or_attr_value (rtx
, int*);
272 static rtx
simplify_test_exp (rtx
, int, int);
273 static rtx
simplify_test_exp_in_temp (rtx
, int, int);
274 static rtx
copy_rtx_unchanging (rtx
);
275 static bool attr_alt_subset_p (rtx
, rtx
);
276 static bool attr_alt_subset_of_compl_p (rtx
, rtx
);
277 static void clear_struct_flag (rtx
);
278 static void write_attr_valueq (FILE *, struct attr_desc
*, const char *);
279 static struct attr_value
*find_most_used (struct attr_desc
*);
280 static void write_attr_set (FILE *, struct attr_desc
*, int, rtx
,
281 const char *, const char *, rtx
,
282 int, int, unsigned int);
283 static void write_attr_case (FILE *, struct attr_desc
*,
285 int, const char *, const char *, int, rtx
);
286 static void write_attr_value (FILE *, struct attr_desc
*, rtx
);
287 static void write_upcase (FILE *, const char *);
288 static void write_indent (FILE *, int);
289 static rtx
identity_fn (rtx
);
290 static rtx
zero_fn (rtx
);
291 static rtx
one_fn (rtx
);
292 static rtx
max_fn (rtx
);
293 static rtx
min_fn (rtx
);
295 #define oballoc(T) XOBNEW (hash_obstack, T)
296 #define oballocvec(T, N) XOBNEWVEC (hash_obstack, T, (N))
298 /* This gen* file is unique, in that it writes out multiple files.
300 Before GCC 4.8, insn-attrtab.c was written out containing many large
301 functions and tables. This made insn-attrtab.c _the_ bottle-neck in
302 a parallel build, and even made it impossible to build GCC on machines
303 with relatively small RAM space (PR other/29442). Therefore, the
304 atrribute functions/tables are now written out to three separate
305 files: all "*insn_default_latency" functions go to LATENCY_FILE_NAME,
306 all "*internal_dfa_insn_code" functions go to DFA_FILE_NAME, and the
307 rest goes to ATTR_FILE_NAME. */
309 static const char *attr_file_name
= NULL
;
310 static const char *dfa_file_name
= NULL
;
311 static const char *latency_file_name
= NULL
;
313 static FILE *attr_file
, *dfa_file
, *latency_file
;
315 /* Hash table for sharing RTL and strings. */
317 /* Each hash table slot is a bucket containing a chain of these structures.
318 Strings are given negative hash codes; RTL expressions are given positive
323 struct attr_hash
*next
; /* Next structure in the bucket. */
324 unsigned int hashcode
; /* Hash code of this rtx or string. */
327 char *str
; /* The string (negative hash codes) */
328 rtx rtl
; /* or the RTL recorded here. */
332 /* Now here is the hash table. When recording an RTL, it is added to
333 the slot whose index is the hash code mod the table size. Note
334 that the hash table is used for several kinds of RTL (see attr_rtx)
335 and for strings. While all these live in the same table, they are
336 completely independent, and the hash code is computed differently
339 #define RTL_HASH_SIZE 4093
340 static struct attr_hash
*attr_hash_table
[RTL_HASH_SIZE
];
342 /* Here is how primitive or already-shared RTL's hash
344 #define RTL_HASH(RTL) ((intptr_t) (RTL) & 0777777)
346 /* Add an entry to the hash table for RTL with hash code HASHCODE. */
349 attr_hash_add_rtx (unsigned int hashcode
, rtx rtl
)
353 h
= XOBNEW (hash_obstack
, struct attr_hash
);
354 h
->hashcode
= hashcode
;
356 h
->next
= attr_hash_table
[hashcode
% RTL_HASH_SIZE
];
357 attr_hash_table
[hashcode
% RTL_HASH_SIZE
] = h
;
360 /* Add an entry to the hash table for STRING with hash code HASHCODE. */
363 attr_hash_add_string (unsigned int hashcode
, char *str
)
367 h
= XOBNEW (hash_obstack
, struct attr_hash
);
368 h
->hashcode
= -hashcode
;
370 h
->next
= attr_hash_table
[hashcode
% RTL_HASH_SIZE
];
371 attr_hash_table
[hashcode
% RTL_HASH_SIZE
] = h
;
374 /* Generate an RTL expression, but avoid duplicates.
375 Set the ATTR_PERMANENT_P flag for these permanent objects.
377 In some cases we cannot uniquify; then we return an ordinary
378 impermanent rtx with ATTR_PERMANENT_P clear.
382 rtx attr_rtx (code, [element1, ..., elementn]) */
385 attr_rtx_1 (enum rtx_code code
, va_list p
)
387 rtx rt_val
= NULL_RTX
;/* RTX to return to caller... */
388 unsigned int hashcode
;
390 struct obstack
*old_obstack
= rtl_obstack
;
392 /* For each of several cases, search the hash table for an existing entry.
393 Use that entry if one is found; otherwise create a new RTL and add it
396 if (GET_RTX_CLASS (code
) == RTX_UNARY
)
398 rtx arg0
= va_arg (p
, rtx
);
400 /* A permanent object cannot point to impermanent ones. */
401 if (! ATTR_PERMANENT_P (arg0
))
403 rt_val
= rtx_alloc (code
);
404 XEXP (rt_val
, 0) = arg0
;
408 hashcode
= ((HOST_WIDE_INT
) code
+ RTL_HASH (arg0
));
409 for (h
= attr_hash_table
[hashcode
% RTL_HASH_SIZE
]; h
; h
= h
->next
)
410 if (h
->hashcode
== hashcode
411 && GET_CODE (h
->u
.rtl
) == code
412 && XEXP (h
->u
.rtl
, 0) == arg0
)
417 rtl_obstack
= hash_obstack
;
418 rt_val
= rtx_alloc (code
);
419 XEXP (rt_val
, 0) = arg0
;
422 else if (GET_RTX_CLASS (code
) == RTX_BIN_ARITH
423 || GET_RTX_CLASS (code
) == RTX_COMM_ARITH
424 || GET_RTX_CLASS (code
) == RTX_COMPARE
425 || GET_RTX_CLASS (code
) == RTX_COMM_COMPARE
)
427 rtx arg0
= va_arg (p
, rtx
);
428 rtx arg1
= va_arg (p
, rtx
);
430 /* A permanent object cannot point to impermanent ones. */
431 if (! ATTR_PERMANENT_P (arg0
) || ! ATTR_PERMANENT_P (arg1
))
433 rt_val
= rtx_alloc (code
);
434 XEXP (rt_val
, 0) = arg0
;
435 XEXP (rt_val
, 1) = arg1
;
439 hashcode
= ((HOST_WIDE_INT
) code
+ RTL_HASH (arg0
) + RTL_HASH (arg1
));
440 for (h
= attr_hash_table
[hashcode
% RTL_HASH_SIZE
]; h
; h
= h
->next
)
441 if (h
->hashcode
== hashcode
442 && GET_CODE (h
->u
.rtl
) == code
443 && XEXP (h
->u
.rtl
, 0) == arg0
444 && XEXP (h
->u
.rtl
, 1) == arg1
)
449 rtl_obstack
= hash_obstack
;
450 rt_val
= rtx_alloc (code
);
451 XEXP (rt_val
, 0) = arg0
;
452 XEXP (rt_val
, 1) = arg1
;
455 else if (code
== SYMBOL_REF
456 || (GET_RTX_LENGTH (code
) == 1
457 && GET_RTX_FORMAT (code
)[0] == 's'))
459 char *arg0
= va_arg (p
, char *);
461 arg0
= DEF_ATTR_STRING (arg0
);
463 hashcode
= ((HOST_WIDE_INT
) code
+ RTL_HASH (arg0
));
464 for (h
= attr_hash_table
[hashcode
% RTL_HASH_SIZE
]; h
; h
= h
->next
)
465 if (h
->hashcode
== hashcode
466 && GET_CODE (h
->u
.rtl
) == code
467 && XSTR (h
->u
.rtl
, 0) == arg0
)
472 rtl_obstack
= hash_obstack
;
473 rt_val
= rtx_alloc (code
);
474 XSTR (rt_val
, 0) = arg0
;
475 if (code
== SYMBOL_REF
)
477 X0EXP (rt_val
, 1) = NULL_RTX
;
478 X0EXP (rt_val
, 2) = NULL_RTX
;
482 else if (GET_RTX_LENGTH (code
) == 2
483 && GET_RTX_FORMAT (code
)[0] == 's'
484 && GET_RTX_FORMAT (code
)[1] == 's')
486 char *arg0
= va_arg (p
, char *);
487 char *arg1
= va_arg (p
, char *);
489 hashcode
= ((HOST_WIDE_INT
) code
+ RTL_HASH (arg0
) + RTL_HASH (arg1
));
490 for (h
= attr_hash_table
[hashcode
% RTL_HASH_SIZE
]; h
; h
= h
->next
)
491 if (h
->hashcode
== hashcode
492 && GET_CODE (h
->u
.rtl
) == code
493 && XSTR (h
->u
.rtl
, 0) == arg0
494 && XSTR (h
->u
.rtl
, 1) == arg1
)
499 rtl_obstack
= hash_obstack
;
500 rt_val
= rtx_alloc (code
);
501 XSTR (rt_val
, 0) = arg0
;
502 XSTR (rt_val
, 1) = arg1
;
505 else if (code
== CONST_INT
)
507 HOST_WIDE_INT arg0
= va_arg (p
, HOST_WIDE_INT
);
517 int i
; /* Array indices... */
518 const char *fmt
; /* Current rtx's format... */
520 rt_val
= rtx_alloc (code
); /* Allocate the storage space. */
522 fmt
= GET_RTX_FORMAT (code
); /* Find the right format... */
523 for (i
= 0; i
< GET_RTX_LENGTH (code
); i
++)
527 case '0': /* Unused field. */
530 case 'i': /* An integer? */
531 XINT (rt_val
, i
) = va_arg (p
, int);
534 case 'w': /* A wide integer? */
535 XWINT (rt_val
, i
) = va_arg (p
, HOST_WIDE_INT
);
538 case 's': /* A string? */
539 XSTR (rt_val
, i
) = va_arg (p
, char *);
542 case 'e': /* An expression? */
543 case 'u': /* An insn? Same except when printing. */
544 XEXP (rt_val
, i
) = va_arg (p
, rtx
);
547 case 'E': /* An RTX vector? */
548 XVEC (rt_val
, i
) = va_arg (p
, rtvec
);
558 rtl_obstack
= old_obstack
;
559 attr_hash_add_rtx (hashcode
, rt_val
);
560 ATTR_PERMANENT_P (rt_val
) = 1;
565 attr_rtx (enum rtx_code code
, ...)
571 result
= attr_rtx_1 (code
, p
);
576 /* Create a new string printed with the printf line arguments into a space
577 of at most LEN bytes:
579 rtx attr_printf (len, format, [arg1, ..., argn]) */
582 attr_printf (unsigned int len
, const char *fmt
, ...)
589 gcc_assert (len
< sizeof str
); /* Leave room for \0. */
591 vsprintf (str
, fmt
, p
);
594 return DEF_ATTR_STRING (str
);
598 attr_eq (const char *name
, const char *value
)
600 return attr_rtx (EQ_ATTR
, DEF_ATTR_STRING (name
), DEF_ATTR_STRING (value
));
606 return XSTR (make_numeric_value (n
), 0);
609 /* Return a permanent (possibly shared) copy of a string STR (not assumed
610 to be null terminated) with LEN bytes. */
613 attr_string (const char *str
, int len
)
616 unsigned int hashcode
;
620 /* Compute the hash code. */
621 hashcode
= (len
+ 1) * 613U + (unsigned) str
[0];
622 for (i
= 1; i
< len
; i
+= 2)
623 hashcode
= ((hashcode
* 613) + (unsigned) str
[i
]);
624 if ((int) hashcode
< 0)
625 hashcode
= -hashcode
;
627 /* Search the table for the string. */
628 for (h
= attr_hash_table
[hashcode
% RTL_HASH_SIZE
]; h
; h
= h
->next
)
629 if (h
->hashcode
== -hashcode
&& h
->u
.str
[0] == str
[0]
630 && !strncmp (h
->u
.str
, str
, len
))
631 return h
->u
.str
; /* <-- return if found. */
633 /* Not found; create a permanent copy and add it to the hash table. */
634 new_str
= XOBNEWVAR (hash_obstack
, char, len
+ 1);
635 memcpy (new_str
, str
, len
);
637 attr_hash_add_string (hashcode
, new_str
);
638 copy_md_ptr_loc (new_str
, str
);
640 return new_str
; /* Return the new string. */
643 /* Check two rtx's for equality of contents,
644 taking advantage of the fact that if both are hashed
645 then they can't be equal unless they are the same object. */
648 attr_equal_p (rtx x
, rtx y
)
650 return (x
== y
|| (! (ATTR_PERMANENT_P (x
) && ATTR_PERMANENT_P (y
))
651 && rtx_equal_p (x
, y
)));
654 /* Copy an attribute value expression,
655 descending to all depths, but not copying any
656 permanent hashed subexpressions. */
659 attr_copy_rtx (rtx orig
)
664 const char *format_ptr
;
666 /* No need to copy a permanent object. */
667 if (ATTR_PERMANENT_P (orig
))
670 code
= GET_CODE (orig
);
687 copy
= rtx_alloc (code
);
688 PUT_MODE (copy
, GET_MODE (orig
));
689 ATTR_IND_SIMPLIFIED_P (copy
) = ATTR_IND_SIMPLIFIED_P (orig
);
690 ATTR_CURR_SIMPLIFIED_P (copy
) = ATTR_CURR_SIMPLIFIED_P (orig
);
691 ATTR_PERMANENT_P (copy
) = ATTR_PERMANENT_P (orig
);
693 format_ptr
= GET_RTX_FORMAT (GET_CODE (copy
));
695 for (i
= 0; i
< GET_RTX_LENGTH (GET_CODE (copy
)); i
++)
697 switch (*format_ptr
++)
700 XEXP (copy
, i
) = XEXP (orig
, i
);
701 if (XEXP (orig
, i
) != NULL
)
702 XEXP (copy
, i
) = attr_copy_rtx (XEXP (orig
, i
));
707 XVEC (copy
, i
) = XVEC (orig
, i
);
708 if (XVEC (orig
, i
) != NULL
)
710 XVEC (copy
, i
) = rtvec_alloc (XVECLEN (orig
, i
));
711 for (j
= 0; j
< XVECLEN (copy
, i
); j
++)
712 XVECEXP (copy
, i
, j
) = attr_copy_rtx (XVECEXP (orig
, i
, j
));
718 XINT (copy
, i
) = XINT (orig
, i
);
722 XWINT (copy
, i
) = XWINT (orig
, i
);
727 XSTR (copy
, i
) = XSTR (orig
, i
);
737 /* Given a test expression for an attribute, ensure it is validly formed.
738 IS_CONST indicates whether the expression is constant for each compiler
739 run (a constant expression may not test any particular insn).
741 Convert (eq_attr "att" "a1,a2") to (ior (eq_attr ... ) (eq_attrq ..))
742 and (eq_attr "att" "!a1") to (not (eq_attr "att" "a1")). Do the latter
743 test first so that (eq_attr "att" "!a1,a2,a3") works as expected.
745 Update the string address in EQ_ATTR expression to be the same used
746 in the attribute (or `alternative_name') to speed up subsequent
747 `find_attr' calls and eliminate most `strcmp' calls.
749 Return the new expression, if any. */
752 check_attr_test (rtx exp
, int is_const
, int lineno
)
754 struct attr_desc
*attr
;
755 struct attr_value
*av
;
756 const char *name_ptr
, *p
;
759 switch (GET_CODE (exp
))
762 /* Handle negation test. */
763 if (XSTR (exp
, 1)[0] == '!')
764 return check_attr_test (attr_rtx (NOT
,
765 attr_eq (XSTR (exp
, 0),
769 else if (n_comma_elts (XSTR (exp
, 1)) == 1)
771 attr
= find_attr (&XSTR (exp
, 0), 0);
774 if (! strcmp (XSTR (exp
, 0), "alternative"))
775 return mk_attr_alt (1 << atoi (XSTR (exp
, 1)));
777 fatal ("unknown attribute `%s' in EQ_ATTR", XSTR (exp
, 0));
780 if (is_const
&& ! attr
->is_const
)
781 fatal ("constant expression uses insn attribute `%s' in EQ_ATTR",
784 /* Copy this just to make it permanent,
785 so expressions using it can be permanent too. */
786 exp
= attr_eq (XSTR (exp
, 0), XSTR (exp
, 1));
788 /* It shouldn't be possible to simplify the value given to a
789 constant attribute, so don't expand this until it's time to
790 write the test expression. */
792 ATTR_IND_SIMPLIFIED_P (exp
) = 1;
794 if (attr
->is_numeric
)
796 for (p
= XSTR (exp
, 1); *p
; p
++)
798 fatal ("attribute `%s' takes only numeric values",
803 for (av
= attr
->first_value
; av
; av
= av
->next
)
804 if (GET_CODE (av
->value
) == CONST_STRING
805 && ! strcmp (XSTR (exp
, 1), XSTR (av
->value
, 0)))
809 fatal ("unknown value `%s' for `%s' attribute",
810 XSTR (exp
, 1), XSTR (exp
, 0));
815 if (! strcmp (XSTR (exp
, 0), "alternative"))
819 name_ptr
= XSTR (exp
, 1);
820 while ((p
= next_comma_elt (&name_ptr
)) != NULL
)
821 set
|= 1 << atoi (p
);
823 return mk_attr_alt (set
);
827 /* Make an IOR tree of the possible values. */
829 name_ptr
= XSTR (exp
, 1);
830 while ((p
= next_comma_elt (&name_ptr
)) != NULL
)
832 newexp
= attr_eq (XSTR (exp
, 0), p
);
833 orexp
= insert_right_side (IOR
, orexp
, newexp
, -2, -2);
836 return check_attr_test (orexp
, is_const
, lineno
);
845 /* Either TRUE or FALSE. */
853 XEXP (exp
, 0) = check_attr_test (XEXP (exp
, 0), is_const
, lineno
);
854 XEXP (exp
, 1) = check_attr_test (XEXP (exp
, 1), is_const
, lineno
);
858 XEXP (exp
, 0) = check_attr_test (XEXP (exp
, 0), is_const
, lineno
);
862 exp
= attr_rtx (MATCH_TEST
, XSTR (exp
, 0));
863 ATTR_IND_SIMPLIFIED_P (exp
) = 1;
868 fatal ("RTL operator \"%s\" not valid in constant attribute test",
869 GET_RTX_NAME (GET_CODE (exp
)));
870 /* These cases can't be simplified. */
871 ATTR_IND_SIMPLIFIED_P (exp
) = 1;
874 case LE
: case LT
: case GT
: case GE
:
875 case LEU
: case LTU
: case GTU
: case GEU
:
877 if (GET_CODE (XEXP (exp
, 0)) == SYMBOL_REF
878 && GET_CODE (XEXP (exp
, 1)) == SYMBOL_REF
)
879 exp
= attr_rtx (GET_CODE (exp
),
880 attr_rtx (SYMBOL_REF
, XSTR (XEXP (exp
, 0), 0)),
881 attr_rtx (SYMBOL_REF
, XSTR (XEXP (exp
, 1), 0)));
882 /* These cases can't be simplified. */
883 ATTR_IND_SIMPLIFIED_P (exp
) = 1;
889 /* These cases are valid for constant attributes, but can't be
891 exp
= attr_rtx (SYMBOL_REF
, XSTR (exp
, 0));
892 ATTR_IND_SIMPLIFIED_P (exp
) = 1;
896 fatal ("RTL operator \"%s\" not valid in attribute test",
897 GET_RTX_NAME (GET_CODE (exp
)));
903 /* Given an expression, ensure that it is validly formed and that all named
904 attribute values are valid for the given attribute. Issue a fatal error
905 if not. If no attribute is specified, assume a numeric attribute.
907 Return a perhaps modified replacement expression for the value. */
910 check_attr_value (rtx exp
, struct attr_desc
*attr
)
912 struct attr_value
*av
;
916 switch (GET_CODE (exp
))
919 if (attr
&& ! attr
->is_numeric
)
921 error_with_line (attr
->lineno
,
922 "CONST_INT not valid for non-numeric attribute %s",
927 if (INTVAL (exp
) < 0)
929 error_with_line (attr
->lineno
,
930 "negative numeric value specified for attribute %s",
937 if (! strcmp (XSTR (exp
, 0), "*"))
940 if (attr
== 0 || attr
->is_numeric
)
946 error_with_line (attr
? attr
->lineno
: 0,
947 "non-numeric value for numeric attribute %s",
948 attr
? attr
->name
: "internal");
954 for (av
= attr
->first_value
; av
; av
= av
->next
)
955 if (GET_CODE (av
->value
) == CONST_STRING
956 && ! strcmp (XSTR (av
->value
, 0), XSTR (exp
, 0)))
960 error_with_line (attr
->lineno
,
961 "unknown value `%s' for `%s' attribute",
962 XSTR (exp
, 0), attr
? attr
->name
: "internal");
966 XEXP (exp
, 0) = check_attr_test (XEXP (exp
, 0),
967 attr
? attr
->is_const
: 0,
968 attr
? attr
->lineno
: 0);
969 XEXP (exp
, 1) = check_attr_value (XEXP (exp
, 1), attr
);
970 XEXP (exp
, 2) = check_attr_value (XEXP (exp
, 2), attr
);
978 if (attr
&& !attr
->is_numeric
)
980 error_with_line (attr
->lineno
,
981 "invalid operation `%s' for non-numeric"
982 " attribute value", GET_RTX_NAME (GET_CODE (exp
)));
989 XEXP (exp
, 0) = check_attr_value (XEXP (exp
, 0), attr
);
990 XEXP (exp
, 1) = check_attr_value (XEXP (exp
, 1), attr
);
999 XEXP (exp
, 0) = check_attr_value (XEXP (exp
, 0), attr
);
1003 if (XVECLEN (exp
, 0) % 2 != 0)
1005 error_with_line (attr
->lineno
,
1006 "first operand of COND must have even length");
1010 for (i
= 0; i
< XVECLEN (exp
, 0); i
+= 2)
1012 XVECEXP (exp
, 0, i
) = check_attr_test (XVECEXP (exp
, 0, i
),
1013 attr
? attr
->is_const
: 0,
1014 attr
? attr
->lineno
: 0);
1015 XVECEXP (exp
, 0, i
+ 1)
1016 = check_attr_value (XVECEXP (exp
, 0, i
+ 1), attr
);
1019 XEXP (exp
, 1) = check_attr_value (XEXP (exp
, 1), attr
);
1024 struct attr_desc
*attr2
= find_attr (&XSTR (exp
, 0), 0);
1026 error_with_line (attr
? attr
->lineno
: 0,
1027 "unknown attribute `%s' in ATTR",
1029 else if (attr
&& attr
->is_const
&& ! attr2
->is_const
)
1030 error_with_line (attr
->lineno
,
1031 "non-constant attribute `%s' referenced from `%s'",
1032 XSTR (exp
, 0), attr
->name
);
1034 && attr
->is_numeric
!= attr2
->is_numeric
)
1035 error_with_line (attr
->lineno
,
1036 "numeric attribute mismatch calling `%s' from `%s'",
1037 XSTR (exp
, 0), attr
->name
);
1042 /* A constant SYMBOL_REF is valid as a constant attribute test and
1043 is expanded later by make_canonical into a COND. In a non-constant
1044 attribute test, it is left be. */
1045 return attr_rtx (SYMBOL_REF
, XSTR (exp
, 0));
1048 error_with_line (attr
? attr
->lineno
: 0,
1049 "invalid operation `%s' for attribute value",
1050 GET_RTX_NAME (GET_CODE (exp
)));
1057 /* Given an SET_ATTR_ALTERNATIVE expression, convert to the canonical SET.
1058 It becomes a COND with each test being (eq_attr "alternative" "n") */
1061 convert_set_attr_alternative (rtx exp
, struct insn_def
*id
)
1063 int num_alt
= id
->num_alternatives
;
1067 if (XVECLEN (exp
, 1) != num_alt
)
1069 error_with_line (id
->lineno
,
1070 "bad number of entries in SET_ATTR_ALTERNATIVE, was %d expected %d",
1071 XVECLEN (exp
, 1), num_alt
);
1075 /* Make a COND with all tests but the last. Select the last value via the
1077 condexp
= rtx_alloc (COND
);
1078 XVEC (condexp
, 0) = rtvec_alloc ((num_alt
- 1) * 2);
1080 for (i
= 0; i
< num_alt
- 1; i
++)
1083 p
= attr_numeral (i
);
1085 XVECEXP (condexp
, 0, 2 * i
) = attr_eq (alternative_name
, p
);
1086 XVECEXP (condexp
, 0, 2 * i
+ 1) = XVECEXP (exp
, 1, i
);
1089 XEXP (condexp
, 1) = XVECEXP (exp
, 1, i
);
1091 return attr_rtx (SET
, attr_rtx (ATTR
, XSTR (exp
, 0)), condexp
);
1094 /* Given a SET_ATTR, convert to the appropriate SET. If a comma-separated
1095 list of values is given, convert to SET_ATTR_ALTERNATIVE first. */
1098 convert_set_attr (rtx exp
, struct insn_def
*id
)
1101 const char *name_ptr
;
1105 /* See how many alternative specified. */
1106 n
= n_comma_elts (XSTR (exp
, 1));
1108 return attr_rtx (SET
,
1109 attr_rtx (ATTR
, XSTR (exp
, 0)),
1110 attr_rtx (CONST_STRING
, XSTR (exp
, 1)));
1112 newexp
= rtx_alloc (SET_ATTR_ALTERNATIVE
);
1113 XSTR (newexp
, 0) = XSTR (exp
, 0);
1114 XVEC (newexp
, 1) = rtvec_alloc (n
);
1116 /* Process each comma-separated name. */
1117 name_ptr
= XSTR (exp
, 1);
1119 while ((p
= next_comma_elt (&name_ptr
)) != NULL
)
1120 XVECEXP (newexp
, 1, n
++) = attr_rtx (CONST_STRING
, p
);
1122 return convert_set_attr_alternative (newexp
, id
);
1125 /* Scan all definitions, checking for validity. Also, convert any SET_ATTR
1126 and SET_ATTR_ALTERNATIVE expressions to the corresponding SET
1132 struct insn_def
*id
;
1133 struct attr_desc
*attr
;
1137 for (id
= defs
; id
; id
= id
->next
)
1139 if (XVEC (id
->def
, id
->vec_idx
) == NULL
)
1142 read_md_filename
= id
->filename
;
1143 for (i
= 0; i
< XVECLEN (id
->def
, id
->vec_idx
); i
++)
1145 value
= XVECEXP (id
->def
, id
->vec_idx
, i
);
1146 switch (GET_CODE (value
))
1149 if (GET_CODE (XEXP (value
, 0)) != ATTR
)
1151 error_with_line (id
->lineno
, "bad attribute set");
1156 case SET_ATTR_ALTERNATIVE
:
1157 value
= convert_set_attr_alternative (value
, id
);
1161 value
= convert_set_attr (value
, id
);
1165 error_with_line (id
->lineno
, "invalid attribute code %s",
1166 GET_RTX_NAME (GET_CODE (value
)));
1169 if (value
== NULL_RTX
)
1172 if ((attr
= find_attr (&XSTR (XEXP (value
, 0), 0), 0)) == NULL
)
1174 error_with_line (id
->lineno
, "unknown attribute %s",
1175 XSTR (XEXP (value
, 0), 0));
1179 XVECEXP (id
->def
, id
->vec_idx
, i
) = value
;
1180 XEXP (value
, 1) = check_attr_value (XEXP (value
, 1), attr
);
1185 /* Given a valid expression for an attribute value, remove any IF_THEN_ELSE
1186 expressions by converting them into a COND. This removes cases from this
1187 program. Also, replace an attribute value of "*" with the default attribute
1191 make_canonical (struct attr_desc
*attr
, rtx exp
)
1196 switch (GET_CODE (exp
))
1199 exp
= make_numeric_value (INTVAL (exp
));
1203 if (! strcmp (XSTR (exp
, 0), "*"))
1205 if (attr
== 0 || attr
->default_val
== 0)
1206 fatal ("(attr_value \"*\") used in invalid context");
1207 exp
= attr
->default_val
->value
;
1210 XSTR (exp
, 0) = DEF_ATTR_STRING (XSTR (exp
, 0));
1215 if (!attr
->is_const
|| ATTR_IND_SIMPLIFIED_P (exp
))
1217 /* The SYMBOL_REF is constant for a given run, so mark it as unchanging.
1218 This makes the COND something that won't be considered an arbitrary
1219 expression by walk_attr_value. */
1220 ATTR_IND_SIMPLIFIED_P (exp
) = 1;
1221 exp
= check_attr_value (exp
, attr
);
1225 newexp
= rtx_alloc (COND
);
1226 XVEC (newexp
, 0) = rtvec_alloc (2);
1227 XVECEXP (newexp
, 0, 0) = XEXP (exp
, 0);
1228 XVECEXP (newexp
, 0, 1) = XEXP (exp
, 1);
1230 XEXP (newexp
, 1) = XEXP (exp
, 2);
1233 /* Fall through to COND case since this is now a COND. */
1240 /* First, check for degenerate COND. */
1241 if (XVECLEN (exp
, 0) == 0)
1242 return make_canonical (attr
, XEXP (exp
, 1));
1243 defval
= XEXP (exp
, 1) = make_canonical (attr
, XEXP (exp
, 1));
1245 for (i
= 0; i
< XVECLEN (exp
, 0); i
+= 2)
1247 XVECEXP (exp
, 0, i
) = copy_boolean (XVECEXP (exp
, 0, i
));
1248 XVECEXP (exp
, 0, i
+ 1)
1249 = make_canonical (attr
, XVECEXP (exp
, 0, i
+ 1));
1250 if (! rtx_equal_p (XVECEXP (exp
, 0, i
+ 1), defval
))
1266 copy_boolean (rtx exp
)
1268 if (GET_CODE (exp
) == AND
|| GET_CODE (exp
) == IOR
)
1269 return attr_rtx (GET_CODE (exp
), copy_boolean (XEXP (exp
, 0)),
1270 copy_boolean (XEXP (exp
, 1)));
1271 if (GET_CODE (exp
) == MATCH_OPERAND
)
1273 XSTR (exp
, 1) = DEF_ATTR_STRING (XSTR (exp
, 1));
1274 XSTR (exp
, 2) = DEF_ATTR_STRING (XSTR (exp
, 2));
1276 else if (GET_CODE (exp
) == EQ_ATTR
)
1278 XSTR (exp
, 0) = DEF_ATTR_STRING (XSTR (exp
, 0));
1279 XSTR (exp
, 1) = DEF_ATTR_STRING (XSTR (exp
, 1));
1285 /* Given a value and an attribute description, return a `struct attr_value *'
1286 that represents that value. This is either an existing structure, if the
1287 value has been previously encountered, or a newly-created structure.
1289 `insn_code' is the code of an insn whose attribute has the specified
1290 value (-2 if not processing an insn). We ensure that all insns for
1291 a given value have the same number of alternatives if the value checks
1294 static struct attr_value
*
1295 get_attr_value (rtx value
, struct attr_desc
*attr
, int insn_code
)
1297 struct attr_value
*av
;
1300 value
= make_canonical (attr
, value
);
1301 if (compares_alternatives_p (value
))
1303 if (insn_code
< 0 || insn_alternatives
== NULL
)
1304 fatal ("(eq_attr \"alternatives\" ...) used in non-insn context");
1306 num_alt
= insn_alternatives
[insn_code
];
1309 for (av
= attr
->first_value
; av
; av
= av
->next
)
1310 if (rtx_equal_p (value
, av
->value
)
1311 && (num_alt
== 0 || av
->first_insn
== NULL
1312 || insn_alternatives
[av
->first_insn
->def
->insn_code
]))
1315 av
= oballoc (struct attr_value
);
1317 av
->next
= attr
->first_value
;
1318 attr
->first_value
= av
;
1319 av
->first_insn
= NULL
;
1321 av
->has_asm_insn
= 0;
1326 /* After all DEFINE_DELAYs have been read in, create internal attributes
1327 to generate the required routines.
1329 First, we compute the number of delay slots for each insn (as a COND of
1330 each of the test expressions in DEFINE_DELAYs). Then, if more than one
1331 delay type is specified, we compute a similar function giving the
1332 DEFINE_DELAY ordinal for each insn.
1334 Finally, for each [DEFINE_DELAY, slot #] pair, we compute an attribute that
1335 tells whether a given insn can be in that delay slot.
1337 Normal attribute filling and optimization expands these to contain the
1338 information needed to handle delay slots. */
1341 expand_delays (void)
1343 struct delay_desc
*delay
;
1349 /* First, generate data for `num_delay_slots' function. */
1351 condexp
= rtx_alloc (COND
);
1352 XVEC (condexp
, 0) = rtvec_alloc (num_delays
* 2);
1353 XEXP (condexp
, 1) = make_numeric_value (0);
1355 for (i
= 0, delay
= delays
; delay
; i
+= 2, delay
= delay
->next
)
1357 XVECEXP (condexp
, 0, i
) = XEXP (delay
->def
, 0);
1358 XVECEXP (condexp
, 0, i
+ 1)
1359 = make_numeric_value (XVECLEN (delay
->def
, 1) / 3);
1362 make_internal_attr (num_delay_slots_str
, condexp
, ATTR_NONE
);
1364 /* If more than one delay type, do the same for computing the delay type. */
1367 condexp
= rtx_alloc (COND
);
1368 XVEC (condexp
, 0) = rtvec_alloc (num_delays
* 2);
1369 XEXP (condexp
, 1) = make_numeric_value (0);
1371 for (i
= 0, delay
= delays
; delay
; i
+= 2, delay
= delay
->next
)
1373 XVECEXP (condexp
, 0, i
) = XEXP (delay
->def
, 0);
1374 XVECEXP (condexp
, 0, i
+ 1) = make_numeric_value (delay
->num
);
1377 make_internal_attr (delay_type_str
, condexp
, ATTR_SPECIAL
);
1380 /* For each delay possibility and delay slot, compute an eligibility
1381 attribute for non-annulled insns and for each type of annulled (annul
1382 if true and annul if false). */
1383 for (delay
= delays
; delay
; delay
= delay
->next
)
1385 for (i
= 0; i
< XVECLEN (delay
->def
, 1); i
+= 3)
1387 condexp
= XVECEXP (delay
->def
, 1, i
);
1389 condexp
= false_rtx
;
1390 newexp
= attr_rtx (IF_THEN_ELSE
, condexp
,
1391 make_numeric_value (1), make_numeric_value (0));
1393 p
= attr_printf (sizeof "*delay__" + MAX_DIGITS
* 2,
1394 "*delay_%d_%d", delay
->num
, i
/ 3);
1395 make_internal_attr (p
, newexp
, ATTR_SPECIAL
);
1397 if (have_annul_true
)
1399 condexp
= XVECEXP (delay
->def
, 1, i
+ 1);
1400 if (condexp
== 0) condexp
= false_rtx
;
1401 newexp
= attr_rtx (IF_THEN_ELSE
, condexp
,
1402 make_numeric_value (1),
1403 make_numeric_value (0));
1404 p
= attr_printf (sizeof "*annul_true__" + MAX_DIGITS
* 2,
1405 "*annul_true_%d_%d", delay
->num
, i
/ 3);
1406 make_internal_attr (p
, newexp
, ATTR_SPECIAL
);
1409 if (have_annul_false
)
1411 condexp
= XVECEXP (delay
->def
, 1, i
+ 2);
1412 if (condexp
== 0) condexp
= false_rtx
;
1413 newexp
= attr_rtx (IF_THEN_ELSE
, condexp
,
1414 make_numeric_value (1),
1415 make_numeric_value (0));
1416 p
= attr_printf (sizeof "*annul_false__" + MAX_DIGITS
* 2,
1417 "*annul_false_%d_%d", delay
->num
, i
/ 3);
1418 make_internal_attr (p
, newexp
, ATTR_SPECIAL
);
1424 /* Once all attributes and insns have been read and checked, we construct for
1425 each attribute value a list of all the insns that have that value for
1429 fill_attr (struct attr_desc
*attr
)
1431 struct attr_value
*av
;
1432 struct insn_ent
*ie
;
1433 struct insn_def
*id
;
1437 /* Don't fill constant attributes. The value is independent of
1438 any particular insn. */
1442 for (id
= defs
; id
; id
= id
->next
)
1444 /* If no value is specified for this insn for this attribute, use the
1447 if (XVEC (id
->def
, id
->vec_idx
))
1448 for (i
= 0; i
< XVECLEN (id
->def
, id
->vec_idx
); i
++)
1449 if (! strcmp_check (XSTR (XEXP (XVECEXP (id
->def
, id
->vec_idx
, i
), 0), 0),
1451 value
= XEXP (XVECEXP (id
->def
, id
->vec_idx
, i
), 1);
1454 av
= attr
->default_val
;
1456 av
= get_attr_value (value
, attr
, id
->insn_code
);
1458 ie
= oballoc (struct insn_ent
);
1460 insert_insn_ent (av
, ie
);
1464 /* Given an expression EXP, see if it is a COND or IF_THEN_ELSE that has a
1465 test that checks relative positions of insns (uses MATCH_DUP or PC).
1466 If so, replace it with what is obtained by passing the expression to
1467 ADDRESS_FN. If not but it is a COND or IF_THEN_ELSE, call this routine
1468 recursively on each value (including the default value). Otherwise,
1469 return the value returned by NO_ADDRESS_FN applied to EXP. */
1472 substitute_address (rtx exp
, rtx (*no_address_fn
) (rtx
),
1473 rtx (*address_fn
) (rtx
))
1478 if (GET_CODE (exp
) == COND
)
1480 /* See if any tests use addresses. */
1482 for (i
= 0; i
< XVECLEN (exp
, 0); i
+= 2)
1483 walk_attr_value (XVECEXP (exp
, 0, i
));
1486 return (*address_fn
) (exp
);
1488 /* Make a new copy of this COND, replacing each element. */
1489 newexp
= rtx_alloc (COND
);
1490 XVEC (newexp
, 0) = rtvec_alloc (XVECLEN (exp
, 0));
1491 for (i
= 0; i
< XVECLEN (exp
, 0); i
+= 2)
1493 XVECEXP (newexp
, 0, i
) = XVECEXP (exp
, 0, i
);
1494 XVECEXP (newexp
, 0, i
+ 1)
1495 = substitute_address (XVECEXP (exp
, 0, i
+ 1),
1496 no_address_fn
, address_fn
);
1499 XEXP (newexp
, 1) = substitute_address (XEXP (exp
, 1),
1500 no_address_fn
, address_fn
);
1505 else if (GET_CODE (exp
) == IF_THEN_ELSE
)
1508 walk_attr_value (XEXP (exp
, 0));
1510 return (*address_fn
) (exp
);
1512 return attr_rtx (IF_THEN_ELSE
,
1513 substitute_address (XEXP (exp
, 0),
1514 no_address_fn
, address_fn
),
1515 substitute_address (XEXP (exp
, 1),
1516 no_address_fn
, address_fn
),
1517 substitute_address (XEXP (exp
, 2),
1518 no_address_fn
, address_fn
));
1521 return (*no_address_fn
) (exp
);
1524 /* Make new attributes from the `length' attribute. The following are made,
1525 each corresponding to a function called from `shorten_branches' or
1528 *insn_default_length This is the length of the insn to be returned
1529 by `get_attr_length' before `shorten_branches'
1530 has been called. In each case where the length
1531 depends on relative addresses, the largest
1532 possible is used. This routine is also used
1533 to compute the initial size of the insn.
1535 *insn_variable_length_p This returns 1 if the insn's length depends
1536 on relative addresses, zero otherwise.
1538 *insn_current_length This is only called when it is known that the
1539 insn has a variable length and returns the
1540 current length, based on relative addresses.
1544 make_length_attrs (void)
1546 static const char *new_names
[] =
1548 "*insn_default_length",
1550 "*insn_variable_length_p",
1551 "*insn_current_length"
1553 static rtx (*const no_address_fn
[]) (rtx
)
1554 = {identity_fn
,identity_fn
, zero_fn
, zero_fn
};
1555 static rtx (*const address_fn
[]) (rtx
)
1556 = {max_fn
, min_fn
, one_fn
, identity_fn
};
1558 struct attr_desc
*length_attr
, *new_attr
;
1559 struct attr_value
*av
, *new_av
;
1560 struct insn_ent
*ie
, *new_ie
;
1562 /* See if length attribute is defined. If so, it must be numeric. Make
1563 it special so we don't output anything for it. */
1564 length_attr
= find_attr (&length_str
, 0);
1565 if (length_attr
== 0)
1568 if (! length_attr
->is_numeric
)
1569 fatal ("length attribute must be numeric");
1571 length_attr
->is_const
= 0;
1572 length_attr
->is_special
= 1;
1574 /* Make each new attribute, in turn. */
1575 for (i
= 0; i
< ARRAY_SIZE (new_names
); i
++)
1577 make_internal_attr (new_names
[i
],
1578 substitute_address (length_attr
->default_val
->value
,
1579 no_address_fn
[i
], address_fn
[i
]),
1581 new_attr
= find_attr (&new_names
[i
], 0);
1582 for (av
= length_attr
->first_value
; av
; av
= av
->next
)
1583 for (ie
= av
->first_insn
; ie
; ie
= ie
->next
)
1585 new_av
= get_attr_value (substitute_address (av
->value
,
1588 new_attr
, ie
->def
->insn_code
);
1589 new_ie
= oballoc (struct insn_ent
);
1590 new_ie
->def
= ie
->def
;
1591 insert_insn_ent (new_av
, new_ie
);
1596 /* Utility functions called from above routine. */
1599 identity_fn (rtx exp
)
1605 zero_fn (rtx exp ATTRIBUTE_UNUSED
)
1607 return make_numeric_value (0);
1611 one_fn (rtx exp ATTRIBUTE_UNUSED
)
1613 return make_numeric_value (1);
1620 return make_numeric_value (max_attr_value (exp
, &unknown
));
1627 return make_numeric_value (min_attr_value (exp
, &unknown
));
1631 write_length_unit_log (FILE *outf
)
1633 struct attr_desc
*length_attr
= find_attr (&length_str
, 0);
1634 struct attr_value
*av
;
1635 struct insn_ent
*ie
;
1636 unsigned int length_unit_log
, length_or
;
1641 length_or
= or_attr_value (length_attr
->default_val
->value
, &unknown
);
1642 for (av
= length_attr
->first_value
; av
; av
= av
->next
)
1643 for (ie
= av
->first_insn
; ie
; ie
= ie
->next
)
1644 length_or
|= or_attr_value (av
->value
, &unknown
);
1647 if (length_attr
== NULL
|| unknown
)
1648 length_unit_log
= 0;
1651 length_or
= ~length_or
;
1652 for (length_unit_log
= 0; length_or
& 1; length_or
>>= 1)
1655 fprintf (outf
, "EXPORTED_CONST int length_unit_log = %u;\n", length_unit_log
);
1658 /* Compute approximate cost of the expression. Used to decide whether
1659 expression is cheap enough for inline. */
1661 attr_rtx_cost (rtx x
)
1667 code
= GET_CODE (x
);
1680 /* Alternatives don't result into function call. */
1681 if (!strcmp_check (XSTR (x
, 0), alternative_name
))
1688 const char *fmt
= GET_RTX_FORMAT (code
);
1689 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
1695 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
1696 cost
+= attr_rtx_cost (XVECEXP (x
, i
, j
));
1699 cost
+= attr_rtx_cost (XEXP (x
, i
));
1709 /* Take a COND expression and see if any of the conditions in it can be
1710 simplified. If any are known true or known false for the particular insn
1711 code, the COND can be further simplified.
1713 Also call ourselves on any COND operations that are values of this COND.
1715 We do not modify EXP; rather, we make and return a new rtx. */
1718 simplify_cond (rtx exp
, int insn_code
, int insn_index
)
1721 /* We store the desired contents here,
1722 then build a new expression if they don't match EXP. */
1723 rtx defval
= XEXP (exp
, 1);
1724 rtx new_defval
= XEXP (exp
, 1);
1725 int len
= XVECLEN (exp
, 0);
1726 rtx
*tests
= XNEWVEC (rtx
, len
);
1730 /* This lets us free all storage allocated below, if appropriate. */
1731 obstack_finish (rtl_obstack
);
1733 memcpy (tests
, XVEC (exp
, 0)->elem
, len
* sizeof (rtx
));
1735 /* See if default value needs simplification. */
1736 if (GET_CODE (defval
) == COND
)
1737 new_defval
= simplify_cond (defval
, insn_code
, insn_index
);
1739 /* Simplify the subexpressions, and see what tests we can get rid of. */
1741 for (i
= 0; i
< len
; i
+= 2)
1743 rtx newtest
, newval
;
1745 /* Simplify this test. */
1746 newtest
= simplify_test_exp_in_temp (tests
[i
], insn_code
, insn_index
);
1749 newval
= tests
[i
+ 1];
1750 /* See if this value may need simplification. */
1751 if (GET_CODE (newval
) == COND
)
1752 newval
= simplify_cond (newval
, insn_code
, insn_index
);
1754 /* Look for ways to delete or combine this test. */
1755 if (newtest
== true_rtx
)
1757 /* If test is true, make this value the default
1758 and discard this + any following tests. */
1760 defval
= tests
[i
+ 1];
1761 new_defval
= newval
;
1764 else if (newtest
== false_rtx
)
1766 /* If test is false, discard it and its value. */
1767 for (j
= i
; j
< len
- 2; j
++)
1768 tests
[j
] = tests
[j
+ 2];
1773 else if (i
> 0 && attr_equal_p (newval
, tests
[i
- 1]))
1775 /* If this value and the value for the prev test are the same,
1779 = insert_right_side (IOR
, tests
[i
- 2], newtest
,
1780 insn_code
, insn_index
);
1782 /* Delete this test/value. */
1783 for (j
= i
; j
< len
- 2; j
++)
1784 tests
[j
] = tests
[j
+ 2];
1790 tests
[i
+ 1] = newval
;
1793 /* If the last test in a COND has the same value
1794 as the default value, that test isn't needed. */
1796 while (len
> 0 && attr_equal_p (tests
[len
- 1], new_defval
))
1799 /* See if we changed anything. */
1800 if (len
!= XVECLEN (exp
, 0) || new_defval
!= XEXP (exp
, 1))
1803 for (i
= 0; i
< len
; i
++)
1804 if (! attr_equal_p (tests
[i
], XVECEXP (exp
, 0, i
)))
1812 if (GET_CODE (defval
) == COND
)
1813 ret
= simplify_cond (defval
, insn_code
, insn_index
);
1821 rtx newexp
= rtx_alloc (COND
);
1823 XVEC (newexp
, 0) = rtvec_alloc (len
);
1824 memcpy (XVEC (newexp
, 0)->elem
, tests
, len
* sizeof (rtx
));
1825 XEXP (newexp
, 1) = new_defval
;
1832 /* Remove an insn entry from an attribute value. */
1835 remove_insn_ent (struct attr_value
*av
, struct insn_ent
*ie
)
1837 struct insn_ent
*previe
;
1839 if (av
->first_insn
== ie
)
1840 av
->first_insn
= ie
->next
;
1843 for (previe
= av
->first_insn
; previe
->next
!= ie
; previe
= previe
->next
)
1845 previe
->next
= ie
->next
;
1849 if (ie
->def
->insn_code
== -1)
1850 av
->has_asm_insn
= 0;
1855 /* Insert an insn entry in an attribute value list. */
1858 insert_insn_ent (struct attr_value
*av
, struct insn_ent
*ie
)
1860 ie
->next
= av
->first_insn
;
1861 av
->first_insn
= ie
;
1863 if (ie
->def
->insn_code
== -1)
1864 av
->has_asm_insn
= 1;
1869 /* This is a utility routine to take an expression that is a tree of either
1870 AND or IOR expressions and insert a new term. The new term will be
1871 inserted at the right side of the first node whose code does not match
1872 the root. A new node will be created with the root's code. Its left
1873 side will be the old right side and its right side will be the new
1876 If the `term' is itself a tree, all its leaves will be inserted. */
1879 insert_right_side (enum rtx_code code
, rtx exp
, rtx term
, int insn_code
, int insn_index
)
1883 /* Avoid consing in some special cases. */
1884 if (code
== AND
&& term
== true_rtx
)
1886 if (code
== AND
&& term
== false_rtx
)
1888 if (code
== AND
&& exp
== true_rtx
)
1890 if (code
== AND
&& exp
== false_rtx
)
1892 if (code
== IOR
&& term
== true_rtx
)
1894 if (code
== IOR
&& term
== false_rtx
)
1896 if (code
== IOR
&& exp
== true_rtx
)
1898 if (code
== IOR
&& exp
== false_rtx
)
1900 if (attr_equal_p (exp
, term
))
1903 if (GET_CODE (term
) == code
)
1905 exp
= insert_right_side (code
, exp
, XEXP (term
, 0),
1906 insn_code
, insn_index
);
1907 exp
= insert_right_side (code
, exp
, XEXP (term
, 1),
1908 insn_code
, insn_index
);
1913 if (GET_CODE (exp
) == code
)
1915 rtx new_rtx
= insert_right_side (code
, XEXP (exp
, 1),
1916 term
, insn_code
, insn_index
);
1917 if (new_rtx
!= XEXP (exp
, 1))
1918 /* Make a copy of this expression and call recursively. */
1919 newexp
= attr_rtx (code
, XEXP (exp
, 0), new_rtx
);
1925 /* Insert the new term. */
1926 newexp
= attr_rtx (code
, exp
, term
);
1929 return simplify_test_exp_in_temp (newexp
, insn_code
, insn_index
);
1932 /* If we have an expression which AND's a bunch of
1933 (not (eq_attrq "alternative" "n"))
1934 terms, we may have covered all or all but one of the possible alternatives.
1935 If so, we can optimize. Similarly for IOR's of EQ_ATTR.
1937 This routine is passed an expression and either AND or IOR. It returns a
1938 bitmask indicating which alternatives are mentioned within EXP. */
1941 compute_alternative_mask (rtx exp
, enum rtx_code code
)
1944 if (GET_CODE (exp
) == code
)
1945 return compute_alternative_mask (XEXP (exp
, 0), code
)
1946 | compute_alternative_mask (XEXP (exp
, 1), code
);
1948 else if (code
== AND
&& GET_CODE (exp
) == NOT
1949 && GET_CODE (XEXP (exp
, 0)) == EQ_ATTR
1950 && XSTR (XEXP (exp
, 0), 0) == alternative_name
)
1951 string
= XSTR (XEXP (exp
, 0), 1);
1953 else if (code
== IOR
&& GET_CODE (exp
) == EQ_ATTR
1954 && XSTR (exp
, 0) == alternative_name
)
1955 string
= XSTR (exp
, 1);
1957 else if (GET_CODE (exp
) == EQ_ATTR_ALT
)
1959 if (code
== AND
&& XINT (exp
, 1))
1960 return XINT (exp
, 0);
1962 if (code
== IOR
&& !XINT (exp
, 1))
1963 return XINT (exp
, 0);
1971 return 1 << (string
[0] - '0');
1972 return 1 << atoi (string
);
1975 /* Given I, a single-bit mask, return RTX to compare the `alternative'
1976 attribute with the value represented by that bit. */
1979 make_alternative_compare (int mask
)
1981 return mk_attr_alt (mask
);
1984 /* If we are processing an (eq_attr "attr" "value") test, we find the value
1985 of "attr" for this insn code. From that value, we can compute a test
1986 showing when the EQ_ATTR will be true. This routine performs that
1987 computation. If a test condition involves an address, we leave the EQ_ATTR
1988 intact because addresses are only valid for the `length' attribute.
1990 EXP is the EQ_ATTR expression and ATTR is the attribute to which
1991 it refers. VALUE is the value of that attribute for the insn
1992 corresponding to INSN_CODE and INSN_INDEX. */
1995 evaluate_eq_attr (rtx exp
, struct attr_desc
*attr
, rtx value
,
1996 int insn_code
, int insn_index
)
2003 while (GET_CODE (value
) == ATTR
)
2005 struct attr_value
*av
= NULL
;
2007 attr
= find_attr (&XSTR (value
, 0), 0);
2009 if (insn_code_values
)
2011 struct attr_value_list
*iv
;
2012 for (iv
= insn_code_values
[insn_code
]; iv
; iv
= iv
->next
)
2013 if (iv
->attr
== attr
)
2021 struct insn_ent
*ie
;
2022 for (av
= attr
->first_value
; av
; av
= av
->next
)
2023 for (ie
= av
->first_insn
; ie
; ie
= ie
->next
)
2024 if (ie
->def
->insn_code
== insn_code
)
2034 switch (GET_CODE (value
))
2037 if (! strcmp_check (XSTR (value
, 0), XSTR (exp
, 1)))
2048 gcc_assert (GET_CODE (exp
) == EQ_ATTR
);
2049 prefix
= attr
->enum_name
? attr
->enum_name
: attr
->name
;
2050 string
= ACONCAT ((prefix
, "_", XSTR (exp
, 1), NULL
));
2051 for (p
= string
; *p
; p
++)
2054 newexp
= attr_rtx (EQ
, value
,
2055 attr_rtx (SYMBOL_REF
,
2056 DEF_ATTR_STRING (string
)));
2061 /* We construct an IOR of all the cases for which the
2062 requested attribute value is present. Since we start with
2063 FALSE, if it is not present, FALSE will be returned.
2065 Each case is the AND of the NOT's of the previous conditions with the
2066 current condition; in the default case the current condition is TRUE.
2068 For each possible COND value, call ourselves recursively.
2070 The extra TRUE and FALSE expressions will be eliminated by another
2071 call to the simplification routine. */
2076 for (i
= 0; i
< XVECLEN (value
, 0); i
+= 2)
2078 rtx this_cond
= simplify_test_exp_in_temp (XVECEXP (value
, 0, i
),
2079 insn_code
, insn_index
);
2081 right
= insert_right_side (AND
, andexp
, this_cond
,
2082 insn_code
, insn_index
);
2083 right
= insert_right_side (AND
, right
,
2084 evaluate_eq_attr (exp
, attr
,
2087 insn_code
, insn_index
),
2088 insn_code
, insn_index
);
2089 orexp
= insert_right_side (IOR
, orexp
, right
,
2090 insn_code
, insn_index
);
2092 /* Add this condition into the AND expression. */
2093 newexp
= attr_rtx (NOT
, this_cond
);
2094 andexp
= insert_right_side (AND
, andexp
, newexp
,
2095 insn_code
, insn_index
);
2098 /* Handle the default case. */
2099 right
= insert_right_side (AND
, andexp
,
2100 evaluate_eq_attr (exp
, attr
, XEXP (value
, 1),
2101 insn_code
, insn_index
),
2102 insn_code
, insn_index
);
2103 newexp
= insert_right_side (IOR
, orexp
, right
, insn_code
, insn_index
);
2110 /* If uses an address, must return original expression. But set the
2111 ATTR_IND_SIMPLIFIED_P bit so we don't try to simplify it again. */
2114 walk_attr_value (newexp
);
2118 if (! ATTR_IND_SIMPLIFIED_P (exp
))
2119 return copy_rtx_unchanging (exp
);
2126 /* This routine is called when an AND of a term with a tree of AND's is
2127 encountered. If the term or its complement is present in the tree, it
2128 can be replaced with TRUE or FALSE, respectively.
2130 Note that (eq_attr "att" "v1") and (eq_attr "att" "v2") cannot both
2131 be true and hence are complementary.
2133 There is one special case: If we see
2134 (and (not (eq_attr "att" "v1"))
2135 (eq_attr "att" "v2"))
2136 this can be replaced by (eq_attr "att" "v2"). To do this we need to
2137 replace the term, not anything in the AND tree. So we pass a pointer to
2141 simplify_and_tree (rtx exp
, rtx
*pterm
, int insn_code
, int insn_index
)
2146 int left_eliminates_term
, right_eliminates_term
;
2148 if (GET_CODE (exp
) == AND
)
2150 left
= simplify_and_tree (XEXP (exp
, 0), pterm
, insn_code
, insn_index
);
2151 right
= simplify_and_tree (XEXP (exp
, 1), pterm
, insn_code
, insn_index
);
2152 if (left
!= XEXP (exp
, 0) || right
!= XEXP (exp
, 1))
2154 newexp
= attr_rtx (AND
, left
, right
);
2156 exp
= simplify_test_exp_in_temp (newexp
, insn_code
, insn_index
);
2160 else if (GET_CODE (exp
) == IOR
)
2162 /* For the IOR case, we do the same as above, except that we can
2163 only eliminate `term' if both sides of the IOR would do so. */
2165 left
= simplify_and_tree (XEXP (exp
, 0), &temp
, insn_code
, insn_index
);
2166 left_eliminates_term
= (temp
== true_rtx
);
2169 right
= simplify_and_tree (XEXP (exp
, 1), &temp
, insn_code
, insn_index
);
2170 right_eliminates_term
= (temp
== true_rtx
);
2172 if (left_eliminates_term
&& right_eliminates_term
)
2175 if (left
!= XEXP (exp
, 0) || right
!= XEXP (exp
, 1))
2177 newexp
= attr_rtx (IOR
, left
, right
);
2179 exp
= simplify_test_exp_in_temp (newexp
, insn_code
, insn_index
);
2183 /* Check for simplifications. Do some extra checking here since this
2184 routine is called so many times. */
2189 else if (GET_CODE (exp
) == NOT
&& XEXP (exp
, 0) == *pterm
)
2192 else if (GET_CODE (*pterm
) == NOT
&& exp
== XEXP (*pterm
, 0))
2195 else if (GET_CODE (exp
) == EQ_ATTR_ALT
&& GET_CODE (*pterm
) == EQ_ATTR_ALT
)
2197 if (attr_alt_subset_p (*pterm
, exp
))
2200 if (attr_alt_subset_of_compl_p (*pterm
, exp
))
2203 if (attr_alt_subset_p (exp
, *pterm
))
2209 else if (GET_CODE (exp
) == EQ_ATTR
&& GET_CODE (*pterm
) == EQ_ATTR
)
2211 if (XSTR (exp
, 0) != XSTR (*pterm
, 0))
2214 if (! strcmp_check (XSTR (exp
, 1), XSTR (*pterm
, 1)))
2220 else if (GET_CODE (*pterm
) == EQ_ATTR
&& GET_CODE (exp
) == NOT
2221 && GET_CODE (XEXP (exp
, 0)) == EQ_ATTR
)
2223 if (XSTR (*pterm
, 0) != XSTR (XEXP (exp
, 0), 0))
2226 if (! strcmp_check (XSTR (*pterm
, 1), XSTR (XEXP (exp
, 0), 1)))
2232 else if (GET_CODE (exp
) == EQ_ATTR
&& GET_CODE (*pterm
) == NOT
2233 && GET_CODE (XEXP (*pterm
, 0)) == EQ_ATTR
)
2235 if (XSTR (exp
, 0) != XSTR (XEXP (*pterm
, 0), 0))
2238 if (! strcmp_check (XSTR (exp
, 1), XSTR (XEXP (*pterm
, 0), 1)))
2244 else if (GET_CODE (exp
) == NOT
&& GET_CODE (*pterm
) == NOT
)
2246 if (attr_equal_p (XEXP (exp
, 0), XEXP (*pterm
, 0)))
2250 else if (GET_CODE (exp
) == NOT
)
2252 if (attr_equal_p (XEXP (exp
, 0), *pterm
))
2256 else if (GET_CODE (*pterm
) == NOT
)
2258 if (attr_equal_p (XEXP (*pterm
, 0), exp
))
2262 else if (attr_equal_p (exp
, *pterm
))
2268 /* Similar to `simplify_and_tree', but for IOR trees. */
2271 simplify_or_tree (rtx exp
, rtx
*pterm
, int insn_code
, int insn_index
)
2276 int left_eliminates_term
, right_eliminates_term
;
2278 if (GET_CODE (exp
) == IOR
)
2280 left
= simplify_or_tree (XEXP (exp
, 0), pterm
, insn_code
, insn_index
);
2281 right
= simplify_or_tree (XEXP (exp
, 1), pterm
, insn_code
, insn_index
);
2282 if (left
!= XEXP (exp
, 0) || right
!= XEXP (exp
, 1))
2284 newexp
= attr_rtx (GET_CODE (exp
), left
, right
);
2286 exp
= simplify_test_exp_in_temp (newexp
, insn_code
, insn_index
);
2290 else if (GET_CODE (exp
) == AND
)
2292 /* For the AND case, we do the same as above, except that we can
2293 only eliminate `term' if both sides of the AND would do so. */
2295 left
= simplify_or_tree (XEXP (exp
, 0), &temp
, insn_code
, insn_index
);
2296 left_eliminates_term
= (temp
== false_rtx
);
2299 right
= simplify_or_tree (XEXP (exp
, 1), &temp
, insn_code
, insn_index
);
2300 right_eliminates_term
= (temp
== false_rtx
);
2302 if (left_eliminates_term
&& right_eliminates_term
)
2305 if (left
!= XEXP (exp
, 0) || right
!= XEXP (exp
, 1))
2307 newexp
= attr_rtx (GET_CODE (exp
), left
, right
);
2309 exp
= simplify_test_exp_in_temp (newexp
, insn_code
, insn_index
);
2313 if (attr_equal_p (exp
, *pterm
))
2316 else if (GET_CODE (exp
) == NOT
&& attr_equal_p (XEXP (exp
, 0), *pterm
))
2319 else if (GET_CODE (*pterm
) == NOT
&& attr_equal_p (XEXP (*pterm
, 0), exp
))
2322 else if (GET_CODE (*pterm
) == EQ_ATTR
&& GET_CODE (exp
) == NOT
2323 && GET_CODE (XEXP (exp
, 0)) == EQ_ATTR
2324 && XSTR (*pterm
, 0) == XSTR (XEXP (exp
, 0), 0))
2327 else if (GET_CODE (exp
) == EQ_ATTR
&& GET_CODE (*pterm
) == NOT
2328 && GET_CODE (XEXP (*pterm
, 0)) == EQ_ATTR
2329 && XSTR (exp
, 0) == XSTR (XEXP (*pterm
, 0), 0))
2335 /* Simplify test expression and use temporary obstack in order to avoid
2336 memory bloat. Use ATTR_IND_SIMPLIFIED to avoid unnecessary simplifications
2337 and avoid unnecessary copying if possible. */
2340 simplify_test_exp_in_temp (rtx exp
, int insn_code
, int insn_index
)
2343 struct obstack
*old
;
2344 if (ATTR_IND_SIMPLIFIED_P (exp
))
2347 rtl_obstack
= temp_obstack
;
2348 x
= simplify_test_exp (exp
, insn_code
, insn_index
);
2350 if (x
== exp
|| rtl_obstack
== temp_obstack
)
2352 return attr_copy_rtx (x
);
2355 /* Returns true if S1 is a subset of S2. */
2358 attr_alt_subset_p (rtx s1
, rtx s2
)
2360 switch ((XINT (s1
, 1) << 1) | XINT (s2
, 1))
2363 return !(XINT (s1
, 0) &~ XINT (s2
, 0));
2366 return !(XINT (s1
, 0) & XINT (s2
, 0));
2372 return !(XINT (s2
, 0) &~ XINT (s1
, 0));
2379 /* Returns true if S1 is a subset of complement of S2. */
2382 attr_alt_subset_of_compl_p (rtx s1
, rtx s2
)
2384 switch ((XINT (s1
, 1) << 1) | XINT (s2
, 1))
2387 return !(XINT (s1
, 0) & XINT (s2
, 0));
2390 return !(XINT (s1
, 0) & ~XINT (s2
, 0));
2393 return !(XINT (s2
, 0) &~ XINT (s1
, 0));
2403 /* Return EQ_ATTR_ALT expression representing intersection of S1 and S2. */
2406 attr_alt_intersection (rtx s1
, rtx s2
)
2408 rtx result
= rtx_alloc (EQ_ATTR_ALT
);
2410 switch ((XINT (s1
, 1) << 1) | XINT (s2
, 1))
2413 XINT (result
, 0) = XINT (s1
, 0) & XINT (s2
, 0);
2416 XINT (result
, 0) = XINT (s1
, 0) & ~XINT (s2
, 0);
2419 XINT (result
, 0) = XINT (s2
, 0) & ~XINT (s1
, 0);
2422 XINT (result
, 0) = XINT (s1
, 0) | XINT (s2
, 0);
2427 XINT (result
, 1) = XINT (s1
, 1) & XINT (s2
, 1);
2432 /* Return EQ_ATTR_ALT expression representing union of S1 and S2. */
2435 attr_alt_union (rtx s1
, rtx s2
)
2437 rtx result
= rtx_alloc (EQ_ATTR_ALT
);
2439 switch ((XINT (s1
, 1) << 1) | XINT (s2
, 1))
2442 XINT (result
, 0) = XINT (s1
, 0) | XINT (s2
, 0);
2445 XINT (result
, 0) = XINT (s2
, 0) & ~XINT (s1
, 0);
2448 XINT (result
, 0) = XINT (s1
, 0) & ~XINT (s2
, 0);
2451 XINT (result
, 0) = XINT (s1
, 0) & XINT (s2
, 0);
2457 XINT (result
, 1) = XINT (s1
, 1) | XINT (s2
, 1);
2461 /* Return EQ_ATTR_ALT expression representing complement of S. */
2464 attr_alt_complement (rtx s
)
2466 rtx result
= rtx_alloc (EQ_ATTR_ALT
);
2468 XINT (result
, 0) = XINT (s
, 0);
2469 XINT (result
, 1) = 1 - XINT (s
, 1);
2474 /* Return EQ_ATTR_ALT expression representing set containing elements set
2480 rtx result
= rtx_alloc (EQ_ATTR_ALT
);
2482 XINT (result
, 0) = e
;
2483 XINT (result
, 1) = 0;
2488 /* Given an expression, see if it can be simplified for a particular insn
2489 code based on the values of other attributes being tested. This can
2490 eliminate nested get_attr_... calls.
2492 Note that if an endless recursion is specified in the patterns, the
2493 optimization will loop. However, it will do so in precisely the cases where
2494 an infinite recursion loop could occur during compilation. It's better that
2498 simplify_test_exp (rtx exp
, int insn_code
, int insn_index
)
2501 struct attr_desc
*attr
;
2502 struct attr_value
*av
;
2503 struct insn_ent
*ie
;
2504 struct attr_value_list
*iv
;
2507 bool left_alt
, right_alt
;
2509 /* Don't re-simplify something we already simplified. */
2510 if (ATTR_IND_SIMPLIFIED_P (exp
) || ATTR_CURR_SIMPLIFIED_P (exp
))
2513 switch (GET_CODE (exp
))
2516 left
= SIMPLIFY_TEST_EXP (XEXP (exp
, 0), insn_code
, insn_index
);
2517 if (left
== false_rtx
)
2519 right
= SIMPLIFY_TEST_EXP (XEXP (exp
, 1), insn_code
, insn_index
);
2520 if (right
== false_rtx
)
2523 if (GET_CODE (left
) == EQ_ATTR_ALT
2524 && GET_CODE (right
) == EQ_ATTR_ALT
)
2526 exp
= attr_alt_intersection (left
, right
);
2527 return simplify_test_exp (exp
, insn_code
, insn_index
);
2530 /* If either side is an IOR and we have (eq_attr "alternative" ..")
2531 present on both sides, apply the distributive law since this will
2532 yield simplifications. */
2533 if ((GET_CODE (left
) == IOR
|| GET_CODE (right
) == IOR
)
2534 && compute_alternative_mask (left
, IOR
)
2535 && compute_alternative_mask (right
, IOR
))
2537 if (GET_CODE (left
) == IOR
)
2544 newexp
= attr_rtx (IOR
,
2545 attr_rtx (AND
, left
, XEXP (right
, 0)),
2546 attr_rtx (AND
, left
, XEXP (right
, 1)));
2548 return SIMPLIFY_TEST_EXP (newexp
, insn_code
, insn_index
);
2551 /* Try with the term on both sides. */
2552 right
= simplify_and_tree (right
, &left
, insn_code
, insn_index
);
2553 if (left
== XEXP (exp
, 0) && right
== XEXP (exp
, 1))
2554 left
= simplify_and_tree (left
, &right
, insn_code
, insn_index
);
2556 if (left
== false_rtx
|| right
== false_rtx
)
2558 else if (left
== true_rtx
)
2562 else if (right
== true_rtx
)
2566 /* See if all or all but one of the insn's alternatives are specified
2567 in this tree. Optimize if so. */
2569 if (GET_CODE (left
) == NOT
)
2570 left_alt
= (GET_CODE (XEXP (left
, 0)) == EQ_ATTR
2571 && XSTR (XEXP (left
, 0), 0) == alternative_name
);
2573 left_alt
= (GET_CODE (left
) == EQ_ATTR_ALT
2576 if (GET_CODE (right
) == NOT
)
2577 right_alt
= (GET_CODE (XEXP (right
, 0)) == EQ_ATTR
2578 && XSTR (XEXP (right
, 0), 0) == alternative_name
);
2580 right_alt
= (GET_CODE (right
) == EQ_ATTR_ALT
2581 && XINT (right
, 1));
2584 && (GET_CODE (left
) == AND
2586 || GET_CODE (right
) == AND
2589 i
= compute_alternative_mask (exp
, AND
);
2590 if (i
& ~insn_alternatives
[insn_code
])
2591 fatal ("invalid alternative specified for pattern number %d",
2594 /* If all alternatives are excluded, this is false. */
2595 i
^= insn_alternatives
[insn_code
];
2598 else if ((i
& (i
- 1)) == 0 && insn_alternatives
[insn_code
] > 1)
2600 /* If just one excluded, AND a comparison with that one to the
2601 front of the tree. The others will be eliminated by
2602 optimization. We do not want to do this if the insn has one
2603 alternative and we have tested none of them! */
2604 left
= make_alternative_compare (i
);
2605 right
= simplify_and_tree (exp
, &left
, insn_code
, insn_index
);
2606 newexp
= attr_rtx (AND
, left
, right
);
2608 return SIMPLIFY_TEST_EXP (newexp
, insn_code
, insn_index
);
2612 if (left
!= XEXP (exp
, 0) || right
!= XEXP (exp
, 1))
2614 newexp
= attr_rtx (AND
, left
, right
);
2615 return SIMPLIFY_TEST_EXP (newexp
, insn_code
, insn_index
);
2620 left
= SIMPLIFY_TEST_EXP (XEXP (exp
, 0), insn_code
, insn_index
);
2621 if (left
== true_rtx
)
2623 right
= SIMPLIFY_TEST_EXP (XEXP (exp
, 1), insn_code
, insn_index
);
2624 if (right
== true_rtx
)
2627 if (GET_CODE (left
) == EQ_ATTR_ALT
2628 && GET_CODE (right
) == EQ_ATTR_ALT
)
2630 exp
= attr_alt_union (left
, right
);
2631 return simplify_test_exp (exp
, insn_code
, insn_index
);
2634 right
= simplify_or_tree (right
, &left
, insn_code
, insn_index
);
2635 if (left
== XEXP (exp
, 0) && right
== XEXP (exp
, 1))
2636 left
= simplify_or_tree (left
, &right
, insn_code
, insn_index
);
2638 if (right
== true_rtx
|| left
== true_rtx
)
2640 else if (left
== false_rtx
)
2644 else if (right
== false_rtx
)
2649 /* Test for simple cases where the distributive law is useful. I.e.,
2650 convert (ior (and (x) (y))
2656 else if (GET_CODE (left
) == AND
&& GET_CODE (right
) == AND
2657 && attr_equal_p (XEXP (left
, 0), XEXP (right
, 0)))
2659 newexp
= attr_rtx (IOR
, XEXP (left
, 1), XEXP (right
, 1));
2661 left
= XEXP (left
, 0);
2663 newexp
= attr_rtx (AND
, left
, right
);
2664 return SIMPLIFY_TEST_EXP (newexp
, insn_code
, insn_index
);
2668 convert (ior (and (y) (x))
2670 to (and (ior (y) (z))
2672 Note that we want the common term to stay at the end.
2675 else if (GET_CODE (left
) == AND
&& GET_CODE (right
) == AND
2676 && attr_equal_p (XEXP (left
, 1), XEXP (right
, 1)))
2678 newexp
= attr_rtx (IOR
, XEXP (left
, 0), XEXP (right
, 0));
2681 right
= XEXP (right
, 1);
2682 newexp
= attr_rtx (AND
, left
, right
);
2683 return SIMPLIFY_TEST_EXP (newexp
, insn_code
, insn_index
);
2686 /* See if all or all but one of the insn's alternatives are specified
2687 in this tree. Optimize if so. */
2689 else if (insn_code
>= 0
2690 && (GET_CODE (left
) == IOR
2691 || (GET_CODE (left
) == EQ_ATTR_ALT
2693 || (GET_CODE (left
) == EQ_ATTR
2694 && XSTR (left
, 0) == alternative_name
)
2695 || GET_CODE (right
) == IOR
2696 || (GET_CODE (right
) == EQ_ATTR_ALT
2697 && !XINT (right
, 1))
2698 || (GET_CODE (right
) == EQ_ATTR
2699 && XSTR (right
, 0) == alternative_name
)))
2701 i
= compute_alternative_mask (exp
, IOR
);
2702 if (i
& ~insn_alternatives
[insn_code
])
2703 fatal ("invalid alternative specified for pattern number %d",
2706 /* If all alternatives are included, this is true. */
2707 i
^= insn_alternatives
[insn_code
];
2710 else if ((i
& (i
- 1)) == 0 && insn_alternatives
[insn_code
] > 1)
2712 /* If just one excluded, IOR a comparison with that one to the
2713 front of the tree. The others will be eliminated by
2714 optimization. We do not want to do this if the insn has one
2715 alternative and we have tested none of them! */
2716 left
= make_alternative_compare (i
);
2717 right
= simplify_and_tree (exp
, &left
, insn_code
, insn_index
);
2718 newexp
= attr_rtx (IOR
, attr_rtx (NOT
, left
), right
);
2720 return SIMPLIFY_TEST_EXP (newexp
, insn_code
, insn_index
);
2724 if (left
!= XEXP (exp
, 0) || right
!= XEXP (exp
, 1))
2726 newexp
= attr_rtx (IOR
, left
, right
);
2727 return SIMPLIFY_TEST_EXP (newexp
, insn_code
, insn_index
);
2732 if (GET_CODE (XEXP (exp
, 0)) == NOT
)
2734 left
= SIMPLIFY_TEST_EXP (XEXP (XEXP (exp
, 0), 0),
2735 insn_code
, insn_index
);
2739 left
= SIMPLIFY_TEST_EXP (XEXP (exp
, 0), insn_code
, insn_index
);
2740 if (GET_CODE (left
) == NOT
)
2741 return XEXP (left
, 0);
2743 if (left
== false_rtx
)
2745 if (left
== true_rtx
)
2748 if (GET_CODE (left
) == EQ_ATTR_ALT
)
2750 exp
= attr_alt_complement (left
);
2751 return simplify_test_exp (exp
, insn_code
, insn_index
);
2754 /* Try to apply De`Morgan's laws. */
2755 if (GET_CODE (left
) == IOR
)
2757 newexp
= attr_rtx (AND
,
2758 attr_rtx (NOT
, XEXP (left
, 0)),
2759 attr_rtx (NOT
, XEXP (left
, 1)));
2761 newexp
= SIMPLIFY_TEST_EXP (newexp
, insn_code
, insn_index
);
2763 else if (GET_CODE (left
) == AND
)
2765 newexp
= attr_rtx (IOR
,
2766 attr_rtx (NOT
, XEXP (left
, 0)),
2767 attr_rtx (NOT
, XEXP (left
, 1)));
2769 newexp
= SIMPLIFY_TEST_EXP (newexp
, insn_code
, insn_index
);
2771 else if (left
!= XEXP (exp
, 0))
2773 newexp
= attr_rtx (NOT
, left
);
2779 return XINT (exp
, 1) ? true_rtx
: false_rtx
;
2783 if (XSTR (exp
, 0) == alternative_name
)
2785 newexp
= mk_attr_alt (1 << atoi (XSTR (exp
, 1)));
2789 /* Look at the value for this insn code in the specified attribute.
2790 We normally can replace this comparison with the condition that
2791 would give this insn the values being tested for. */
2793 && (attr
= find_attr (&XSTR (exp
, 0), 0)) != NULL
)
2798 if (insn_code_values
)
2800 for (iv
= insn_code_values
[insn_code
]; iv
; iv
= iv
->next
)
2801 if (iv
->attr
== attr
)
2809 for (av
= attr
->first_value
; av
; av
= av
->next
)
2810 for (ie
= av
->first_insn
; ie
; ie
= ie
->next
)
2811 if (ie
->def
->insn_code
== insn_code
)
2818 x
= evaluate_eq_attr (exp
, attr
, av
->value
,
2819 insn_code
, insn_index
);
2820 x
= SIMPLIFY_TEST_EXP (x
, insn_code
, insn_index
);
2821 if (attr_rtx_cost (x
) < 7)
2831 /* We have already simplified this expression. Simplifying it again
2832 won't buy anything unless we weren't given a valid insn code
2833 to process (i.e., we are canonicalizing something.). */
2835 && ! ATTR_IND_SIMPLIFIED_P (newexp
))
2836 return copy_rtx_unchanging (newexp
);
2841 /* Return 1 if any EQ_ATTR subexpression of P refers to ATTR,
2842 otherwise return 0. */
2845 tests_attr_p (rtx p
, struct attr_desc
*attr
)
2850 if (GET_CODE (p
) == EQ_ATTR
)
2852 if (XSTR (p
, 0) != attr
->name
)
2857 fmt
= GET_RTX_FORMAT (GET_CODE (p
));
2858 ie
= GET_RTX_LENGTH (GET_CODE (p
));
2859 for (i
= 0; i
< ie
; i
++)
2864 if (tests_attr_p (XEXP (p
, i
), attr
))
2869 je
= XVECLEN (p
, i
);
2870 for (j
= 0; j
< je
; ++j
)
2871 if (tests_attr_p (XVECEXP (p
, i
, j
), attr
))
2880 /* Calculate a topological sorting of all attributes so that
2881 all attributes only depend on attributes in front of it.
2882 Place the result in *RET (which is a pointer to an array of
2883 attr_desc pointers), and return the size of that array. */
2886 get_attr_order (struct attr_desc
***ret
)
2890 struct attr_desc
*attr
;
2891 struct attr_desc
**all
, **sorted
;
2893 for (i
= 0; i
< MAX_ATTRS_INDEX
; i
++)
2894 for (attr
= attrs
[i
]; attr
; attr
= attr
->next
)
2896 all
= XNEWVEC (struct attr_desc
*, num
);
2897 sorted
= XNEWVEC (struct attr_desc
*, num
);
2898 handled
= XCNEWVEC (char, num
);
2900 for (i
= 0; i
< MAX_ATTRS_INDEX
; i
++)
2901 for (attr
= attrs
[i
]; attr
; attr
= attr
->next
)
2905 for (i
= 0; i
< num
; i
++)
2906 if (all
[i
]->is_const
)
2907 handled
[i
] = 1, sorted
[j
++] = all
[i
];
2909 /* We have only few attributes hence we can live with the inner
2910 loop being O(n^2), unlike the normal fast variants of topological
2914 for (i
= 0; i
< num
; i
++)
2917 /* Let's see if I depends on anything interesting. */
2919 for (k
= 0; k
< num
; k
++)
2922 struct attr_value
*av
;
2923 for (av
= all
[i
]->first_value
; av
; av
= av
->next
)
2924 if (av
->num_insns
!= 0)
2925 if (tests_attr_p (av
->value
, all
[k
]))
2929 /* Something in I depends on K. */
2934 /* Nothing in I depended on anything intersting, so
2937 sorted
[j
++] = all
[i
];
2943 for (j
= 0; j
< num
; j
++)
2945 struct attr_desc
*attr2
;
2946 struct attr_value
*av
;
2949 fprintf (stderr
, "%s depends on: ", attr
->name
);
2950 for (i
= 0; i
< MAX_ATTRS_INDEX
; ++i
)
2951 for (attr2
= attrs
[i
]; attr2
; attr2
= attr2
->next
)
2952 if (!attr2
->is_const
)
2953 for (av
= attr
->first_value
; av
; av
= av
->next
)
2954 if (av
->num_insns
!= 0)
2955 if (tests_attr_p (av
->value
, attr2
))
2957 fprintf (stderr
, "%s, ", attr2
->name
);
2960 fprintf (stderr
, "\n");
2968 /* Optimize the attribute lists by seeing if we can determine conditional
2969 values from the known values of other attributes. This will save subroutine
2970 calls during the compilation. */
2973 optimize_attrs (void)
2975 struct attr_desc
*attr
;
2976 struct attr_value
*av
;
2977 struct insn_ent
*ie
;
2980 struct attr_value_list
*ivbuf
;
2981 struct attr_value_list
*iv
;
2982 struct attr_desc
**topsort
;
2985 /* For each insn code, make a list of all the insn_ent's for it,
2986 for all values for all attributes. */
2988 if (num_insn_ents
== 0)
2991 /* Make 2 extra elements, for "code" values -2 and -1. */
2992 insn_code_values
= XCNEWVEC (struct attr_value_list
*, insn_code_number
+ 2);
2994 /* Offset the table address so we can index by -2 or -1. */
2995 insn_code_values
+= 2;
2997 iv
= ivbuf
= XNEWVEC (struct attr_value_list
, num_insn_ents
);
2999 /* Create the chain of insn*attr values such that we see dependend
3000 attributes after their dependencies. As we use a stack via the
3001 next pointers start from the end of the topological order. */
3002 topnum
= get_attr_order (&topsort
);
3003 for (i
= topnum
- 1; i
>= 0; i
--)
3004 for (av
= topsort
[i
]->first_value
; av
; av
= av
->next
)
3005 for (ie
= av
->first_insn
; ie
; ie
= ie
->next
)
3007 iv
->attr
= topsort
[i
];
3010 iv
->next
= insn_code_values
[ie
->def
->insn_code
];
3011 insn_code_values
[ie
->def
->insn_code
] = iv
;
3016 /* Sanity check on num_insn_ents. */
3017 gcc_assert (iv
== ivbuf
+ num_insn_ents
);
3019 /* Process one insn code at a time. */
3020 for (i
= -2; i
< insn_code_number
; i
++)
3022 /* Clear the ATTR_CURR_SIMPLIFIED_P flag everywhere relevant.
3023 We use it to mean "already simplified for this insn". */
3024 for (iv
= insn_code_values
[i
]; iv
; iv
= iv
->next
)
3025 clear_struct_flag (iv
->av
->value
);
3027 for (iv
= insn_code_values
[i
]; iv
; iv
= iv
->next
)
3029 struct obstack
*old
= rtl_obstack
;
3034 if (GET_CODE (av
->value
) != COND
)
3037 rtl_obstack
= temp_obstack
;
3039 while (GET_CODE (newexp
) == COND
)
3041 rtx newexp2
= simplify_cond (newexp
, ie
->def
->insn_code
,
3042 ie
->def
->insn_index
);
3043 if (newexp2
== newexp
)
3049 /* If we created a new value for this instruction, and it's
3050 cheaper than the old value, and overall cheap, use that
3051 one as specific value for the current instruction.
3052 The last test is to avoid exploding the get_attr_ function
3053 sizes for no much gain. */
3054 if (newexp
!= av
->value
3055 && attr_rtx_cost (newexp
) < attr_rtx_cost (av
->value
)
3056 && attr_rtx_cost (newexp
) < 26
3059 newexp
= attr_copy_rtx (newexp
);
3060 remove_insn_ent (av
, ie
);
3061 av
= get_attr_value (newexp
, attr
, ie
->def
->insn_code
);
3063 insert_insn_ent (av
, ie
);
3069 free (insn_code_values
- 2);
3070 insn_code_values
= NULL
;
3073 /* Clear the ATTR_CURR_SIMPLIFIED_P flag in EXP and its subexpressions. */
3076 clear_struct_flag (rtx x
)
3083 ATTR_CURR_SIMPLIFIED_P (x
) = 0;
3084 if (ATTR_IND_SIMPLIFIED_P (x
))
3087 code
= GET_CODE (x
);
3106 /* Compare the elements. If any pair of corresponding elements
3107 fail to match, return 0 for the whole things. */
3109 fmt
= GET_RTX_FORMAT (code
);
3110 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
3116 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
3117 clear_struct_flag (XVECEXP (x
, i
, j
));
3121 clear_struct_flag (XEXP (x
, i
));
3127 /* Add attribute value NAME to the beginning of ATTR's list. */
3130 add_attr_value (struct attr_desc
*attr
, const char *name
)
3132 struct attr_value
*av
;
3134 av
= oballoc (struct attr_value
);
3135 av
->value
= attr_rtx (CONST_STRING
, name
);
3136 av
->next
= attr
->first_value
;
3137 attr
->first_value
= av
;
3138 av
->first_insn
= NULL
;
3140 av
->has_asm_insn
= 0;
3143 /* Create table entries for DEFINE_ATTR or DEFINE_ENUM_ATTR. */
3146 gen_attr (rtx exp
, int lineno
)
3148 struct enum_type
*et
;
3149 struct enum_value
*ev
;
3150 struct attr_desc
*attr
;
3151 const char *name_ptr
;
3154 /* Make a new attribute structure. Check for duplicate by looking at
3155 attr->default_val, since it is initialized by this routine. */
3156 attr
= find_attr (&XSTR (exp
, 0), 1);
3157 if (attr
->default_val
)
3159 error_with_line (lineno
, "duplicate definition for attribute %s",
3161 message_with_line (attr
->lineno
, "previous definition");
3164 attr
->lineno
= lineno
;
3166 if (GET_CODE (exp
) == DEFINE_ENUM_ATTR
)
3168 attr
->enum_name
= XSTR (exp
, 1);
3169 et
= lookup_enum_type (XSTR (exp
, 1));
3170 if (!et
|| !et
->md_p
)
3171 error_with_line (lineno
, "No define_enum called `%s' defined",
3174 for (ev
= et
->values
; ev
; ev
= ev
->next
)
3175 add_attr_value (attr
, ev
->name
);
3177 else if (*XSTR (exp
, 1) == '\0')
3178 attr
->is_numeric
= 1;
3181 name_ptr
= XSTR (exp
, 1);
3182 while ((p
= next_comma_elt (&name_ptr
)) != NULL
)
3183 add_attr_value (attr
, p
);
3186 if (GET_CODE (XEXP (exp
, 2)) == CONST
)
3189 if (attr
->is_numeric
)
3190 error_with_line (lineno
,
3191 "constant attributes may not take numeric values");
3193 /* Get rid of the CONST node. It is allowed only at top-level. */
3194 XEXP (exp
, 2) = XEXP (XEXP (exp
, 2), 0);
3197 if (! strcmp_check (attr
->name
, length_str
) && ! attr
->is_numeric
)
3198 error_with_line (lineno
, "`length' attribute must take numeric values");
3200 /* Set up the default value. */
3201 XEXP (exp
, 2) = check_attr_value (XEXP (exp
, 2), attr
);
3202 attr
->default_val
= get_attr_value (XEXP (exp
, 2), attr
, -2);
3205 /* Given a pattern for DEFINE_PEEPHOLE or DEFINE_INSN, return the number of
3206 alternatives in the constraints. Assume all MATCH_OPERANDs have the same
3207 number of alternatives as this should be checked elsewhere. */
3210 count_alternatives (rtx exp
)
3215 if (GET_CODE (exp
) == MATCH_OPERAND
)
3216 return n_comma_elts (XSTR (exp
, 2));
3218 for (i
= 0, fmt
= GET_RTX_FORMAT (GET_CODE (exp
));
3219 i
< GET_RTX_LENGTH (GET_CODE (exp
)); i
++)
3224 n
= count_alternatives (XEXP (exp
, i
));
3231 if (XVEC (exp
, i
) != NULL
)
3232 for (j
= 0; j
< XVECLEN (exp
, i
); j
++)
3234 n
= count_alternatives (XVECEXP (exp
, i
, j
));
3243 /* Returns nonzero if the given expression contains an EQ_ATTR with the
3244 `alternative' attribute. */
3247 compares_alternatives_p (rtx exp
)
3252 if (GET_CODE (exp
) == EQ_ATTR
&& XSTR (exp
, 0) == alternative_name
)
3255 for (i
= 0, fmt
= GET_RTX_FORMAT (GET_CODE (exp
));
3256 i
< GET_RTX_LENGTH (GET_CODE (exp
)); i
++)
3261 if (compares_alternatives_p (XEXP (exp
, i
)))
3266 for (j
= 0; j
< XVECLEN (exp
, i
); j
++)
3267 if (compares_alternatives_p (XVECEXP (exp
, i
, j
)))
3275 /* Process DEFINE_PEEPHOLE, DEFINE_INSN, and DEFINE_ASM_ATTRIBUTES. */
3278 gen_insn (rtx exp
, int lineno
)
3280 struct insn_def
*id
;
3282 id
= oballoc (struct insn_def
);
3286 id
->filename
= read_md_filename
;
3287 id
->lineno
= lineno
;
3289 switch (GET_CODE (exp
))
3292 id
->insn_code
= insn_code_number
;
3293 id
->insn_index
= insn_index_number
;
3294 id
->num_alternatives
= count_alternatives (exp
);
3295 if (id
->num_alternatives
== 0)
3296 id
->num_alternatives
= 1;
3300 case DEFINE_PEEPHOLE
:
3301 id
->insn_code
= insn_code_number
;
3302 id
->insn_index
= insn_index_number
;
3303 id
->num_alternatives
= count_alternatives (exp
);
3304 if (id
->num_alternatives
== 0)
3305 id
->num_alternatives
= 1;
3309 case DEFINE_ASM_ATTRIBUTES
:
3311 id
->insn_index
= -1;
3312 id
->num_alternatives
= 1;
3314 got_define_asm_attributes
= 1;
3322 /* Process a DEFINE_DELAY. Validate the vector length, check if annul
3323 true or annul false is specified, and make a `struct delay_desc'. */
3326 gen_delay (rtx def
, int lineno
)
3328 struct delay_desc
*delay
;
3331 if (XVECLEN (def
, 1) % 3 != 0)
3333 error_with_line (lineno
,
3334 "number of elements in DEFINE_DELAY must"
3335 " be multiple of three");
3339 for (i
= 0; i
< XVECLEN (def
, 1); i
+= 3)
3341 if (XVECEXP (def
, 1, i
+ 1))
3342 have_annul_true
= 1;
3343 if (XVECEXP (def
, 1, i
+ 2))
3344 have_annul_false
= 1;
3347 delay
= oballoc (struct delay_desc
);
3349 delay
->num
= ++num_delays
;
3350 delay
->next
= delays
;
3351 delay
->lineno
= lineno
;
3355 /* Names of attributes that could be possibly cached. */
3356 static const char *cached_attrs
[32];
3357 /* Number of such attributes. */
3358 static int cached_attr_count
;
3359 /* Bitmasks of possibly cached attributes. */
3360 static unsigned int attrs_seen_once
, attrs_seen_more_than_once
;
3361 static unsigned int attrs_to_cache
;
3362 static unsigned int attrs_cached_inside
, attrs_cached_after
;
3364 /* Finds non-const attributes that could be possibly cached.
3365 When create is TRUE, fills in cached_attrs array.
3366 Computes ATTRS_SEEN_ONCE and ATTRS_SEEN_MORE_THAN_ONCE
3370 find_attrs_to_cache (rtx exp
, bool create
)
3374 struct attr_desc
*attr
;
3379 switch (GET_CODE (exp
))
3382 if (GET_CODE (XEXP (exp
, 0)) == EQ_ATTR
)
3383 find_attrs_to_cache (XEXP (exp
, 0), create
);
3387 name
= XSTR (exp
, 0);
3388 if (name
== alternative_name
)
3390 for (i
= 0; i
< cached_attr_count
; i
++)
3391 if (name
== cached_attrs
[i
])
3393 if ((attrs_seen_once
& (1U << i
)) != 0)
3394 attrs_seen_more_than_once
|= (1U << i
);
3396 attrs_seen_once
|= (1U << i
);
3401 attr
= find_attr (&name
, 0);
3405 if (cached_attr_count
== 32)
3407 cached_attrs
[cached_attr_count
] = XSTR (exp
, 0);
3408 attrs_seen_once
|= (1U << cached_attr_count
);
3409 cached_attr_count
++;
3414 find_attrs_to_cache (XEXP (exp
, 0), create
);
3415 find_attrs_to_cache (XEXP (exp
, 1), create
);
3419 for (i
= 0; i
< XVECLEN (exp
, 0); i
+= 2)
3420 find_attrs_to_cache (XVECEXP (exp
, 0, i
), create
);
3428 /* Given a piece of RTX, print a C expression to test its truth value to OUTF.
3429 We use AND and IOR both for logical and bit-wise operations, so
3430 interpret them as logical unless they are inside a comparison expression. */
3432 /* Interpret AND/IOR as bit-wise operations instead of logical. */
3433 #define FLG_BITWISE 1
3434 /* Set if cached attribute will be known initialized in else block after
3435 this condition. This is true for LHS of toplevel && and || and
3436 even for RHS of ||, but not for RHS of &&. */
3438 /* Set if cached attribute will be known initialized in then block after
3439 this condition. This is true for LHS of toplevel && and || and
3440 even for RHS of &&, but not for RHS of ||. */
3441 #define FLG_INSIDE 4
3442 /* Cleared when an operand of &&. */
3443 #define FLG_OUTSIDE_AND 8
3446 write_test_expr (FILE *outf
, rtx exp
, unsigned int attrs_cached
, int flags
)
3448 int comparison_operator
= 0;
3450 struct attr_desc
*attr
;
3452 /* In order not to worry about operator precedence, surround our part of
3453 the expression with parentheses. */
3455 fprintf (outf
, "(");
3456 code
= GET_CODE (exp
);
3459 /* Binary operators. */
3462 fprintf (outf
, "(unsigned) ");
3468 comparison_operator
= FLG_BITWISE
;
3470 case PLUS
: case MINUS
: case MULT
: case DIV
: case MOD
:
3471 case AND
: case IOR
: case XOR
:
3472 case ASHIFT
: case LSHIFTRT
: case ASHIFTRT
:
3473 if ((code
!= AND
&& code
!= IOR
) || (flags
& FLG_BITWISE
))
3475 flags
&= ~(FLG_AFTER
| FLG_INSIDE
| FLG_OUTSIDE_AND
);
3476 write_test_expr (outf
, XEXP (exp
, 0), attrs_cached
,
3477 flags
| comparison_operator
);
3482 flags
&= ~FLG_OUTSIDE_AND
;
3483 if (GET_CODE (XEXP (exp
, 0)) == code
3484 || GET_CODE (XEXP (exp
, 0)) == EQ_ATTR
3485 || (GET_CODE (XEXP (exp
, 0)) == NOT
3486 && GET_CODE (XEXP (XEXP (exp
, 0), 0)) == EQ_ATTR
))
3488 = write_test_expr (outf
, XEXP (exp
, 0), attrs_cached
, flags
);
3490 write_test_expr (outf
, XEXP (exp
, 0), attrs_cached
, flags
);
3495 fprintf (outf
, " == ");
3498 fprintf (outf
, " != ");
3501 fprintf (outf
, " >= ");
3504 fprintf (outf
, " > ");
3507 fprintf (outf
, " >= (unsigned) ");
3510 fprintf (outf
, " > (unsigned) ");
3513 fprintf (outf
, " <= ");
3516 fprintf (outf
, " < ");
3519 fprintf (outf
, " <= (unsigned) ");
3522 fprintf (outf
, " < (unsigned) ");
3525 fprintf (outf
, " + ");
3528 fprintf (outf
, " - ");
3531 fprintf (outf
, " * ");
3534 fprintf (outf
, " / ");
3537 fprintf (outf
, " %% ");
3540 if (flags
& FLG_BITWISE
)
3541 fprintf (outf
, " & ");
3543 fprintf (outf
, " && ");
3546 if (flags
& FLG_BITWISE
)
3547 fprintf (outf
, " | ");
3549 fprintf (outf
, " || ");
3552 fprintf (outf
, " ^ ");
3555 fprintf (outf
, " << ");
3559 fprintf (outf
, " >> ");
3567 /* For if (something && (cached_x = get_attr_x (insn)) == X)
3568 cached_x is only known to be initialized in then block. */
3569 flags
&= ~FLG_AFTER
;
3571 else if (code
== IOR
)
3573 if (flags
& FLG_OUTSIDE_AND
)
3574 /* For if (something || (cached_x = get_attr_x (insn)) == X)
3575 cached_x is only known to be initialized in else block
3576 and else if conditions. */
3577 flags
&= ~FLG_INSIDE
;
3579 /* For if ((something || (cached_x = get_attr_x (insn)) == X)
3581 cached_x is not know to be initialized anywhere. */
3582 flags
&= ~(FLG_AFTER
| FLG_INSIDE
);
3584 if ((code
== AND
|| code
== IOR
)
3585 && (GET_CODE (XEXP (exp
, 1)) == code
3586 || GET_CODE (XEXP (exp
, 1)) == EQ_ATTR
3587 || (GET_CODE (XEXP (exp
, 1)) == NOT
3588 && GET_CODE (XEXP (XEXP (exp
, 1), 0)) == EQ_ATTR
)))
3590 = write_test_expr (outf
, XEXP (exp
, 1), attrs_cached
, flags
);
3592 write_test_expr (outf
, XEXP (exp
, 1), attrs_cached
,
3593 flags
| comparison_operator
);
3597 /* Special-case (not (eq_attrq "alternative" "x")) */
3598 if (! (flags
& FLG_BITWISE
) && GET_CODE (XEXP (exp
, 0)) == EQ_ATTR
)
3600 if (XSTR (XEXP (exp
, 0), 0) == alternative_name
)
3602 fprintf (outf
, "which_alternative != %s",
3603 XSTR (XEXP (exp
, 0), 1));
3607 fprintf (outf
, "! ");
3609 write_test_expr (outf
, XEXP (exp
, 0), attrs_cached
, flags
);
3613 /* Otherwise, fall through to normal unary operator. */
3615 /* Unary operators. */
3620 if (flags
& FLG_BITWISE
)
3621 fprintf (outf
, "~ ");
3623 fprintf (outf
, "! ");
3626 fprintf (outf
, "abs ");
3629 fprintf (outf
, "-");
3635 flags
&= ~(FLG_AFTER
| FLG_INSIDE
| FLG_OUTSIDE_AND
);
3636 write_test_expr (outf
, XEXP (exp
, 0), attrs_cached
, flags
);
3641 int set
= XINT (exp
, 0), bit
= 0;
3643 if (flags
& FLG_BITWISE
)
3644 fatal ("EQ_ATTR_ALT not valid inside comparison");
3647 fatal ("Empty EQ_ATTR_ALT should be optimized out");
3649 if (!(set
& (set
- 1)))
3651 if (!(set
& 0xffff))
3674 fprintf (outf
, "which_alternative %s= %d",
3675 XINT (exp
, 1) ? "!" : "=", bit
);
3679 fprintf (outf
, "%s((1 << which_alternative) & %#x)",
3680 XINT (exp
, 1) ? "!" : "", set
);
3685 /* Comparison test of an attribute with a value. Most of these will
3686 have been removed by optimization. Handle "alternative"
3687 specially and give error if EQ_ATTR present inside a comparison. */
3689 if (flags
& FLG_BITWISE
)
3690 fatal ("EQ_ATTR not valid inside comparison");
3692 if (XSTR (exp
, 0) == alternative_name
)
3694 fprintf (outf
, "which_alternative == %s", XSTR (exp
, 1));
3698 attr
= find_attr (&XSTR (exp
, 0), 0);
3701 /* Now is the time to expand the value of a constant attribute. */
3704 write_test_expr (outf
,
3705 evaluate_eq_attr (exp
, attr
,
3706 attr
->default_val
->value
,
3713 for (i
= 0; i
< cached_attr_count
; i
++)
3714 if (attr
->name
== cached_attrs
[i
])
3716 if (i
< cached_attr_count
&& (attrs_cached
& (1U << i
)) != 0)
3717 fprintf (outf
, "cached_%s", attr
->name
);
3718 else if (i
< cached_attr_count
&& (attrs_to_cache
& (1U << i
)) != 0)
3720 fprintf (outf
, "(cached_%s = get_attr_%s (insn))",
3721 attr
->name
, attr
->name
);
3722 if (flags
& FLG_AFTER
)
3723 attrs_cached_after
|= (1U << i
);
3724 if (flags
& FLG_INSIDE
)
3725 attrs_cached_inside
|= (1U << i
);
3726 attrs_cached
|= (1U << i
);
3729 fprintf (outf
, "get_attr_%s (insn)", attr
->name
);
3730 fprintf (outf
, " == ");
3731 write_attr_valueq (outf
, attr
, XSTR (exp
, 1));
3735 /* Comparison test of flags for define_delays. */
3737 if (flags
& FLG_BITWISE
)
3738 fatal ("ATTR_FLAG not valid inside comparison");
3739 fprintf (outf
, "(flags & ATTR_FLAG_%s) != 0", XSTR (exp
, 0));
3742 /* See if an operand matches a predicate. */
3744 /* If only a mode is given, just ensure the mode matches the operand.
3745 If neither a mode nor predicate is given, error. */
3746 if (XSTR (exp
, 1) == NULL
|| *XSTR (exp
, 1) == '\0')
3748 if (GET_MODE (exp
) == VOIDmode
)
3749 fatal ("null MATCH_OPERAND specified as test");
3751 fprintf (outf
, "GET_MODE (operands[%d]) == %smode",
3752 XINT (exp
, 0), GET_MODE_NAME (GET_MODE (exp
)));
3755 fprintf (outf
, "%s (operands[%d], %smode)",
3756 XSTR (exp
, 1), XINT (exp
, 0), GET_MODE_NAME (GET_MODE (exp
)));
3759 /* Constant integer. */
3761 fprintf (outf
, HOST_WIDE_INT_PRINT_DEC
, XWINT (exp
, 0));
3765 fprint_c_condition (outf
, XSTR (exp
, 0));
3766 if (flags
& FLG_BITWISE
)
3767 fprintf (outf
, " != 0");
3770 /* A random C expression. */
3772 fprint_c_condition (outf
, XSTR (exp
, 0));
3775 /* The address of the branch target. */
3778 "INSN_ADDRESSES_SET_P () ? INSN_ADDRESSES (INSN_UID (GET_CODE (operands[%d]) == LABEL_REF ? XEXP (operands[%d], 0) : operands[%d])) : 0",
3779 XINT (exp
, 0), XINT (exp
, 0), XINT (exp
, 0));
3783 /* The address of the current insn. We implement this actually as the
3784 address of the current insn for backward branches, but the last
3785 address of the next insn for forward branches, and both with
3786 adjustments that account for the worst-case possible stretching of
3787 intervening alignments between this insn and its destination. */
3788 fprintf (outf
, "insn_current_reference_address (insn)");
3792 fprintf (outf
, "%s", XSTR (exp
, 0));
3796 write_test_expr (outf
, XEXP (exp
, 0), attrs_cached
, 0);
3797 fprintf (outf
, " ? ");
3798 write_test_expr (outf
, XEXP (exp
, 1), attrs_cached
, FLG_BITWISE
);
3799 fprintf (outf
, " : ");
3800 write_test_expr (outf
, XEXP (exp
, 2), attrs_cached
, FLG_BITWISE
);
3804 fatal ("bad RTX code `%s' in attribute calculation\n",
3805 GET_RTX_NAME (code
));
3808 fprintf (outf
, ")");
3809 return attrs_cached
;
3812 /* Given an attribute value, return the maximum CONST_STRING argument
3813 encountered. Set *UNKNOWNP and return INT_MAX if the value is unknown. */
3816 max_attr_value (rtx exp
, int *unknownp
)
3821 switch (GET_CODE (exp
))
3824 current_max
= atoi (XSTR (exp
, 0));
3828 current_max
= max_attr_value (XEXP (exp
, 1), unknownp
);
3829 for (i
= 0; i
< XVECLEN (exp
, 0); i
+= 2)
3831 n
= max_attr_value (XVECEXP (exp
, 0, i
+ 1), unknownp
);
3832 if (n
> current_max
)
3838 current_max
= max_attr_value (XEXP (exp
, 1), unknownp
);
3839 n
= max_attr_value (XEXP (exp
, 2), unknownp
);
3840 if (n
> current_max
)
3846 current_max
= INT_MAX
;
3853 /* Given an attribute value, return the minimum CONST_STRING argument
3854 encountered. Set *UNKNOWNP and return 0 if the value is unknown. */
3857 min_attr_value (rtx exp
, int *unknownp
)
3862 switch (GET_CODE (exp
))
3865 current_min
= atoi (XSTR (exp
, 0));
3869 current_min
= min_attr_value (XEXP (exp
, 1), unknownp
);
3870 for (i
= 0; i
< XVECLEN (exp
, 0); i
+= 2)
3872 n
= min_attr_value (XVECEXP (exp
, 0, i
+ 1), unknownp
);
3873 if (n
< current_min
)
3879 current_min
= min_attr_value (XEXP (exp
, 1), unknownp
);
3880 n
= min_attr_value (XEXP (exp
, 2), unknownp
);
3881 if (n
< current_min
)
3887 current_min
= INT_MAX
;
3894 /* Given an attribute value, return the result of ORing together all
3895 CONST_STRING arguments encountered. Set *UNKNOWNP and return -1
3896 if the numeric value is not known. */
3899 or_attr_value (rtx exp
, int *unknownp
)
3904 switch (GET_CODE (exp
))
3907 current_or
= atoi (XSTR (exp
, 0));
3911 current_or
= or_attr_value (XEXP (exp
, 1), unknownp
);
3912 for (i
= 0; i
< XVECLEN (exp
, 0); i
+= 2)
3913 current_or
|= or_attr_value (XVECEXP (exp
, 0, i
+ 1), unknownp
);
3917 current_or
= or_attr_value (XEXP (exp
, 1), unknownp
);
3918 current_or
|= or_attr_value (XEXP (exp
, 2), unknownp
);
3930 /* Scan an attribute value, possibly a conditional, and record what actions
3931 will be required to do any conditional tests in it.
3934 `must_extract' if we need to extract the insn operands
3935 `must_constrain' if we must compute `which_alternative'
3936 `address_used' if an address expression was used
3937 `length_used' if an (eq_attr "length" ...) was used
3941 walk_attr_value (rtx exp
)
3950 code
= GET_CODE (exp
);
3954 if (! ATTR_IND_SIMPLIFIED_P (exp
))
3955 /* Since this is an arbitrary expression, it can look at anything.
3956 However, constant expressions do not depend on any particular
3958 must_extract
= must_constrain
= 1;
3967 must_extract
= must_constrain
= 1;
3971 if (XSTR (exp
, 0) == alternative_name
)
3972 must_extract
= must_constrain
= 1;
3973 else if (strcmp_check (XSTR (exp
, 0), length_str
) == 0)
3993 for (i
= 0, fmt
= GET_RTX_FORMAT (code
); i
< GET_RTX_LENGTH (code
); i
++)
3998 walk_attr_value (XEXP (exp
, i
));
4002 if (XVEC (exp
, i
) != NULL
)
4003 for (j
= 0; j
< XVECLEN (exp
, i
); j
++)
4004 walk_attr_value (XVECEXP (exp
, i
, j
));
4009 /* Write out a function to obtain the attribute for a given INSN. */
4012 write_attr_get (FILE *outf
, struct attr_desc
*attr
)
4014 struct attr_value
*av
, *common_av
;
4017 /* Find the most used attribute value. Handle that as the `default' of the
4018 switch we will generate. */
4019 common_av
= find_most_used (attr
);
4021 /* Write out start of function, then all values with explicit `case' lines,
4022 then a `default', then the value with the most uses. */
4023 if (attr
->enum_name
)
4024 fprintf (outf
, "enum %s\n", attr
->enum_name
);
4025 else if (!attr
->is_numeric
)
4026 fprintf (outf
, "enum attr_%s\n", attr
->name
);
4028 fprintf (outf
, "int\n");
4030 /* If the attribute name starts with a star, the remainder is the name of
4031 the subroutine to use, instead of `get_attr_...'. */
4032 if (attr
->name
[0] == '*')
4033 fprintf (outf
, "%s (rtx insn ATTRIBUTE_UNUSED)\n", &attr
->name
[1]);
4034 else if (attr
->is_const
== 0)
4035 fprintf (outf
, "get_attr_%s (rtx insn ATTRIBUTE_UNUSED)\n", attr
->name
);
4038 fprintf (outf
, "get_attr_%s (void)\n", attr
->name
);
4039 fprintf (outf
, "{\n");
4041 for (av
= attr
->first_value
; av
; av
= av
->next
)
4042 if (av
->num_insns
== 1)
4043 write_attr_set (outf
, attr
, 2, av
->value
, "return", ";",
4044 true_rtx
, av
->first_insn
->def
->insn_code
,
4045 av
->first_insn
->def
->insn_index
, 0);
4046 else if (av
->num_insns
!= 0)
4047 write_attr_set (outf
, attr
, 2, av
->value
, "return", ";",
4048 true_rtx
, -2, 0, 0);
4050 fprintf (outf
, "}\n\n");
4054 fprintf (outf
, "{\n");
4056 /* Find attributes that are worth caching in the conditions. */
4057 cached_attr_count
= 0;
4058 attrs_seen_more_than_once
= 0;
4059 for (av
= attr
->first_value
; av
; av
= av
->next
)
4061 attrs_seen_once
= 0;
4062 find_attrs_to_cache (av
->value
, true);
4064 /* Remove those that aren't worth caching from the array. */
4065 for (i
= 0, j
= 0; i
< cached_attr_count
; i
++)
4066 if ((attrs_seen_more_than_once
& (1U << i
)) != 0)
4068 const char *name
= cached_attrs
[i
];
4069 struct attr_desc
*cached_attr
;
4071 cached_attrs
[j
] = name
;
4072 cached_attr
= find_attr (&name
, 0);
4073 gcc_assert (cached_attr
&& cached_attr
->is_const
== 0);
4074 if (cached_attr
->enum_name
)
4075 fprintf (outf
, " enum %s", cached_attr
->enum_name
);
4076 else if (!cached_attr
->is_numeric
)
4077 fprintf (outf
, " enum attr_%s", cached_attr
->name
);
4079 fprintf (outf
, " int");
4080 fprintf (outf
, " cached_%s ATTRIBUTE_UNUSED;\n", name
);
4083 cached_attr_count
= j
;
4084 if (cached_attr_count
)
4085 fprintf (outf
, "\n");
4087 fprintf (outf
, " switch (recog_memoized (insn))\n");
4088 fprintf (outf
, " {\n");
4090 for (av
= attr
->first_value
; av
; av
= av
->next
)
4091 if (av
!= common_av
)
4092 write_attr_case (outf
, attr
, av
, 1, "return", ";", 4, true_rtx
);
4094 write_attr_case (outf
, attr
, common_av
, 0, "return", ";", 4, true_rtx
);
4095 fprintf (outf
, " }\n}\n\n");
4096 cached_attr_count
= 0;
4099 /* Given an AND tree of known true terms (because we are inside an `if' with
4100 that as the condition or are in an `else' clause) and an expression,
4101 replace any known true terms with TRUE. Use `simplify_and_tree' to do
4102 the bulk of the work. */
4105 eliminate_known_true (rtx known_true
, rtx exp
, int insn_code
, int insn_index
)
4109 known_true
= SIMPLIFY_TEST_EXP (known_true
, insn_code
, insn_index
);
4111 if (GET_CODE (known_true
) == AND
)
4113 exp
= eliminate_known_true (XEXP (known_true
, 0), exp
,
4114 insn_code
, insn_index
);
4115 exp
= eliminate_known_true (XEXP (known_true
, 1), exp
,
4116 insn_code
, insn_index
);
4121 exp
= simplify_and_tree (exp
, &term
, insn_code
, insn_index
);
4127 /* Write out a series of tests and assignment statements to perform tests and
4128 sets of an attribute value. We are passed an indentation amount and prefix
4129 and suffix strings to write around each attribute value (e.g., "return"
4133 write_attr_set (FILE *outf
, struct attr_desc
*attr
, int indent
, rtx value
,
4134 const char *prefix
, const char *suffix
, rtx known_true
,
4135 int insn_code
, int insn_index
, unsigned int attrs_cached
)
4137 if (GET_CODE (value
) == COND
)
4139 /* Assume the default value will be the default of the COND unless we
4140 find an always true expression. */
4141 rtx default_val
= XEXP (value
, 1);
4142 rtx our_known_true
= known_true
;
4147 if (cached_attr_count
)
4149 attrs_seen_once
= 0;
4150 attrs_seen_more_than_once
= 0;
4151 for (i
= 0; i
< XVECLEN (value
, 0); i
+= 2)
4152 find_attrs_to_cache (XVECEXP (value
, 0, i
), false);
4153 attrs_to_cache
|= attrs_seen_more_than_once
;
4156 for (i
= 0; i
< XVECLEN (value
, 0); i
+= 2)
4161 /* Reset our_known_true after some time to not accumulate
4162 too much cruft (slowing down genattrtab). */
4164 our_known_true
= known_true
;
4165 testexp
= eliminate_known_true (our_known_true
,
4166 XVECEXP (value
, 0, i
),
4167 insn_code
, insn_index
);
4168 newexp
= attr_rtx (NOT
, testexp
);
4169 newexp
= insert_right_side (AND
, our_known_true
, newexp
,
4170 insn_code
, insn_index
);
4172 /* If the test expression is always true or if the next `known_true'
4173 expression is always false, this is the last case, so break
4174 out and let this value be the `else' case. */
4175 if (testexp
== true_rtx
|| newexp
== false_rtx
)
4177 default_val
= XVECEXP (value
, 0, i
+ 1);
4181 /* Compute the expression to pass to our recursive call as being
4183 inner_true
= insert_right_side (AND
, our_known_true
,
4184 testexp
, insn_code
, insn_index
);
4186 /* If this is always false, skip it. */
4187 if (inner_true
== false_rtx
)
4190 attrs_cached_inside
= attrs_cached
;
4191 attrs_cached_after
= attrs_cached
;
4192 write_indent (outf
, indent
);
4193 fprintf (outf
, "%sif ", first_if
? "" : "else ");
4195 write_test_expr (outf
, testexp
, attrs_cached
,
4196 (FLG_AFTER
| FLG_INSIDE
| FLG_OUTSIDE_AND
));
4197 attrs_cached
= attrs_cached_after
;
4198 fprintf (outf
, "\n");
4199 write_indent (outf
, indent
+ 2);
4200 fprintf (outf
, "{\n");
4202 write_attr_set (outf
, attr
, indent
+ 4,
4203 XVECEXP (value
, 0, i
+ 1), prefix
, suffix
,
4204 inner_true
, insn_code
, insn_index
,
4205 attrs_cached_inside
);
4206 write_indent (outf
, indent
+ 2);
4207 fprintf (outf
, "}\n");
4208 our_known_true
= newexp
;
4213 write_indent (outf
, indent
);
4214 fprintf (outf
, "else\n");
4215 write_indent (outf
, indent
+ 2);
4216 fprintf (outf
, "{\n");
4219 write_attr_set (outf
, attr
, first_if
? indent
: indent
+ 4, default_val
,
4220 prefix
, suffix
, our_known_true
, insn_code
, insn_index
,
4225 write_indent (outf
, indent
+ 2);
4226 fprintf (outf
, "}\n");
4231 write_indent (outf
, indent
);
4232 fprintf (outf
, "%s ", prefix
);
4233 write_attr_value (outf
, attr
, value
);
4234 fprintf (outf
, "%s\n", suffix
);
4238 /* Write a series of case statements for every instruction in list IE.
4239 INDENT is the amount of indentation to write before each case. */
4242 write_insn_cases (FILE *outf
, struct insn_ent
*ie
, int indent
)
4244 for (; ie
!= 0; ie
= ie
->next
)
4245 if (ie
->def
->insn_code
!= -1)
4247 write_indent (outf
, indent
);
4248 if (GET_CODE (ie
->def
->def
) == DEFINE_PEEPHOLE
)
4249 fprintf (outf
, "case %d: /* define_peephole, line %d */\n",
4250 ie
->def
->insn_code
, ie
->def
->lineno
);
4252 fprintf (outf
, "case %d: /* %s */\n",
4253 ie
->def
->insn_code
, XSTR (ie
->def
->def
, 0));
4257 /* Write out the computation for one attribute value. */
4260 write_attr_case (FILE *outf
, struct attr_desc
*attr
, struct attr_value
*av
,
4261 int write_case_lines
, const char *prefix
, const char *suffix
,
4262 int indent
, rtx known_true
)
4264 if (av
->num_insns
== 0)
4267 if (av
->has_asm_insn
)
4269 write_indent (outf
, indent
);
4270 fprintf (outf
, "case -1:\n");
4271 write_indent (outf
, indent
+ 2);
4272 fprintf (outf
, "if (GET_CODE (PATTERN (insn)) != ASM_INPUT\n");
4273 write_indent (outf
, indent
+ 2);
4274 fprintf (outf
, " && asm_noperands (PATTERN (insn)) < 0)\n");
4275 write_indent (outf
, indent
+ 2);
4276 fprintf (outf
, " fatal_insn_not_found (insn);\n");
4279 if (write_case_lines
)
4280 write_insn_cases (outf
, av
->first_insn
, indent
);
4283 write_indent (outf
, indent
);
4284 fprintf (outf
, "default:\n");
4287 /* See what we have to do to output this value. */
4288 must_extract
= must_constrain
= address_used
= 0;
4289 walk_attr_value (av
->value
);
4293 write_indent (outf
, indent
+ 2);
4294 fprintf (outf
, "extract_constrain_insn_cached (insn);\n");
4296 else if (must_extract
)
4298 write_indent (outf
, indent
+ 2);
4299 fprintf (outf
, "extract_insn_cached (insn);\n");
4303 if (av
->num_insns
== 1)
4304 write_attr_set (outf
, attr
, indent
+ 2, av
->value
, prefix
, suffix
,
4305 known_true
, av
->first_insn
->def
->insn_code
,
4306 av
->first_insn
->def
->insn_index
, 0);
4308 write_attr_set (outf
, attr
, indent
+ 2, av
->value
, prefix
, suffix
,
4309 known_true
, -2, 0, 0);
4311 if (strncmp (prefix
, "return", 6))
4313 write_indent (outf
, indent
+ 2);
4314 fprintf (outf
, "break;\n");
4316 fprintf (outf
, "\n");
4319 /* Utilities to write in various forms. */
4322 write_attr_valueq (FILE *outf
, struct attr_desc
*attr
, const char *s
)
4324 if (attr
->is_numeric
)
4328 fprintf (outf
, "%d", num
);
4330 if (num
> 9 || num
< 0)
4331 fprintf (outf
, " /* %#x */", num
);
4335 write_upcase (outf
, attr
->enum_name
? attr
->enum_name
: attr
->name
);
4336 fprintf (outf
, "_");
4337 write_upcase (outf
, s
);
4342 write_attr_value (FILE *outf
, struct attr_desc
*attr
, rtx value
)
4346 switch (GET_CODE (value
))
4349 write_attr_valueq (outf
, attr
, XSTR (value
, 0));
4353 fprintf (outf
, HOST_WIDE_INT_PRINT_DEC
, INTVAL (value
));
4357 fprint_c_condition (outf
, XSTR (value
, 0));
4362 struct attr_desc
*attr2
= find_attr (&XSTR (value
, 0), 0);
4363 if (attr
->enum_name
)
4364 fprintf (outf
, "(enum %s)", attr
->enum_name
);
4365 else if (!attr
->is_numeric
)
4366 fprintf (outf
, "(enum attr_%s)", attr
->name
);
4367 else if (!attr2
->is_numeric
)
4368 fprintf (outf
, "(int)");
4370 fprintf (outf
, "get_attr_%s (%s)", attr2
->name
,
4371 (attr2
->is_const
? "" : "insn"));
4392 write_attr_value (outf
, attr
, XEXP (value
, 0));
4396 write_attr_value (outf
, attr
, XEXP (value
, 1));
4405 write_upcase (FILE *outf
, const char *str
)
4409 /* The argument of TOUPPER should not have side effects. */
4410 fputc (TOUPPER (*str
), outf
);
4416 write_indent (FILE *outf
, int indent
)
4418 for (; indent
> 8; indent
-= 8)
4419 fprintf (outf
, "\t");
4421 for (; indent
; indent
--)
4422 fprintf (outf
, " ");
4425 /* Write a subroutine that is given an insn that requires a delay slot, a
4426 delay slot ordinal, and a candidate insn. It returns nonzero if the
4427 candidate can be placed in the specified delay slot of the insn.
4429 We can write as many as three subroutines. `eligible_for_delay'
4430 handles normal delay slots, `eligible_for_annul_true' indicates that
4431 the specified insn can be annulled if the branch is true, and likewise
4432 for `eligible_for_annul_false'.
4434 KIND is a string distinguishing these three cases ("delay", "annul_true",
4435 or "annul_false"). */
4438 write_eligible_delay (FILE *outf
, const char *kind
)
4440 struct delay_desc
*delay
;
4444 struct attr_desc
*attr
;
4445 struct attr_value
*av
, *common_av
;
4448 /* Compute the maximum number of delay slots required. We use the delay
4449 ordinal times this number plus one, plus the slot number as an index into
4450 the appropriate predicate to test. */
4452 for (delay
= delays
, max_slots
= 0; delay
; delay
= delay
->next
)
4453 if (XVECLEN (delay
->def
, 1) / 3 > max_slots
)
4454 max_slots
= XVECLEN (delay
->def
, 1) / 3;
4456 /* Write function prelude. */
4458 fprintf (outf
, "int\n");
4459 fprintf (outf
, "eligible_for_%s (rtx delay_insn ATTRIBUTE_UNUSED, int slot, \n"
4460 " rtx candidate_insn, int flags ATTRIBUTE_UNUSED)\n",
4462 fprintf (outf
, "{\n");
4463 fprintf (outf
, " rtx insn;\n");
4464 fprintf (outf
, "\n");
4465 fprintf (outf
, " gcc_assert (slot < %d);\n", max_slots
);
4466 fprintf (outf
, "\n");
4467 /* Allow dbr_schedule to pass labels, etc. This can happen if try_split
4468 converts a compound instruction into a loop. */
4469 fprintf (outf
, " if (!INSN_P (candidate_insn))\n");
4470 fprintf (outf
, " return 0;\n");
4471 fprintf (outf
, "\n");
4473 /* If more than one delay type, find out which type the delay insn is. */
4477 attr
= find_attr (&delay_type_str
, 0);
4479 common_av
= find_most_used (attr
);
4481 fprintf (outf
, " insn = delay_insn;\n");
4482 fprintf (outf
, " switch (recog_memoized (insn))\n");
4483 fprintf (outf
, " {\n");
4485 sprintf (str
, " * %d;\n break;", max_slots
);
4486 for (av
= attr
->first_value
; av
; av
= av
->next
)
4487 if (av
!= common_av
)
4488 write_attr_case (outf
, attr
, av
, 1, "slot +=", str
, 4, true_rtx
);
4490 write_attr_case (outf
, attr
, common_av
, 0, "slot +=", str
, 4, true_rtx
);
4491 fprintf (outf
, " }\n\n");
4493 /* Ensure matched. Otherwise, shouldn't have been called. */
4494 fprintf (outf
, " gcc_assert (slot >= %d);\n\n", max_slots
);
4497 /* If just one type of delay slot, write simple switch. */
4498 if (num_delays
== 1 && max_slots
== 1)
4500 fprintf (outf
, " insn = candidate_insn;\n");
4501 fprintf (outf
, " switch (recog_memoized (insn))\n");
4502 fprintf (outf
, " {\n");
4504 attr
= find_attr (&delay_1_0_str
, 0);
4506 common_av
= find_most_used (attr
);
4508 for (av
= attr
->first_value
; av
; av
= av
->next
)
4509 if (av
!= common_av
)
4510 write_attr_case (outf
, attr
, av
, 1, "return", ";", 4, true_rtx
);
4512 write_attr_case (outf
, attr
, common_av
, 0, "return", ";", 4, true_rtx
);
4513 fprintf (outf
, " }\n");
4518 /* Write a nested CASE. The first indicates which condition we need to
4519 test, and the inner CASE tests the condition. */
4520 fprintf (outf
, " insn = candidate_insn;\n");
4521 fprintf (outf
, " switch (slot)\n");
4522 fprintf (outf
, " {\n");
4524 for (delay
= delays
; delay
; delay
= delay
->next
)
4525 for (i
= 0; i
< XVECLEN (delay
->def
, 1); i
+= 3)
4527 fprintf (outf
, " case %d:\n",
4528 (i
/ 3) + (num_delays
== 1 ? 0 : delay
->num
* max_slots
));
4529 fprintf (outf
, " switch (recog_memoized (insn))\n");
4530 fprintf (outf
, "\t{\n");
4532 sprintf (str
, "*%s_%d_%d", kind
, delay
->num
, i
/ 3);
4534 attr
= find_attr (&pstr
, 0);
4536 common_av
= find_most_used (attr
);
4538 for (av
= attr
->first_value
; av
; av
= av
->next
)
4539 if (av
!= common_av
)
4540 write_attr_case (outf
, attr
, av
, 1, "return", ";", 8, true_rtx
);
4542 write_attr_case (outf
, attr
, common_av
, 0, "return", ";", 8, true_rtx
);
4543 fprintf (outf
, " }\n");
4546 fprintf (outf
, " default:\n");
4547 fprintf (outf
, " gcc_unreachable ();\n");
4548 fprintf (outf
, " }\n");
4551 fprintf (outf
, "}\n\n");
4554 /* This page contains miscellaneous utility routines. */
4556 /* Given a pointer to a (char *), return a malloc'ed string containing the
4557 next comma-separated element. Advance the pointer to after the string
4558 scanned, or the end-of-string. Return NULL if at end of string. */
4561 next_comma_elt (const char **pstr
)
4565 start
= scan_comma_elt (pstr
);
4570 return attr_string (start
, *pstr
- start
);
4573 /* Return a `struct attr_desc' pointer for a given named attribute. If CREATE
4574 is nonzero, build a new attribute, if one does not exist. *NAME_P is
4575 replaced by a pointer to a canonical copy of the string. */
4577 static struct attr_desc
*
4578 find_attr (const char **name_p
, int create
)
4580 struct attr_desc
*attr
;
4582 const char *name
= *name_p
;
4584 /* Before we resort to using `strcmp', see if the string address matches
4585 anywhere. In most cases, it should have been canonicalized to do so. */
4586 if (name
== alternative_name
)
4589 index
= name
[0] & (MAX_ATTRS_INDEX
- 1);
4590 for (attr
= attrs
[index
]; attr
; attr
= attr
->next
)
4591 if (name
== attr
->name
)
4594 /* Otherwise, do it the slow way. */
4595 for (attr
= attrs
[index
]; attr
; attr
= attr
->next
)
4596 if (name
[0] == attr
->name
[0] && ! strcmp (name
, attr
->name
))
4598 *name_p
= attr
->name
;
4605 attr
= oballoc (struct attr_desc
);
4606 attr
->name
= DEF_ATTR_STRING (name
);
4607 attr
->enum_name
= 0;
4608 attr
->first_value
= attr
->default_val
= NULL
;
4609 attr
->is_numeric
= attr
->is_const
= attr
->is_special
= 0;
4610 attr
->next
= attrs
[index
];
4611 attrs
[index
] = attr
;
4613 *name_p
= attr
->name
;
4618 /* Create internal attribute with the given default value. */
4621 make_internal_attr (const char *name
, rtx value
, int special
)
4623 struct attr_desc
*attr
;
4625 attr
= find_attr (&name
, 1);
4626 gcc_assert (!attr
->default_val
);
4628 attr
->is_numeric
= 1;
4630 attr
->is_special
= (special
& ATTR_SPECIAL
) != 0;
4631 attr
->default_val
= get_attr_value (value
, attr
, -2);
4634 /* Find the most used value of an attribute. */
4636 static struct attr_value
*
4637 find_most_used (struct attr_desc
*attr
)
4639 struct attr_value
*av
;
4640 struct attr_value
*most_used
;
4646 for (av
= attr
->first_value
; av
; av
= av
->next
)
4647 if (av
->num_insns
> nuses
)
4648 nuses
= av
->num_insns
, most_used
= av
;
4653 /* Return (attr_value "n") */
4656 make_numeric_value (int n
)
4658 static rtx int_values
[20];
4662 gcc_assert (n
>= 0);
4664 if (n
< 20 && int_values
[n
])
4665 return int_values
[n
];
4667 p
= attr_printf (MAX_DIGITS
, "%d", n
);
4668 exp
= attr_rtx (CONST_STRING
, p
);
4671 int_values
[n
] = exp
;
4677 copy_rtx_unchanging (rtx orig
)
4679 if (ATTR_IND_SIMPLIFIED_P (orig
) || ATTR_CURR_SIMPLIFIED_P (orig
))
4682 ATTR_CURR_SIMPLIFIED_P (orig
) = 1;
4686 /* Determine if an insn has a constant number of delay slots, i.e., the
4687 number of delay slots is not a function of the length of the insn. */
4690 write_const_num_delay_slots (FILE *outf
)
4692 struct attr_desc
*attr
= find_attr (&num_delay_slots_str
, 0);
4693 struct attr_value
*av
;
4697 fprintf (outf
, "int\nconst_num_delay_slots (rtx insn)\n");
4698 fprintf (outf
, "{\n");
4699 fprintf (outf
, " switch (recog_memoized (insn))\n");
4700 fprintf (outf
, " {\n");
4702 for (av
= attr
->first_value
; av
; av
= av
->next
)
4705 walk_attr_value (av
->value
);
4707 write_insn_cases (outf
, av
->first_insn
, 4);
4710 fprintf (outf
, " default:\n");
4711 fprintf (outf
, " return 1;\n");
4712 fprintf (outf
, " }\n}\n\n");
4716 /* Synthetic attributes used by insn-automata.c and the scheduler.
4717 These are primarily concerned with (define_insn_reservation)
4722 struct insn_reserv
*next
;
4725 int default_latency
;
4728 /* Sequence number of this insn. */
4731 /* Whether a (define_bypass) construct names this insn in its
4736 static struct insn_reserv
*all_insn_reservs
= 0;
4737 static struct insn_reserv
**last_insn_reserv_p
= &all_insn_reservs
;
4738 static size_t n_insn_reservs
;
4740 /* Store information from a DEFINE_INSN_RESERVATION for future
4741 attribute generation. */
4743 gen_insn_reserv (rtx def
)
4745 struct insn_reserv
*decl
= oballoc (struct insn_reserv
);
4747 decl
->name
= DEF_ATTR_STRING (XSTR (def
, 0));
4748 decl
->default_latency
= XINT (def
, 1);
4749 decl
->condexp
= check_attr_test (XEXP (def
, 2), 0, 0);
4750 decl
->insn_num
= n_insn_reservs
;
4751 decl
->bypassed
= false;
4754 *last_insn_reserv_p
= decl
;
4755 last_insn_reserv_p
= &decl
->next
;
4759 /* Store information from a DEFINE_BYPASS for future attribute
4760 generation. The only thing we care about is the list of output
4761 insns, which will later be used to tag reservation structures with
4762 a 'bypassed' bit. */
4766 struct bypass_list
*next
;
4767 const char *pattern
;
4770 static struct bypass_list
*all_bypasses
;
4771 static size_t n_bypasses
;
4774 gen_bypass_1 (const char *s
, size_t len
)
4776 struct bypass_list
*b
;
4781 s
= attr_string (s
, len
);
4782 for (b
= all_bypasses
; b
; b
= b
->next
)
4783 if (s
== b
->pattern
)
4784 return; /* already got that one */
4786 b
= oballoc (struct bypass_list
);
4788 b
->next
= all_bypasses
;
4794 gen_bypass (rtx def
)
4796 const char *p
, *base
;
4798 for (p
= base
= XSTR (def
, 1); *p
; p
++)
4801 gen_bypass_1 (base
, p
- base
);
4804 while (ISSPACE (*p
));
4807 gen_bypass_1 (base
, p
- base
);
4810 /* Find and mark all of the bypassed insns. */
4812 process_bypasses (void)
4814 struct bypass_list
*b
;
4815 struct insn_reserv
*r
;
4817 /* The reservation list is likely to be much longer than the bypass
4819 for (r
= all_insn_reservs
; r
; r
= r
->next
)
4820 for (b
= all_bypasses
; b
; b
= b
->next
)
4821 if (fnmatch (b
->pattern
, r
->name
, 0) == 0)
4825 /* Check that attribute NAME is used in define_insn_reservation condition
4826 EXP. Return true if it is. */
4828 check_tune_attr (const char *name
, rtx exp
)
4830 switch (GET_CODE (exp
))
4833 if (check_tune_attr (name
, XEXP (exp
, 0)))
4835 return check_tune_attr (name
, XEXP (exp
, 1));
4838 return (check_tune_attr (name
, XEXP (exp
, 0))
4839 && check_tune_attr (name
, XEXP (exp
, 1)));
4842 return XSTR (exp
, 0) == name
;
4849 /* Try to find a const attribute (usually cpu or tune) that is used
4850 in all define_insn_reservation conditions. */
4851 static struct attr_desc
*
4852 find_tune_attr (rtx exp
)
4854 struct attr_desc
*attr
;
4856 switch (GET_CODE (exp
))
4860 attr
= find_tune_attr (XEXP (exp
, 0));
4863 return find_tune_attr (XEXP (exp
, 1));
4866 if (XSTR (exp
, 0) == alternative_name
)
4869 attr
= find_attr (&XSTR (exp
, 0), 0);
4872 if (attr
->is_const
&& !attr
->is_special
)
4874 struct insn_reserv
*decl
;
4876 for (decl
= all_insn_reservs
; decl
; decl
= decl
->next
)
4877 if (! check_tune_attr (attr
->name
, decl
->condexp
))
4888 /* Create all of the attributes that describe automaton properties.
4889 Write the DFA and latency function prototypes to the files that
4890 need to have them, and write the init_sched_attrs(). */
4893 make_automaton_attrs (void)
4896 struct insn_reserv
*decl
;
4897 rtx code_exp
, lats_exp
, byps_exp
;
4898 struct attr_desc
*tune_attr
;
4900 if (n_insn_reservs
== 0)
4903 tune_attr
= find_tune_attr (all_insn_reservs
->condexp
);
4904 if (tune_attr
!= NULL
)
4906 rtx
*condexps
= XNEWVEC (rtx
, n_insn_reservs
* 3);
4907 struct attr_value
*val
;
4910 gcc_assert (tune_attr
->is_const
4911 && !tune_attr
->is_special
4912 && !tune_attr
->is_numeric
);
4914 /* Write the prototypes for all DFA functions. */
4915 for (val
= tune_attr
->first_value
; val
; val
= val
->next
)
4917 if (val
== tune_attr
->default_val
)
4919 gcc_assert (GET_CODE (val
->value
) == CONST_STRING
);
4921 "extern int internal_dfa_insn_code_%s (rtx);\n",
4922 XSTR (val
->value
, 0));
4924 fprintf (dfa_file
, "\n");
4926 /* Write the prototypes for all latency functions. */
4927 for (val
= tune_attr
->first_value
; val
; val
= val
->next
)
4929 if (val
== tune_attr
->default_val
)
4931 gcc_assert (GET_CODE (val
->value
) == CONST_STRING
);
4932 fprintf (latency_file
,
4933 "extern int insn_default_latency_%s (rtx);\n",
4934 XSTR (val
->value
, 0));
4936 fprintf (latency_file
, "\n");
4938 /* Write the prototypes for all automaton functions. */
4939 for (val
= tune_attr
->first_value
; val
; val
= val
->next
)
4941 if (val
== tune_attr
->default_val
)
4943 gcc_assert (GET_CODE (val
->value
) == CONST_STRING
);
4945 "extern int internal_dfa_insn_code_%s (rtx);\n"
4946 "extern int insn_default_latency_%s (rtx);\n",
4947 XSTR (val
->value
, 0), XSTR (val
->value
, 0));
4949 fprintf (attr_file
, "\n");
4950 fprintf (attr_file
, "int (*internal_dfa_insn_code) (rtx);\n");
4951 fprintf (attr_file
, "int (*insn_default_latency) (rtx);\n");
4952 fprintf (attr_file
, "\n");
4953 fprintf (attr_file
, "void\n");
4954 fprintf (attr_file
, "init_sched_attrs (void)\n");
4955 fprintf (attr_file
, "{\n");
4957 for (val
= tune_attr
->first_value
; val
; val
= val
->next
)
4961 rtx test
= attr_rtx (EQ_ATTR
, tune_attr
->name
, XSTR (val
->value
, 0));
4963 if (val
== tune_attr
->default_val
)
4965 for (decl
= all_insn_reservs
, i
= 0;
4971 = simplify_and_tree (decl
->condexp
, &ctest
, -2, 0);
4972 if (condexp
== false_rtx
)
4974 if (condexp
== true_rtx
)
4976 condexps
[i
] = condexp
;
4977 condexps
[i
+ 1] = make_numeric_value (decl
->insn_num
);
4978 condexps
[i
+ 2] = make_numeric_value (decl
->default_latency
);
4982 code_exp
= rtx_alloc (COND
);
4983 lats_exp
= rtx_alloc (COND
);
4986 XVEC (code_exp
, 0) = rtvec_alloc (j
);
4987 XVEC (lats_exp
, 0) = rtvec_alloc (j
);
4991 XEXP (code_exp
, 1) = make_numeric_value (decl
->insn_num
);
4992 XEXP (lats_exp
, 1) = make_numeric_value (decl
->default_latency
);
4996 XEXP (code_exp
, 1) = make_numeric_value (n_insn_reservs
+ 1);
4997 XEXP (lats_exp
, 1) = make_numeric_value (0);
5004 XVECEXP (code_exp
, 0, j
) = condexps
[i
];
5005 XVECEXP (lats_exp
, 0, j
) = condexps
[i
];
5007 XVECEXP (code_exp
, 0, j
+ 1) = condexps
[i
+ 1];
5008 XVECEXP (lats_exp
, 0, j
+ 1) = condexps
[i
+ 2];
5011 name
= XNEWVEC (char,
5012 sizeof ("*internal_dfa_insn_code_")
5013 + strlen (XSTR (val
->value
, 0)));
5014 strcpy (name
, "*internal_dfa_insn_code_");
5015 strcat (name
, XSTR (val
->value
, 0));
5016 make_internal_attr (name
, code_exp
, ATTR_NONE
);
5017 strcpy (name
, "*insn_default_latency_");
5018 strcat (name
, XSTR (val
->value
, 0));
5019 make_internal_attr (name
, lats_exp
, ATTR_NONE
);
5024 fprintf (attr_file
, " if (");
5028 fprintf (attr_file
, " else if (");
5029 write_test_expr (attr_file
, test
, 0, 0);
5030 fprintf (attr_file
, ")\n");
5031 fprintf (attr_file
, " {\n");
5032 fprintf (attr_file
, " internal_dfa_insn_code\n");
5033 fprintf (attr_file
, " = internal_dfa_insn_code_%s;\n",
5034 XSTR (val
->value
, 0));
5035 fprintf (attr_file
, " insn_default_latency\n");
5036 fprintf (attr_file
, " = insn_default_latency_%s;\n",
5037 XSTR (val
->value
, 0));
5038 fprintf (attr_file
, " }\n");
5041 fprintf (attr_file
, " else\n");
5042 fprintf (attr_file
, " gcc_unreachable ();\n");
5043 fprintf (attr_file
, "}\n");
5044 fprintf (attr_file
, "\n");
5046 XDELETEVEC (condexps
);
5050 code_exp
= rtx_alloc (COND
);
5051 lats_exp
= rtx_alloc (COND
);
5053 XVEC (code_exp
, 0) = rtvec_alloc (n_insn_reservs
* 2);
5054 XVEC (lats_exp
, 0) = rtvec_alloc (n_insn_reservs
* 2);
5056 XEXP (code_exp
, 1) = make_numeric_value (n_insn_reservs
+ 1);
5057 XEXP (lats_exp
, 1) = make_numeric_value (0);
5059 for (decl
= all_insn_reservs
, i
= 0;
5061 decl
= decl
->next
, i
+= 2)
5063 XVECEXP (code_exp
, 0, i
) = decl
->condexp
;
5064 XVECEXP (lats_exp
, 0, i
) = decl
->condexp
;
5066 XVECEXP (code_exp
, 0, i
+1) = make_numeric_value (decl
->insn_num
);
5067 XVECEXP (lats_exp
, 0, i
+1)
5068 = make_numeric_value (decl
->default_latency
);
5070 make_internal_attr ("*internal_dfa_insn_code", code_exp
, ATTR_NONE
);
5071 make_internal_attr ("*insn_default_latency", lats_exp
, ATTR_NONE
);
5074 if (n_bypasses
== 0)
5075 byps_exp
= make_numeric_value (0);
5078 process_bypasses ();
5080 byps_exp
= rtx_alloc (COND
);
5081 XVEC (byps_exp
, 0) = rtvec_alloc (n_bypasses
* 2);
5082 XEXP (byps_exp
, 1) = make_numeric_value (0);
5083 for (decl
= all_insn_reservs
, i
= 0;
5088 XVECEXP (byps_exp
, 0, i
) = decl
->condexp
;
5089 XVECEXP (byps_exp
, 0, i
+1) = make_numeric_value (1);
5094 make_internal_attr ("*bypass_p", byps_exp
, ATTR_NONE
);
5098 write_header (FILE *outf
)
5100 fprintf (outf
, "/* Generated automatically by the program `genattrtab'\n"
5101 " from the machine description file `md'. */\n\n");
5103 fprintf (outf
, "#include \"config.h\"\n");
5104 fprintf (outf
, "#include \"system.h\"\n");
5105 fprintf (outf
, "#include \"coretypes.h\"\n");
5106 fprintf (outf
, "#include \"tm.h\"\n");
5107 fprintf (outf
, "#include \"tree.h\"\n");
5108 fprintf (outf
, "#include \"varasm.h\"\n");
5109 fprintf (outf
, "#include \"stor-layout.h\"\n");
5110 fprintf (outf
, "#include \"calls.h\"\n");
5111 fprintf (outf
, "#include \"rtl.h\"\n");
5112 fprintf (outf
, "#include \"insn-attr.h\"\n");
5113 fprintf (outf
, "#include \"tm_p.h\"\n");
5114 fprintf (outf
, "#include \"insn-config.h\"\n");
5115 fprintf (outf
, "#include \"recog.h\"\n");
5116 fprintf (outf
, "#include \"regs.h\"\n");
5117 fprintf (outf
, "#include \"real.h\"\n");
5118 fprintf (outf
, "#include \"output.h\"\n");
5119 fprintf (outf
, "#include \"toplev.h\"\n");
5120 fprintf (outf
, "#include \"flags.h\"\n");
5121 fprintf (outf
, "#include \"function.h\"\n");
5122 fprintf (outf
, "\n");
5123 fprintf (outf
, "#define operands recog_data.operand\n\n");
5127 open_outfile (const char *file_name
)
5130 outf
= fopen (file_name
, "w");
5132 fatal ("cannot open file %s: %s", file_name
, xstrerror (errno
));
5133 write_header (outf
);
5138 handle_arg (const char *arg
)
5143 attr_file_name
= &arg
[2];
5146 dfa_file_name
= &arg
[2];
5149 latency_file_name
= &arg
[2];
5157 main (int argc
, char **argv
)
5160 struct attr_desc
*attr
;
5161 struct insn_def
*id
;
5165 progname
= "genattrtab";
5167 if (!init_rtx_reader_args_cb (argc
, argv
, handle_arg
))
5168 return FATAL_EXIT_CODE
;
5170 attr_file
= open_outfile (attr_file_name
);
5171 dfa_file
= open_outfile (dfa_file_name
);
5172 latency_file
= open_outfile (latency_file_name
);
5174 obstack_init (hash_obstack
);
5175 obstack_init (temp_obstack
);
5177 /* Set up true and false rtx's */
5178 true_rtx
= rtx_alloc (CONST_INT
);
5179 XWINT (true_rtx
, 0) = 1;
5180 false_rtx
= rtx_alloc (CONST_INT
);
5181 XWINT (false_rtx
, 0) = 0;
5182 ATTR_IND_SIMPLIFIED_P (true_rtx
) = ATTR_IND_SIMPLIFIED_P (false_rtx
) = 1;
5183 ATTR_PERMANENT_P (true_rtx
) = ATTR_PERMANENT_P (false_rtx
) = 1;
5185 alternative_name
= DEF_ATTR_STRING ("alternative");
5186 length_str
= DEF_ATTR_STRING ("length");
5187 delay_type_str
= DEF_ATTR_STRING ("*delay_type");
5188 delay_1_0_str
= DEF_ATTR_STRING ("*delay_1_0");
5189 num_delay_slots_str
= DEF_ATTR_STRING ("*num_delay_slots");
5191 /* Read the machine description. */
5197 desc
= read_md_rtx (&lineno
, &insn_code_number
);
5201 switch (GET_CODE (desc
))
5204 case DEFINE_PEEPHOLE
:
5205 case DEFINE_ASM_ATTRIBUTES
:
5206 gen_insn (desc
, lineno
);
5210 case DEFINE_ENUM_ATTR
:
5211 gen_attr (desc
, lineno
);
5215 gen_delay (desc
, lineno
);
5218 case DEFINE_INSN_RESERVATION
:
5219 gen_insn_reserv (desc
);
5229 if (GET_CODE (desc
) != DEFINE_ASM_ATTRIBUTES
)
5230 insn_index_number
++;
5234 return FATAL_EXIT_CODE
;
5238 /* If we didn't have a DEFINE_ASM_ATTRIBUTES, make a null one. */
5239 if (! got_define_asm_attributes
)
5241 tem
= rtx_alloc (DEFINE_ASM_ATTRIBUTES
);
5242 XVEC (tem
, 0) = rtvec_alloc (0);
5246 /* Expand DEFINE_DELAY information into new attribute. */
5250 /* Make `insn_alternatives'. */
5251 insn_alternatives
= oballocvec (int, insn_code_number
);
5252 for (id
= defs
; id
; id
= id
->next
)
5253 if (id
->insn_code
>= 0)
5254 insn_alternatives
[id
->insn_code
] = (1 << id
->num_alternatives
) - 1;
5256 /* Make `insn_n_alternatives'. */
5257 insn_n_alternatives
= oballocvec (int, insn_code_number
);
5258 for (id
= defs
; id
; id
= id
->next
)
5259 if (id
->insn_code
>= 0)
5260 insn_n_alternatives
[id
->insn_code
] = id
->num_alternatives
;
5262 /* Construct extra attributes for automata. */
5263 make_automaton_attrs ();
5265 /* Prepare to write out attribute subroutines by checking everything stored
5266 away and building the attribute cases. */
5270 for (i
= 0; i
< MAX_ATTRS_INDEX
; i
++)
5271 for (attr
= attrs
[i
]; attr
; attr
= attr
->next
)
5272 attr
->default_val
->value
5273 = check_attr_value (attr
->default_val
->value
, attr
);
5276 return FATAL_EXIT_CODE
;
5278 for (i
= 0; i
< MAX_ATTRS_INDEX
; i
++)
5279 for (attr
= attrs
[i
]; attr
; attr
= attr
->next
)
5282 /* Construct extra attributes for `length'. */
5283 make_length_attrs ();
5285 /* Perform any possible optimizations to speed up compilation. */
5288 /* Now write out all the `gen_attr_...' routines. Do these before the
5289 special routines so that they get defined before they are used. */
5291 for (i
= 0; i
< MAX_ATTRS_INDEX
; i
++)
5292 for (attr
= attrs
[i
]; attr
; attr
= attr
->next
)
5296 #define IS_ATTR_GROUP(X) (!strncmp (attr->name, X, strlen (X)))
5297 if (IS_ATTR_GROUP ("*internal_dfa_insn_code"))
5299 else if (IS_ATTR_GROUP ("*insn_default_latency"))
5300 outf
= latency_file
;
5303 #undef IS_ATTR_GROUP
5305 if (! attr
->is_special
&& ! attr
->is_const
)
5306 write_attr_get (outf
, attr
);
5309 /* Write out delay eligibility information, if DEFINE_DELAY present.
5310 (The function to compute the number of delay slots will be written
5314 write_eligible_delay (attr_file
, "delay");
5315 if (have_annul_true
)
5316 write_eligible_delay (attr_file
, "annul_true");
5317 if (have_annul_false
)
5318 write_eligible_delay (attr_file
, "annul_false");
5321 /* Write out constant delay slot info. */
5322 write_const_num_delay_slots (attr_file
);
5324 write_length_unit_log (attr_file
);
5326 if (fclose (attr_file
) != 0)
5327 fatal ("cannot close file %s: %s", attr_file_name
, xstrerror (errno
));
5328 if (fclose (dfa_file
) != 0)
5329 fatal ("cannot close file %s: %s", dfa_file_name
, xstrerror (errno
));
5330 if (fclose (latency_file
) != 0)
5331 fatal ("cannot close file %s: %s", latency_file_name
, xstrerror (errno
));
5333 return SUCCESS_EXIT_CODE
;