?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
* config/i386/i386.md (mmx_pinsrw): Output operands in correct
[official-gcc.git] / gcc / genattrtab.c
blobd3f77b0640d66b92f7cf74af59fde5b1b653a249
1 /* Generate code from machine description to compute values of attributes.
2 Copyright (C) 1991, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000 Free Software Foundation, Inc.
4 Contributed by Richard Kenner (kenner@vlsi1.ultra.nyu.edu)
5
6 This file is part of GNU CC.
7
8 GNU CC is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
11 any later version.
12
13 GNU CC is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with GNU CC; see the file COPYING. If not, write to
20 the Free Software Foundation, 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
22
23 /* This program handles insn attributes and the DEFINE_DELAY and
24 DEFINE_FUNCTION_UNIT definitions.
25
26 It produces a series of functions named `get_attr_...', one for each insn
27 attribute. Each of these is given the rtx for an insn and returns a member
28 of the enum for the attribute.
29
30 These subroutines have the form of a `switch' on the INSN_CODE (via
31 `recog_memoized'). Each case either returns a constant attribute value
32 or a value that depends on tests on other attributes, the form of
33 operands, or some random C expression (encoded with a SYMBOL_REF
34 expression).
35
36 If the attribute `alternative', or a random C expression is present,
37 `constrain_operands' is called. If either of these cases of a reference to
38 an operand is found, `extract_insn' is called.
39
40 The special attribute `length' is also recognized. For this operand,
41 expressions involving the address of an operand or the current insn,
42 (address (pc)), are valid. In this case, an initial pass is made to
43 set all lengths that do not depend on address. Those that do are set to
44 the maximum length. Then each insn that depends on an address is checked
45 and possibly has its length changed. The process repeats until no further
46 changed are made. The resulting lengths are saved for use by
47 `get_attr_length'.
48
49 A special form of DEFINE_ATTR, where the expression for default value is a
50 CONST expression, indicates an attribute that is constant for a given run
51 of the compiler. The subroutine generated for these attributes has no
52 parameters as it does not depend on any particular insn. Constant
53 attributes are typically used to specify which variety of processor is
54 used.
55
56 Internal attributes are defined to handle DEFINE_DELAY and
57 DEFINE_FUNCTION_UNIT. Special routines are output for these cases.
58
59 This program works by keeping a list of possible values for each attribute.
60 These include the basic attribute choices, default values for attribute, and
61 all derived quantities.
62
63 As the description file is read, the definition for each insn is saved in a
64 `struct insn_def'. When the file reading is complete, a `struct insn_ent'
65 is created for each insn and chained to the corresponding attribute value,
66 either that specified, or the default.
67
68 An optimization phase is then run. This simplifies expressions for each
69 insn. EQ_ATTR tests are resolved, whenever possible, to a test that
70 indicates when the attribute has the specified value for the insn. This
71 avoids recursive calls during compilation.
72
73 The strategy used when processing DEFINE_DELAY and DEFINE_FUNCTION_UNIT
74 definitions is to create arbitrarily complex expressions and have the
75 optimization simplify them.
76
77 Once optimization is complete, any required routines and definitions
78 will be written.
79
80 An optimization that is not yet implemented is to hoist the constant
81 expressions entirely out of the routines and definitions that are written.
82 A way to do this is to iterate over all possible combinations of values
83 for constant attributes and generate a set of functions for that given
84 combination. An initialization function would be written that evaluates
85 the attributes and installs the corresponding set of routines and
86 definitions (each would be accessed through a pointer).
87
88 We use the flags in an RTX as follows:
89 `unchanging' (RTX_UNCHANGING_P): This rtx is fully simplified
90 independent of the insn code.
91 `in_struct' (MEM_IN_STRUCT_P): This rtx is fully simplified
92 for the insn code currently being processed (see optimize_attrs).
93 `integrated' (RTX_INTEGRATED_P): This rtx is permanent and unique
94 (see attr_rtx).
95 `volatil' (MEM_VOLATILE_P): During simplify_by_exploding the value of an
96 EQ_ATTR rtx is true if !volatil and false if volatil. */
97
98 #include "hconfig.h"
99 #include "system.h"
100 #include "rtl.h"
101 #include "ggc.h"
102 #include "gensupport.h"
103
104 #ifdef HAVE_SYS_RESOURCE_H
105 # include <sys/resource.h>
106 #endif
107
108 /* We must include obstack.h after <sys/time.h>, to avoid lossage with
109 /usr/include/sys/stdtypes.h on Sun OS 4.x. */
110 #include "obstack.h"
111 #include "errors.h"
112
113 static struct obstack obstack1, obstack2;
114 struct obstack *hash_obstack = &obstack1;
115 struct obstack *temp_obstack = &obstack2;
116
117 #define obstack_chunk_alloc xmalloc
118 #define obstack_chunk_free free
119
120 /* enough space to reserve for printing out ints */
121 #define MAX_DIGITS (HOST_BITS_PER_INT * 3 / 10 + 3)
122
123 /* Define structures used to record attributes and values. */
124
125 /* As each DEFINE_INSN, DEFINE_PEEPHOLE, or DEFINE_ASM_ATTRIBUTES is
126 encountered, we store all the relevant information into a
127 `struct insn_def'. This is done to allow attribute definitions to occur
128 anywhere in the file. */
129
130 struct insn_def
131 {
132 struct insn_def *next; /* Next insn in chain. */
133 rtx def; /* The DEFINE_... */
134 int insn_code; /* Instruction number. */
135 int insn_index; /* Expression numer in file, for errors. */
136 int lineno; /* Line number. */
137 int num_alternatives; /* Number of alternatives. */
138 int vec_idx; /* Index of attribute vector in `def'. */
139 };
140
141 /* Once everything has been read in, we store in each attribute value a list
142 of insn codes that have that value. Here is the structure used for the
143 list. */
144
145 struct insn_ent
146 {
147 struct insn_ent *next; /* Next in chain. */
148 int insn_code; /* Instruction number. */
149 int insn_index; /* Index of definition in file */
150 int lineno; /* Line number. */
151 };
152
153 /* Each value of an attribute (either constant or computed) is assigned a
154 structure which is used as the listhead of the insns that have that
155 value. */
156
157 struct attr_value
158 {
159 rtx value; /* Value of attribute. */
160 struct attr_value *next; /* Next attribute value in chain. */
161 struct insn_ent *first_insn; /* First insn with this value. */
162 int num_insns; /* Number of insns with this value. */
163 int has_asm_insn; /* True if this value used for `asm' insns */
164 };
165
166 /* Structure for each attribute. */
167
168 struct attr_desc
169 {
170 char *name; /* Name of attribute. */
171 struct attr_desc *next; /* Next attribute. */
172 unsigned is_numeric : 1; /* Values of this attribute are numeric. */
173 unsigned negative_ok : 1; /* Allow negative numeric values. */
174 unsigned unsigned_p : 1; /* Make the output function unsigned int. */
175 unsigned is_const : 1; /* Attribute value constant for each run. */
176 unsigned is_special : 1; /* Don't call `write_attr_set'. */
177 unsigned func_units_p : 1; /* this is the function_units attribute */
178 unsigned blockage_p : 1; /* this is the blockage range function */
179 struct attr_value *first_value; /* First value of this attribute. */
180 struct attr_value *default_val; /* Default value for this attribute. */
181 int lineno; /* Line number. */
182 };
183
184 #define NULL_ATTR (struct attr_desc *) NULL
185
186 /* A range of values. */
187
188 struct range
189 {
190 int min;
191 int max;
192 };
193
194 /* Structure for each DEFINE_DELAY. */
195
196 struct delay_desc
197 {
198 rtx def; /* DEFINE_DELAY expression. */
199 struct delay_desc *next; /* Next DEFINE_DELAY. */
200 int num; /* Number of DEFINE_DELAY, starting at 1. */
201 int lineno; /* Line number. */
202 };
203
204 /* Record information about each DEFINE_FUNCTION_UNIT. */
205
206 struct function_unit_op
207 {
208 rtx condexp; /* Expression TRUE for applicable insn. */
209 struct function_unit_op *next; /* Next operation for this function unit. */
210 int num; /* Ordinal for this operation type in unit. */
211 int ready; /* Cost until data is ready. */
212 int issue_delay; /* Cost until unit can accept another insn. */
213 rtx conflict_exp; /* Expression TRUE for insns incurring issue delay. */
214 rtx issue_exp; /* Expression computing issue delay. */
215 int lineno; /* Line number. */
216 };
217
218 /* Record information about each function unit mentioned in a
219 DEFINE_FUNCTION_UNIT. */
220
221 struct function_unit
222 {
223 const char *name; /* Function unit name. */
224 struct function_unit *next; /* Next function unit. */
225 int num; /* Ordinal of this unit type. */
226 int multiplicity; /* Number of units of this type. */
227 int simultaneity; /* Maximum number of simultaneous insns
228 on this function unit or 0 if unlimited. */
229 rtx condexp; /* Expression TRUE for insn needing unit. */
230 int num_opclasses; /* Number of different operation types. */
231 struct function_unit_op *ops; /* Pointer to first operation type. */
232 int needs_conflict_function; /* Nonzero if a conflict function required. */
233 int needs_blockage_function; /* Nonzero if a blockage function required. */
234 int needs_range_function; /* Nonzero if blockage range function needed.*/
235 rtx default_cost; /* Conflict cost, if constant. */
236 struct range issue_delay; /* Range of issue delay values. */
237 int max_blockage; /* Maximum time an insn blocks the unit. */
238 int first_lineno; /* First seen line number. */
239 };
240
241 /* Listheads of above structures. */
242
243 /* This one is indexed by the first character of the attribute name. */
244 #define MAX_ATTRS_INDEX 256
245 static struct attr_desc *attrs[MAX_ATTRS_INDEX];
246 static struct insn_def *defs;
247 static struct delay_desc *delays;
248 static struct function_unit *units;
249
250 /* An expression where all the unknown terms are EQ_ATTR tests can be
251 rearranged into a COND provided we can enumerate all possible
252 combinations of the unknown values. The set of combinations become the
253 tests of the COND; the value of the expression given that combination is
254 computed and becomes the corresponding value. To do this, we must be
255 able to enumerate all values for each attribute used in the expression
256 (currently, we give up if we find a numeric attribute).
257
258 If the set of EQ_ATTR tests used in an expression tests the value of N
259 different attributes, the list of all possible combinations can be made
260 by walking the N-dimensional attribute space defined by those
261 attributes. We record each of these as a struct dimension.
262
263 The algorithm relies on sharing EQ_ATTR nodes: if two nodes in an
264 expression are the same, the will also have the same address. We find
265 all the EQ_ATTR nodes by marking them MEM_VOLATILE_P. This bit later
266 represents the value of an EQ_ATTR node, so once all nodes are marked,
267 they are also given an initial value of FALSE.
268
269 We then separate the set of EQ_ATTR nodes into dimensions for each
270 attribute and put them on the VALUES list. Terms are added as needed by
271 `add_values_to_cover' so that all possible values of the attribute are
272 tested.
273
274 Each dimension also has a current value. This is the node that is
275 currently considered to be TRUE. If this is one of the nodes added by
276 `add_values_to_cover', all the EQ_ATTR tests in the original expression
277 will be FALSE. Otherwise, only the CURRENT_VALUE will be true.
278
279 NUM_VALUES is simply the length of the VALUES list and is there for
280 convenience.
281
282 Once the dimensions are created, the algorithm enumerates all possible
283 values and computes the current value of the given expression. */
284
285 struct dimension
286 {
287 struct attr_desc *attr; /* Attribute for this dimension. */
288 rtx values; /* List of attribute values used. */
289 rtx current_value; /* Position in the list for the TRUE value. */
290 int num_values; /* Length of the values list. */
291 };
292
293 /* Other variables. */
294
295 static int insn_code_number;
296 static int insn_index_number;
297 static int got_define_asm_attributes;
298 static int must_extract;
299 static int must_constrain;
300 static int address_used;
301 static int length_used;
302 static int num_delays;
303 static int have_annul_true, have_annul_false;
304 static int num_units, num_unit_opclasses;
305 static int num_insn_ents;
306
307 /* Used as operand to `operate_exp': */
308
309 enum operator {PLUS_OP, MINUS_OP, POS_MINUS_OP, EQ_OP, OR_OP, ORX_OP, MAX_OP, MIN_OP, RANGE_OP};
310
311 /* Stores, for each insn code, the number of constraint alternatives. */
312
313 static int *insn_n_alternatives;
314
315 /* Stores, for each insn code, a bitmap that has bits on for each possible
316 alternative. */
317
318 static int *insn_alternatives;
319
320 /* If nonzero, assume that the `alternative' attr has this value.
321 This is the hashed, unique string for the numeral
322 whose value is chosen alternative. */
323
324 static const char *current_alternative_string;
325
326 /* Used to simplify expressions. */
327
328 static rtx true_rtx, false_rtx;
329
330 /* Used to reduce calls to `strcmp' */
331
332 static char *alternative_name;
333
334 /* Indicate that REG_DEAD notes are valid if dead_or_set_p is ever
335 called. */
336
337 int reload_completed = 0;
338
339 /* Some machines test `optimize' in macros called from rtlanal.c, so we need
340 to define it here. */
341
342 int optimize = 0;
343
344 /* Simplify an expression. Only call the routine if there is something to
345 simplify. */
346 #define SIMPLIFY_TEST_EXP(EXP,INSN_CODE,INSN_INDEX) \
347 (RTX_UNCHANGING_P (EXP) || MEM_IN_STRUCT_P (EXP) ? (EXP) \
348 : simplify_test_exp (EXP, INSN_CODE, INSN_INDEX))
349
350 /* Simplify (eq_attr ("alternative") ...)
351 when we are working with a particular alternative. */
352 #define SIMPLIFY_ALTERNATIVE(EXP) \
353 if (current_alternative_string \
354 && GET_CODE ((EXP)) == EQ_ATTR \
355 && XSTR ((EXP), 0) == alternative_name) \
356 (EXP) = (XSTR ((EXP), 1) == current_alternative_string \
357 ? true_rtx : false_rtx);
358
359 /* These are referenced by rtlanal.c and hence need to be defined somewhere.
360 They won't actually be used. */
361
362 rtx global_rtl[GR_MAX];
363 rtx pic_offset_table_rtx;
364
365 static void attr_hash_add_rtx PARAMS ((int, rtx));
366 static void attr_hash_add_string PARAMS ((int, char *));
367 static rtx attr_rtx PARAMS ((enum rtx_code, ...));
368 static char *attr_printf PARAMS ((int, const char *, ...))
369 ATTRIBUTE_PRINTF_2;
370 static char *attr_string PARAMS ((const char *, int));
371 static rtx check_attr_test PARAMS ((rtx, int, int));
372 static rtx check_attr_value PARAMS ((rtx, struct attr_desc *));
373 static rtx convert_set_attr_alternative PARAMS ((rtx, struct insn_def *));
374 static rtx convert_set_attr PARAMS ((rtx, struct insn_def *));
375 static void check_defs PARAMS ((void));
376 #if 0
377 static rtx convert_const_symbol_ref PARAMS ((rtx, struct attr_desc *));
378 #endif
379 static rtx make_canonical PARAMS ((struct attr_desc *, rtx));
380 static struct attr_value *get_attr_value PARAMS ((rtx, struct attr_desc *, int));
381 static rtx copy_rtx_unchanging PARAMS ((rtx));
382 static rtx copy_boolean PARAMS ((rtx));
383 static void expand_delays PARAMS ((void));
384 static rtx operate_exp PARAMS ((enum operator, rtx, rtx));
385 static void expand_units PARAMS ((void));
386 static rtx simplify_knowing PARAMS ((rtx, rtx));
387 static rtx encode_units_mask PARAMS ((rtx));
388 static void fill_attr PARAMS ((struct attr_desc *));
389 /* dpx2 compiler chokes if we specify the arg types of the args. */
390 static rtx substitute_address PARAMS ((rtx, rtx (*) (rtx), rtx (*) (rtx)));
391 static void make_length_attrs PARAMS ((void));
392 static rtx identity_fn PARAMS ((rtx));
393 static rtx zero_fn PARAMS ((rtx));
394 static rtx one_fn PARAMS ((rtx));
395 static rtx max_fn PARAMS ((rtx));
396 static void write_length_unit_log PARAMS ((void));
397 static rtx simplify_cond PARAMS ((rtx, int, int));
398 #if 0
399 static rtx simplify_by_alternatives PARAMS ((rtx, int, int));
400 #endif
401 static rtx simplify_by_exploding PARAMS ((rtx));
402 static int find_and_mark_used_attributes PARAMS ((rtx, rtx *, int *));
403 static void unmark_used_attributes PARAMS ((rtx, struct dimension *, int));
404 static int add_values_to_cover PARAMS ((struct dimension *));
405 static int increment_current_value PARAMS ((struct dimension *, int));
406 static rtx test_for_current_value PARAMS ((struct dimension *, int));
407 static rtx simplify_with_current_value PARAMS ((rtx, struct dimension *, int));
408 static rtx simplify_with_current_value_aux PARAMS ((rtx));
409 static void clear_struct_flag PARAMS ((rtx));
410 static int count_sub_rtxs PARAMS ((rtx, int));
411 static void remove_insn_ent PARAMS ((struct attr_value *, struct insn_ent *));
412 static void insert_insn_ent PARAMS ((struct attr_value *, struct insn_ent *));
413 static rtx insert_right_side PARAMS ((enum rtx_code, rtx, rtx, int, int));
414 static rtx make_alternative_compare PARAMS ((int));
415 static int compute_alternative_mask PARAMS ((rtx, enum rtx_code));
416 static rtx evaluate_eq_attr PARAMS ((rtx, rtx, int, int));
417 static rtx simplify_and_tree PARAMS ((rtx, rtx *, int, int));
418 static rtx simplify_or_tree PARAMS ((rtx, rtx *, int, int));
419 static rtx simplify_test_exp PARAMS ((rtx, int, int));
420 static void optimize_attrs PARAMS ((void));
421 static void gen_attr PARAMS ((rtx, int));
422 static int count_alternatives PARAMS ((rtx));
423 static int compares_alternatives_p PARAMS ((rtx));
424 static int contained_in_p PARAMS ((rtx, rtx));
425 static void gen_insn PARAMS ((rtx, int));
426 static void gen_delay PARAMS ((rtx, int));
427 static void gen_unit PARAMS ((rtx, int));
428 static void write_test_expr PARAMS ((rtx, int));
429 static int max_attr_value PARAMS ((rtx, int*));
430 static int or_attr_value PARAMS ((rtx, int*));
431 static void walk_attr_value PARAMS ((rtx));
432 static void write_attr_get PARAMS ((struct attr_desc *));
433 static rtx eliminate_known_true PARAMS ((rtx, rtx, int, int));
434 static void write_attr_set PARAMS ((struct attr_desc *, int, rtx,
435 const char *, const char *, rtx,
436 int, int));
437 static void write_attr_case PARAMS ((struct attr_desc *, struct attr_value *,
438 int, const char *, const char *, int, rtx));
439 static void write_unit_name PARAMS ((const char *, int, const char *));
440 static void write_attr_valueq PARAMS ((struct attr_desc *, const char *));
441 static void write_attr_value PARAMS ((struct attr_desc *, rtx));
442 static void write_upcase PARAMS ((const char *));
443 static void write_indent PARAMS ((int));
444 static void write_eligible_delay PARAMS ((const char *));
445 static void write_function_unit_info PARAMS ((void));
446 static void write_complex_function PARAMS ((struct function_unit *, const char *,
447 const char *));
448 static int write_expr_attr_cache PARAMS ((rtx, struct attr_desc *));
449 static void write_toplevel_expr PARAMS ((rtx));
450 static void write_const_num_delay_slots PARAMS ((void));
451 static int n_comma_elts PARAMS ((const char *));
452 static char *next_comma_elt PARAMS ((const char **));
453 static struct attr_desc *find_attr PARAMS ((const char *, int));
454 static void make_internal_attr PARAMS ((const char *, rtx, int));
455 static struct attr_value *find_most_used PARAMS ((struct attr_desc *));
456 static rtx find_single_value PARAMS ((struct attr_desc *));
457 static rtx make_numeric_value PARAMS ((int));
458 static void extend_range PARAMS ((struct range *, int, int));
459 static rtx attr_eq PARAMS ((const char *, const char *));
460 static const char *attr_numeral PARAMS ((int));
461 static int attr_equal_p PARAMS ((rtx, rtx));
462 static rtx attr_copy_rtx PARAMS ((rtx));
463
464 #define oballoc(size) obstack_alloc (hash_obstack, size)
465 \f
466 /* Hash table for sharing RTL and strings. */
467
468 /* Each hash table slot is a bucket containing a chain of these structures.
469 Strings are given negative hash codes; RTL expressions are given positive
470 hash codes. */
471
472 struct attr_hash
473 {
474 struct attr_hash *next; /* Next structure in the bucket. */
475 int hashcode; /* Hash code of this rtx or string. */
476 union
477 {
478 char *str; /* The string (negative hash codes) */
479 rtx rtl; /* or the RTL recorded here. */
480 } u;
481 };
482
483 /* Now here is the hash table. When recording an RTL, it is added to
484 the slot whose index is the hash code mod the table size. Note
485 that the hash table is used for several kinds of RTL (see attr_rtx)
486 and for strings. While all these live in the same table, they are
487 completely independent, and the hash code is computed differently
488 for each. */
489
490 #define RTL_HASH_SIZE 4093
491 struct attr_hash *attr_hash_table[RTL_HASH_SIZE];
492
493 /* Here is how primitive or already-shared RTL's hash
494 codes are made. */
495 #define RTL_HASH(RTL) ((long) (RTL) & 0777777)
496
497 /* Add an entry to the hash table for RTL with hash code HASHCODE. */
498
499 static void
500 attr_hash_add_rtx (hashcode, rtl)
501 int hashcode;
502 rtx rtl;
503 {
504 register struct attr_hash *h;
505
506 h = (struct attr_hash *) obstack_alloc (hash_obstack,
507 sizeof (struct attr_hash));
508 h->hashcode = hashcode;
509 h->u.rtl = rtl;
510 h->next = attr_hash_table[hashcode % RTL_HASH_SIZE];
511 attr_hash_table[hashcode % RTL_HASH_SIZE] = h;
512 }
513
514 /* Add an entry to the hash table for STRING with hash code HASHCODE. */
515
516 static void
517 attr_hash_add_string (hashcode, str)
518 int hashcode;
519 char *str;
520 {
521 register struct attr_hash *h;
522
523 h = (struct attr_hash *) obstack_alloc (hash_obstack,
524 sizeof (struct attr_hash));
525 h->hashcode = -hashcode;
526 h->u.str = str;
527 h->next = attr_hash_table[hashcode % RTL_HASH_SIZE];
528 attr_hash_table[hashcode % RTL_HASH_SIZE] = h;
529 }
530
531 /* Generate an RTL expression, but avoid duplicates.
532 Set the RTX_INTEGRATED_P flag for these permanent objects.
533
534 In some cases we cannot uniquify; then we return an ordinary
535 impermanent rtx with RTX_INTEGRATED_P clear.
536
537 Args are like gen_rtx, but without the mode:
538
539 rtx attr_rtx (code, [element1, ..., elementn]) */
540
541 static rtx
542 attr_rtx VPARAMS ((enum rtx_code code, ...))
543 {
544 #ifndef ANSI_PROTOTYPES
545 enum rtx_code code;
546 #endif
547 va_list p;
548 register int i; /* Array indices... */
549 register const char *fmt; /* Current rtx's format... */
550 register rtx rt_val = NULL_RTX;/* RTX to return to caller... */
551 int hashcode;
552 register struct attr_hash *h;
553 struct obstack *old_obstack = rtl_obstack;
554
555 VA_START (p, code);
556
557 #ifndef ANSI_PROTOTYPES
558 code = va_arg (p, enum rtx_code);
559 #endif
560
561 /* For each of several cases, search the hash table for an existing entry.
562 Use that entry if one is found; otherwise create a new RTL and add it
563 to the table. */
564
565 if (GET_RTX_CLASS (code) == '1')
566 {
567 rtx arg0 = va_arg (p, rtx);
568
569 /* A permanent object cannot point to impermanent ones. */
570 if (! RTX_INTEGRATED_P (arg0))
571 {
572 rt_val = rtx_alloc (code);
573 XEXP (rt_val, 0) = arg0;
574 va_end (p);
575 return rt_val;
576 }
577
578 hashcode = ((HOST_WIDE_INT) code + RTL_HASH (arg0));
579 for (h = attr_hash_table[hashcode % RTL_HASH_SIZE]; h; h = h->next)
580 if (h->hashcode == hashcode
581 && GET_CODE (h->u.rtl) == code
582 && XEXP (h->u.rtl, 0) == arg0)
583 goto found;
584
585 if (h == 0)
586 {
587 rtl_obstack = hash_obstack;
588 rt_val = rtx_alloc (code);
589 XEXP (rt_val, 0) = arg0;
590 }
591 }
592 else if (GET_RTX_CLASS (code) == 'c'
593 || GET_RTX_CLASS (code) == '2'
594 || GET_RTX_CLASS (code) == '<')
595 {
596 rtx arg0 = va_arg (p, rtx);
597 rtx arg1 = va_arg (p, rtx);
598
599 /* A permanent object cannot point to impermanent ones. */
600 if (! RTX_INTEGRATED_P (arg0) || ! RTX_INTEGRATED_P (arg1))
601 {
602 rt_val = rtx_alloc (code);
603 XEXP (rt_val, 0) = arg0;
604 XEXP (rt_val, 1) = arg1;
605 va_end (p);
606 return rt_val;
607 }
608
609 hashcode = ((HOST_WIDE_INT) code + RTL_HASH (arg0) + RTL_HASH (arg1));
610 for (h = attr_hash_table[hashcode % RTL_HASH_SIZE]; h; h = h->next)
611 if (h->hashcode == hashcode
612 && GET_CODE (h->u.rtl) == code
613 && XEXP (h->u.rtl, 0) == arg0
614 && XEXP (h->u.rtl, 1) == arg1)
615 goto found;
616
617 if (h == 0)
618 {
619 rtl_obstack = hash_obstack;
620 rt_val = rtx_alloc (code);
621 XEXP (rt_val, 0) = arg0;
622 XEXP (rt_val, 1) = arg1;
623 }
624 }
625 else if (GET_RTX_LENGTH (code) == 1
626 && GET_RTX_FORMAT (code)[0] == 's')
627 {
628 char *arg0 = va_arg (p, char *);
629
630 if (code == SYMBOL_REF)
631 arg0 = attr_string (arg0, strlen (arg0));
632
633 hashcode = ((HOST_WIDE_INT) code + RTL_HASH (arg0));
634 for (h = attr_hash_table[hashcode % RTL_HASH_SIZE]; h; h = h->next)
635 if (h->hashcode == hashcode
636 && GET_CODE (h->u.rtl) == code
637 && XSTR (h->u.rtl, 0) == arg0)
638 goto found;
639
640 if (h == 0)
641 {
642 rtl_obstack = hash_obstack;
643 rt_val = rtx_alloc (code);
644 XSTR (rt_val, 0) = arg0;
645 }
646 }
647 else if (GET_RTX_LENGTH (code) == 2
648 && GET_RTX_FORMAT (code)[0] == 's'
649 && GET_RTX_FORMAT (code)[1] == 's')
650 {
651 char *arg0 = va_arg (p, char *);
652 char *arg1 = va_arg (p, char *);
653
654 hashcode = ((HOST_WIDE_INT) code + RTL_HASH (arg0) + RTL_HASH (arg1));
655 for (h = attr_hash_table[hashcode % RTL_HASH_SIZE]; h; h = h->next)
656 if (h->hashcode == hashcode
657 && GET_CODE (h->u.rtl) == code
658 && XSTR (h->u.rtl, 0) == arg0
659 && XSTR (h->u.rtl, 1) == arg1)
660 goto found;
661
662 if (h == 0)
663 {
664 rtl_obstack = hash_obstack;
665 rt_val = rtx_alloc (code);
666 XSTR (rt_val, 0) = arg0;
667 XSTR (rt_val, 1) = arg1;
668 }
669 }
670 else if (code == CONST_INT)
671 {
672 HOST_WIDE_INT arg0 = va_arg (p, HOST_WIDE_INT);
673 if (arg0 == 0)
674 {
675 va_end (p);
676 return false_rtx;
677 }
678 if (arg0 == 1)
679 {
680 va_end (p);
681 return true_rtx;
682 }
683 goto nohash;
684 }
685 else
686 {
687 nohash:
688 rt_val = rtx_alloc (code); /* Allocate the storage space. */
689
690 fmt = GET_RTX_FORMAT (code); /* Find the right format... */
691 for (i = 0; i < GET_RTX_LENGTH (code); i++)
692 {
693 switch (*fmt++)
694 {
695 case '0': /* Unused field. */
696 break;
697
698 case 'i': /* An integer? */
699 XINT (rt_val, i) = va_arg (p, int);
700 break;
701
702 case 'w': /* A wide integer? */
703 XWINT (rt_val, i) = va_arg (p, HOST_WIDE_INT);
704 break;
705
706 case 's': /* A string? */
707 XSTR (rt_val, i) = va_arg (p, char *);
708 break;
709
710 case 'e': /* An expression? */
711 case 'u': /* An insn? Same except when printing. */
712 XEXP (rt_val, i) = va_arg (p, rtx);
713 break;
714
715 case 'E': /* An RTX vector? */
716 XVEC (rt_val, i) = va_arg (p, rtvec);
717 break;
718
719 default:
720 abort ();
721 }
722 }
723 va_end (p);
724 return rt_val;
725 }
726
727 rtl_obstack = old_obstack;
728 va_end (p);
729 attr_hash_add_rtx (hashcode, rt_val);
730 RTX_INTEGRATED_P (rt_val) = 1;
731 return rt_val;
732
733 found:
734 va_end (p);
735 return h->u.rtl;
736 }
737
738 /* Create a new string printed with the printf line arguments into a space
739 of at most LEN bytes:
740
741 rtx attr_printf (len, format, [arg1, ..., argn]) */
742
743 static char *
744 attr_printf VPARAMS ((register int len, const char *fmt, ...))
745 {
746 #ifndef ANSI_PROTOTYPES
747 register int len;
748 const char *fmt;
749 #endif
750 va_list p;
751 register char *str;
752
753 VA_START (p, fmt);
754
755 #ifndef ANSI_PROTOTYPES
756 len = va_arg (p, int);
757 fmt = va_arg (p, const char *);
758 #endif
759
760 /* Print the string into a temporary location. */
761 str = (char *) alloca (len);
762 vsprintf (str, fmt, p);
763 va_end (p);
764
765 return attr_string (str, strlen (str));
766 }
767
768 static rtx
769 attr_eq (name, value)
770 const char *name, *value;
771 {
772 return attr_rtx (EQ_ATTR, attr_string (name, strlen (name)),
773 attr_string (value, strlen (value)));
774 }
775
776 static const char *
777 attr_numeral (n)
778 int n;
779 {
780 return XSTR (make_numeric_value (n), 0);
781 }
782
783 /* Return a permanent (possibly shared) copy of a string STR (not assumed
784 to be null terminated) with LEN bytes. */
785
786 static char *
787 attr_string (str, len)
788 const char *str;
789 int len;
790 {
791 register struct attr_hash *h;
792 int hashcode;
793 int i;
794 register char *new_str;
795
796 /* Compute the hash code. */
797 hashcode = (len + 1) * 613 + (unsigned) str[0];
798 for (i = 1; i <= len; i += 2)
799 hashcode = ((hashcode * 613) + (unsigned) str[i]);
800 if (hashcode < 0)
801 hashcode = -hashcode;
802
803 /* Search the table for the string. */
804 for (h = attr_hash_table[hashcode % RTL_HASH_SIZE]; h; h = h->next)
805 if (h->hashcode == -hashcode && h->u.str[0] == str[0]
806 && !strncmp (h->u.str, str, len))
807 return h->u.str; /* <-- return if found. */
808
809 /* Not found; create a permanent copy and add it to the hash table. */
810 new_str = (char *) obstack_alloc (hash_obstack, len + 1);
811 bcopy (str, new_str, len);
812 new_str[len] = '\0';
813 attr_hash_add_string (hashcode, new_str);
814
815 return new_str; /* Return the new string. */
816 }
817
818 /* Check two rtx's for equality of contents,
819 taking advantage of the fact that if both are hashed
820 then they can't be equal unless they are the same object. */
821
822 static int
823 attr_equal_p (x, y)
824 rtx x, y;
825 {
826 return (x == y || (! (RTX_INTEGRATED_P (x) && RTX_INTEGRATED_P (y))
827 && rtx_equal_p (x, y)));
828 }
829 \f
830 /* Copy an attribute value expression,
831 descending to all depths, but not copying any
832 permanent hashed subexpressions. */
833
834 static rtx
835 attr_copy_rtx (orig)
836 register rtx orig;
837 {
838 register rtx copy;
839 register int i, j;
840 register RTX_CODE code;
841 register const char *format_ptr;
842
843 /* No need to copy a permanent object. */
844 if (RTX_INTEGRATED_P (orig))
845 return orig;
846
847 code = GET_CODE (orig);
848
849 switch (code)
850 {
851 case REG:
852 case QUEUED:
853 case CONST_INT:
854 case CONST_DOUBLE:
855 case SYMBOL_REF:
856 case CODE_LABEL:
857 case PC:
858 case CC0:
859 return orig;
860
861 default:
862 break;
863 }
864
865 copy = rtx_alloc (code);
866 PUT_MODE (copy, GET_MODE (orig));
867 copy->in_struct = orig->in_struct;
868 copy->volatil = orig->volatil;
869 copy->unchanging = orig->unchanging;
870 copy->integrated = orig->integrated;
871
872 format_ptr = GET_RTX_FORMAT (GET_CODE (copy));
873
874 for (i = 0; i < GET_RTX_LENGTH (GET_CODE (copy)); i++)
875 {
876 switch (*format_ptr++)
877 {
878 case 'e':
879 XEXP (copy, i) = XEXP (orig, i);
880 if (XEXP (orig, i) != NULL)
881 XEXP (copy, i) = attr_copy_rtx (XEXP (orig, i));
882 break;
883
884 case 'E':
885 case 'V':
886 XVEC (copy, i) = XVEC (orig, i);
887 if (XVEC (orig, i) != NULL)
888 {
889 XVEC (copy, i) = rtvec_alloc (XVECLEN (orig, i));
890 for (j = 0; j < XVECLEN (copy, i); j++)
891 XVECEXP (copy, i, j) = attr_copy_rtx (XVECEXP (orig, i, j));
892 }
893 break;
894
895 case 'n':
896 case 'i':
897 XINT (copy, i) = XINT (orig, i);
898 break;
899
900 case 'w':
901 XWINT (copy, i) = XWINT (orig, i);
902 break;
903
904 case 's':
905 case 'S':
906 XSTR (copy, i) = XSTR (orig, i);
907 break;
908
909 default:
910 abort ();
911 }
912 }
913 return copy;
914 }
915 \f
916 /* Given a test expression for an attribute, ensure it is validly formed.
917 IS_CONST indicates whether the expression is constant for each compiler
918 run (a constant expression may not test any particular insn).
919
920 Convert (eq_attr "att" "a1,a2") to (ior (eq_attr ... ) (eq_attrq ..))
921 and (eq_attr "att" "!a1") to (not (eq_attr "att" "a1")). Do the latter
922 test first so that (eq_attr "att" "!a1,a2,a3") works as expected.
923
924 Update the string address in EQ_ATTR expression to be the same used
925 in the attribute (or `alternative_name') to speed up subsequent
926 `find_attr' calls and eliminate most `strcmp' calls.
927
928 Return the new expression, if any. */
929
930 static rtx
931 check_attr_test (exp, is_const, lineno)
932 rtx exp;
933 int is_const;
934 int lineno;
935 {
936 struct attr_desc *attr;
937 struct attr_value *av;
938 const char *name_ptr, *p;
939 rtx orexp, newexp;
940
941 switch (GET_CODE (exp))
942 {
943 case EQ_ATTR:
944 /* Handle negation test. */
945 if (XSTR (exp, 1)[0] == '!')
946 return check_attr_test (attr_rtx (NOT,
947 attr_eq (XSTR (exp, 0),
948 &XSTR (exp, 1)[1])),
949 is_const, lineno);
950
951 else if (n_comma_elts (XSTR (exp, 1)) == 1)
952 {
953 attr = find_attr (XSTR (exp, 0), 0);
954 if (attr == NULL)
955 {
956 if (! strcmp (XSTR (exp, 0), "alternative"))
957 {
958 XSTR (exp, 0) = alternative_name;
959 /* This can't be simplified any further. */
960 RTX_UNCHANGING_P (exp) = 1;
961 return exp;
962 }
963 else
964 fatal ("Unknown attribute `%s' in EQ_ATTR", XSTR (exp, 0));
965 }
966
967 if (is_const && ! attr->is_const)
968 fatal ("Constant expression uses insn attribute `%s' in EQ_ATTR",
969 XSTR (exp, 0));
970
971 /* Copy this just to make it permanent,
972 so expressions using it can be permanent too. */
973 exp = attr_eq (XSTR (exp, 0), XSTR (exp, 1));
974
975 /* It shouldn't be possible to simplify the value given to a
976 constant attribute, so don't expand this until it's time to
977 write the test expression. */
978 if (attr->is_const)
979 RTX_UNCHANGING_P (exp) = 1;
980
981 if (attr->is_numeric)
982 {
983 for (p = XSTR (exp, 1); *p; p++)
984 if (*p < '0' || *p > '9')
985 fatal ("Attribute `%s' takes only numeric values",
986 XSTR (exp, 0));
987 }
988 else
989 {
990 for (av = attr->first_value; av; av = av->next)
991 if (GET_CODE (av->value) == CONST_STRING
992 && ! strcmp (XSTR (exp, 1), XSTR (av->value, 0)))
993 break;
994
995 if (av == NULL)
996 fatal ("Unknown value `%s' for `%s' attribute",
997 XSTR (exp, 1), XSTR (exp, 0));
998 }
999 }
1000 else
1001 {
1002 /* Make an IOR tree of the possible values. */
1003 orexp = false_rtx;
1004 name_ptr = XSTR (exp, 1);
1005 while ((p = next_comma_elt (&name_ptr)) != NULL)
1006 {
1007 newexp = attr_eq (XSTR (exp, 0), p);
1008 orexp = insert_right_side (IOR, orexp, newexp, -2, -2);
1009 }
1010
1011 return check_attr_test (orexp, is_const, lineno);
1012 }
1013 break;
1014
1015 case ATTR_FLAG:
1016 break;
1017
1018 case CONST_INT:
1019 /* Either TRUE or FALSE. */
1020 if (XWINT (exp, 0))
1021 return true_rtx;
1022 else
1023 return false_rtx;
1024
1025 case IOR:
1026 case AND:
1027 XEXP (exp, 0) = check_attr_test (XEXP (exp, 0), is_const, lineno);
1028 XEXP (exp, 1) = check_attr_test (XEXP (exp, 1), is_const, lineno);
1029 break;
1030
1031 case NOT:
1032 XEXP (exp, 0) = check_attr_test (XEXP (exp, 0), is_const, lineno);
1033 break;
1034
1035 case MATCH_INSN:
1036 case MATCH_OPERAND:
1037 if (is_const)
1038 fatal ("RTL operator \"%s\" not valid in constant attribute test",
1039 GET_RTX_NAME (GET_CODE (exp)));
1040 /* These cases can't be simplified. */
1041 RTX_UNCHANGING_P (exp) = 1;
1042 break;
1043
1044 case LE: case LT: case GT: case GE:
1045 case LEU: case LTU: case GTU: case GEU:
1046 case NE: case EQ:
1047 if (GET_CODE (XEXP (exp, 0)) == SYMBOL_REF
1048 && GET_CODE (XEXP (exp, 1)) == SYMBOL_REF)
1049 exp = attr_rtx (GET_CODE (exp),
1050 attr_rtx (SYMBOL_REF, XSTR (XEXP (exp, 0), 0)),
1051 attr_rtx (SYMBOL_REF, XSTR (XEXP (exp, 1), 0)));
1052 /* These cases can't be simplified. */
1053 RTX_UNCHANGING_P (exp) = 1;
1054 break;
1055
1056 case SYMBOL_REF:
1057 if (is_const)
1058 {
1059 /* These cases are valid for constant attributes, but can't be
1060 simplified. */
1061 exp = attr_rtx (SYMBOL_REF, XSTR (exp, 0));
1062 RTX_UNCHANGING_P (exp) = 1;
1063 break;
1064 }
1065 default:
1066 fatal ("RTL operator \"%s\" not valid in attribute test",
1067 GET_RTX_NAME (GET_CODE (exp)));
1068 }
1069
1070 return exp;
1071 }
1072 \f
1073 /* Given an expression, ensure that it is validly formed and that all named
1074 attribute values are valid for the given attribute. Issue a fatal error
1075 if not. If no attribute is specified, assume a numeric attribute.
1076
1077 Return a perhaps modified replacement expression for the value. */
1078
1079 static rtx
1080 check_attr_value (exp, attr)
1081 rtx exp;
1082 struct attr_desc *attr;
1083 {
1084 struct attr_value *av;
1085 const char *p;
1086 int i;
1087
1088 switch (GET_CODE (exp))
1089 {
1090 case CONST_INT:
1091 if (attr && ! attr->is_numeric)
1092 {
1093 message_with_line (attr->lineno,
1094 "CONST_INT not valid for non-numeric attribute %s",
1095 attr->name);
1096 have_error = 1;
1097 break;
1098 }
1099
1100 if (INTVAL (exp) < 0 && ! attr->negative_ok)
1101 {
1102 message_with_line (attr->lineno,
1103 "negative numeric value specified for attribute %s",
1104 attr->name);
1105 have_error = 1;
1106 break;
1107 }
1108 break;
1109
1110 case CONST_STRING:
1111 if (! strcmp (XSTR (exp, 0), "*"))
1112 break;
1113
1114 if (attr == 0 || attr->is_numeric)
1115 {
1116 p = XSTR (exp, 0);
1117 if (attr && attr->negative_ok && *p == '-')
1118 p++;
1119 for (; *p; p++)
1120 if (*p > '9' || *p < '0')
1121 {
1122 message_with_line (attr ? attr->lineno : 0,
1123 "non-numeric value for numeric attribute %s",
1124 attr ? attr->name : "internal");
1125 have_error = 1;
1126 break;
1127 }
1128 break;
1129 }
1130
1131 for (av = attr->first_value; av; av = av->next)
1132 if (GET_CODE (av->value) == CONST_STRING
1133 && ! strcmp (XSTR (av->value, 0), XSTR (exp, 0)))
1134 break;
1135
1136 if (av == NULL)
1137 {
1138 message_with_line (attr->lineno,
1139 "unknown value `%s' for `%s' attribute",
1140 XSTR (exp, 0), attr ? attr->name : "internal");
1141 have_error = 1;
1142 }
1143 break;
1144
1145 case IF_THEN_ELSE:
1146 XEXP (exp, 0) = check_attr_test (XEXP (exp, 0),
1147 attr ? attr->is_const : 0,
1148 attr ? attr->lineno : 0);
1149 XEXP (exp, 1) = check_attr_value (XEXP (exp, 1), attr);
1150 XEXP (exp, 2) = check_attr_value (XEXP (exp, 2), attr);
1151 break;
1152
1153 case PLUS:
1154 case MINUS:
1155 case MULT:
1156 case DIV:
1157 case MOD:
1158 if (attr && !attr->is_numeric)
1159 {
1160 message_with_line (attr->lineno,
1161 "invalid operation `%s' for non-numeric attribute value",
1162 GET_RTX_NAME (GET_CODE (exp)));
1163 have_error = 1;
1164 break;
1165 }
1166 /* FALLTHRU */
1167
1168 case IOR:
1169 case AND:
1170 XEXP (exp, 0) = check_attr_value (XEXP (exp, 0), attr);
1171 XEXP (exp, 1) = check_attr_value (XEXP (exp, 1), attr);
1172 break;
1173
1174 case FFS:
1175 XEXP (exp, 0) = check_attr_value (XEXP (exp, 0), attr);
1176 break;
1177
1178 case COND:
1179 if (XVECLEN (exp, 0) % 2 != 0)
1180 {
1181 message_with_line (attr->lineno,
1182 "first operand of COND must have even length");
1183 have_error = 1;
1184 break;
1185 }
1186
1187 for (i = 0; i < XVECLEN (exp, 0); i += 2)
1188 {
1189 XVECEXP (exp, 0, i) = check_attr_test (XVECEXP (exp, 0, i),
1190 attr ? attr->is_const : 0,
1191 attr ? attr->lineno : 0);
1192 XVECEXP (exp, 0, i + 1)
1193 = check_attr_value (XVECEXP (exp, 0, i + 1), attr);
1194 }
1195
1196 XEXP (exp, 1) = check_attr_value (XEXP (exp, 1), attr);
1197 break;
1198
1199 case ATTR:
1200 {
1201 struct attr_desc *attr2 = find_attr (XSTR (exp, 0), 0);
1202 if (attr2 == NULL)
1203 {
1204 message_with_line (attr ? attr->lineno : 0,
1205 "unknown attribute `%s' in ATTR",
1206 XSTR (exp, 0));
1207 have_error = 1;
1208 }
1209 else if (attr && attr->is_const && ! attr2->is_const)
1210 {
1211 message_with_line (attr->lineno,
1212 "non-constant attribute `%s' referenced from `%s'",
1213 XSTR (exp, 0), attr->name);
1214 have_error = 1;
1215 }
1216 else if (attr
1217 && (attr->is_numeric != attr2->is_numeric
1218 || (! attr->negative_ok && attr2->negative_ok)))
1219 {
1220 message_with_line (attr->lineno,
1221 "numeric attribute mismatch calling `%s' from `%s'",
1222 XSTR (exp, 0), attr->name);
1223 have_error = 1;
1224 }
1225 }
1226 break;
1227
1228 case SYMBOL_REF:
1229 /* A constant SYMBOL_REF is valid as a constant attribute test and
1230 is expanded later by make_canonical into a COND. In a non-constant
1231 attribute test, it is left be. */
1232 return attr_rtx (SYMBOL_REF, XSTR (exp, 0));
1233
1234 default:
1235 message_with_line (attr ? attr->lineno : 0,
1236 "invalid operation `%s' for attribute value",
1237 GET_RTX_NAME (GET_CODE (exp)));
1238 have_error = 1;
1239 break;
1240 }
1241
1242 return exp;
1243 }
1244 \f
1245 /* Given an SET_ATTR_ALTERNATIVE expression, convert to the canonical SET.
1246 It becomes a COND with each test being (eq_attr "alternative "n") */
1247
1248 static rtx
1249 convert_set_attr_alternative (exp, id)
1250 rtx exp;
1251 struct insn_def *id;
1252 {
1253 int num_alt = id->num_alternatives;
1254 rtx condexp;
1255 int i;
1256
1257 if (XVECLEN (exp, 1) != num_alt)
1258 {
1259 message_with_line (id->lineno,
1260 "bad number of entries in SET_ATTR_ALTERNATIVE");
1261 have_error = 1;
1262 return NULL_RTX;
1263 }
1264
1265 /* Make a COND with all tests but the last. Select the last value via the
1266 default. */
1267 condexp = rtx_alloc (COND);
1268 XVEC (condexp, 0) = rtvec_alloc ((num_alt - 1) * 2);
1269
1270 for (i = 0; i < num_alt - 1; i++)
1271 {
1272 const char *p;
1273 p = attr_numeral (i);
1274
1275 XVECEXP (condexp, 0, 2 * i) = attr_eq (alternative_name, p);
1276 XVECEXP (condexp, 0, 2 * i + 1) = XVECEXP (exp, 1, i);
1277 }
1278
1279 XEXP (condexp, 1) = XVECEXP (exp, 1, i);
1280
1281 return attr_rtx (SET, attr_rtx (ATTR, XSTR (exp, 0)), condexp);
1282 }
1283 \f
1284 /* Given a SET_ATTR, convert to the appropriate SET. If a comma-separated
1285 list of values is given, convert to SET_ATTR_ALTERNATIVE first. */
1286
1287 static rtx
1288 convert_set_attr (exp, id)
1289 rtx exp;
1290 struct insn_def *id;
1291 {
1292 rtx newexp;
1293 const char *name_ptr;
1294 char *p;
1295 int n;
1296
1297 /* See how many alternative specified. */
1298 n = n_comma_elts (XSTR (exp, 1));
1299 if (n == 1)
1300 return attr_rtx (SET,
1301 attr_rtx (ATTR, XSTR (exp, 0)),
1302 attr_rtx (CONST_STRING, XSTR (exp, 1)));
1303
1304 newexp = rtx_alloc (SET_ATTR_ALTERNATIVE);
1305 XSTR (newexp, 0) = XSTR (exp, 0);
1306 XVEC (newexp, 1) = rtvec_alloc (n);
1307
1308 /* Process each comma-separated name. */
1309 name_ptr = XSTR (exp, 1);
1310 n = 0;
1311 while ((p = next_comma_elt (&name_ptr)) != NULL)
1312 XVECEXP (newexp, 1, n++) = attr_rtx (CONST_STRING, p);
1313
1314 return convert_set_attr_alternative (newexp, id);
1315 }
1316 \f
1317 /* Scan all definitions, checking for validity. Also, convert any SET_ATTR
1318 and SET_ATTR_ALTERNATIVE expressions to the corresponding SET
1319 expressions. */
1320
1321 static void
1322 check_defs ()
1323 {
1324 struct insn_def *id;
1325 struct attr_desc *attr;
1326 int i;
1327 rtx value;
1328
1329 for (id = defs; id; id = id->next)
1330 {
1331 if (XVEC (id->def, id->vec_idx) == NULL)
1332 continue;
1333
1334 for (i = 0; i < XVECLEN (id->def, id->vec_idx); i++)
1335 {
1336 value = XVECEXP (id->def, id->vec_idx, i);
1337 switch (GET_CODE (value))
1338 {
1339 case SET:
1340 if (GET_CODE (XEXP (value, 0)) != ATTR)
1341 {
1342 message_with_line (id->lineno, "bad attribute set");
1343 have_error = 1;
1344 value = NULL_RTX;
1345 }
1346 break;
1347
1348 case SET_ATTR_ALTERNATIVE:
1349 value = convert_set_attr_alternative (value, id);
1350 break;
1351
1352 case SET_ATTR:
1353 value = convert_set_attr (value, id);
1354 break;
1355
1356 default:
1357 message_with_line (id->lineno, "invalid attribute code %s",
1358 GET_RTX_NAME (GET_CODE (value)));
1359 have_error = 1;
1360 value = NULL_RTX;
1361 }
1362 if (value == NULL_RTX)
1363 continue;
1364
1365 if ((attr = find_attr (XSTR (XEXP (value, 0), 0), 0)) == NULL)
1366 {
1367 message_with_line (id->lineno, "unknown attribute %s",
1368 XSTR (XEXP (value, 0), 0));
1369 have_error = 1;
1370 continue;
1371 }
1372
1373 XVECEXP (id->def, id->vec_idx, i) = value;
1374 XEXP (value, 1) = check_attr_value (XEXP (value, 1), attr);
1375 }
1376 }
1377 }
1378 \f
1379 #if 0
1380 /* Given a constant SYMBOL_REF expression, convert to a COND that
1381 explicitly tests each enumerated value. */
1382
1383 static rtx
1384 convert_const_symbol_ref (exp, attr)
1385 rtx exp;
1386 struct attr_desc *attr;
1387 {
1388 rtx condexp;
1389 struct attr_value *av;
1390 int i;
1391 int num_alt = 0;
1392
1393 for (av = attr->first_value; av; av = av->next)
1394 num_alt++;
1395
1396 /* Make a COND with all tests but the last, and in the original order.
1397 Select the last value via the default. Note that the attr values
1398 are constructed in reverse order. */
1399
1400 condexp = rtx_alloc (COND);
1401 XVEC (condexp, 0) = rtvec_alloc ((num_alt - 1) * 2);
1402 av = attr->first_value;
1403 XEXP (condexp, 1) = av->value;
1404
1405 for (i = num_alt - 2; av = av->next, i >= 0; i--)
1406 {
1407 char *p, *string;
1408 rtx value;
1409
1410 string = p = (char *) oballoc (2
1411 + strlen (attr->name)
1412 + strlen (XSTR (av->value, 0)));
1413 strcpy (p, attr->name);
1414 strcat (p, "_");
1415 strcat (p, XSTR (av->value, 0));
1416 for (; *p != '\0'; p++)
1417 *p = TOUPPER (*p);
1418
1419 value = attr_rtx (SYMBOL_REF, string);
1420 RTX_UNCHANGING_P (value) = 1;
1421
1422 XVECEXP (condexp, 0, 2 * i) = attr_rtx (EQ, exp, value);
1423
1424 XVECEXP (condexp, 0, 2 * i + 1) = av->value;
1425 }
1426
1427 return condexp;
1428 }
1429 #endif
1430 \f
1431 /* Given a valid expression for an attribute value, remove any IF_THEN_ELSE
1432 expressions by converting them into a COND. This removes cases from this
1433 program. Also, replace an attribute value of "*" with the default attribute
1434 value. */
1435
1436 static rtx
1437 make_canonical (attr, exp)
1438 struct attr_desc *attr;
1439 rtx exp;
1440 {
1441 int i;
1442 rtx newexp;
1443
1444 switch (GET_CODE (exp))
1445 {
1446 case CONST_INT:
1447 exp = make_numeric_value (INTVAL (exp));
1448 break;
1449
1450 case CONST_STRING:
1451 if (! strcmp (XSTR (exp, 0), "*"))
1452 {
1453 if (attr == 0 || attr->default_val == 0)
1454 fatal ("(attr_value \"*\") used in invalid context.");
1455 exp = attr->default_val->value;
1456 }
1457
1458 break;
1459
1460 case SYMBOL_REF:
1461 if (!attr->is_const || RTX_UNCHANGING_P (exp))
1462 break;
1463 /* The SYMBOL_REF is constant for a given run, so mark it as unchanging.
1464 This makes the COND something that won't be considered an arbitrary
1465 expression by walk_attr_value. */
1466 RTX_UNCHANGING_P (exp) = 1;
1467 #if 0
1468 /* ??? Why do we do this? With attribute values { A B C D E }, this
1469 tends to generate (!(x==A) && !(x==B) && !(x==C) && !(x==D)) rather
1470 than (x==E). */
1471 exp = convert_const_symbol_ref (exp, attr);
1472 RTX_UNCHANGING_P (exp) = 1;
1473 exp = check_attr_value (exp, attr);
1474 /* Goto COND case since this is now a COND. Note that while the
1475 new expression is rescanned, all symbol_ref notes are marked as
1476 unchanging. */
1477 goto cond;
1478 #else
1479 exp = check_attr_value (exp, attr);
1480 break;
1481 #endif
1482
1483 case IF_THEN_ELSE:
1484 newexp = rtx_alloc (COND);
1485 XVEC (newexp, 0) = rtvec_alloc (2);
1486 XVECEXP (newexp, 0, 0) = XEXP (exp, 0);
1487 XVECEXP (newexp, 0, 1) = XEXP (exp, 1);
1488
1489 XEXP (newexp, 1) = XEXP (exp, 2);
1490
1491 exp = newexp;
1492 /* Fall through to COND case since this is now a COND. */
1493
1494 case COND:
1495 {
1496 int allsame = 1;
1497 rtx defval;
1498
1499 /* First, check for degenerate COND. */
1500 if (XVECLEN (exp, 0) == 0)
1501 return make_canonical (attr, XEXP (exp, 1));
1502 defval = XEXP (exp, 1) = make_canonical (attr, XEXP (exp, 1));
1503
1504 for (i = 0; i < XVECLEN (exp, 0); i += 2)
1505 {
1506 XVECEXP (exp, 0, i) = copy_boolean (XVECEXP (exp, 0, i));
1507 XVECEXP (exp, 0, i + 1)
1508 = make_canonical (attr, XVECEXP (exp, 0, i + 1));
1509 if (! rtx_equal_p (XVECEXP (exp, 0, i + 1), defval))
1510 allsame = 0;
1511 }
1512 if (allsame)
1513 return defval;
1514 }
1515 break;
1516
1517 default:
1518 break;
1519 }
1520
1521 return exp;
1522 }
1523
1524 static rtx
1525 copy_boolean (exp)
1526 rtx exp;
1527 {
1528 if (GET_CODE (exp) == AND || GET_CODE (exp) == IOR)
1529 return attr_rtx (GET_CODE (exp), copy_boolean (XEXP (exp, 0)),
1530 copy_boolean (XEXP (exp, 1)));
1531 return exp;
1532 }
1533 \f
1534 /* Given a value and an attribute description, return a `struct attr_value *'
1535 that represents that value. This is either an existing structure, if the
1536 value has been previously encountered, or a newly-created structure.
1537
1538 `insn_code' is the code of an insn whose attribute has the specified
1539 value (-2 if not processing an insn). We ensure that all insns for
1540 a given value have the same number of alternatives if the value checks
1541 alternatives. */
1542
1543 static struct attr_value *
1544 get_attr_value (value, attr, insn_code)
1545 rtx value;
1546 struct attr_desc *attr;
1547 int insn_code;
1548 {
1549 struct attr_value *av;
1550 int num_alt = 0;
1551
1552 value = make_canonical (attr, value);
1553 if (compares_alternatives_p (value))
1554 {
1555 if (insn_code < 0 || insn_alternatives == NULL)
1556 fatal ("(eq_attr \"alternatives\" ...) used in non-insn context");
1557 else
1558 num_alt = insn_alternatives[insn_code];
1559 }
1560
1561 for (av = attr->first_value; av; av = av->next)
1562 if (rtx_equal_p (value, av->value)
1563 && (num_alt == 0 || av->first_insn == NULL
1564 || insn_alternatives[av->first_insn->insn_code]))
1565 return av;
1566
1567 av = (struct attr_value *) oballoc (sizeof (struct attr_value));
1568 av->value = value;
1569 av->next = attr->first_value;
1570 attr->first_value = av;
1571 av->first_insn = NULL;
1572 av->num_insns = 0;
1573 av->has_asm_insn = 0;
1574
1575 return av;
1576 }
1577 \f
1578 /* After all DEFINE_DELAYs have been read in, create internal attributes
1579 to generate the required routines.
1580
1581 First, we compute the number of delay slots for each insn (as a COND of
1582 each of the test expressions in DEFINE_DELAYs). Then, if more than one
1583 delay type is specified, we compute a similar function giving the
1584 DEFINE_DELAY ordinal for each insn.
1585
1586 Finally, for each [DEFINE_DELAY, slot #] pair, we compute an attribute that
1587 tells whether a given insn can be in that delay slot.
1588
1589 Normal attribute filling and optimization expands these to contain the
1590 information needed to handle delay slots. */
1591
1592 static void
1593 expand_delays ()
1594 {
1595 struct delay_desc *delay;
1596 rtx condexp;
1597 rtx newexp;
1598 int i;
1599 char *p;
1600
1601 /* First, generate data for `num_delay_slots' function. */
1602
1603 condexp = rtx_alloc (COND);
1604 XVEC (condexp, 0) = rtvec_alloc (num_delays * 2);
1605 XEXP (condexp, 1) = make_numeric_value (0);
1606
1607 for (i = 0, delay = delays; delay; i += 2, delay = delay->next)
1608 {
1609 XVECEXP (condexp, 0, i) = XEXP (delay->def, 0);
1610 XVECEXP (condexp, 0, i + 1)
1611 = make_numeric_value (XVECLEN (delay->def, 1) / 3);
1612 }
1613
1614 make_internal_attr ("*num_delay_slots", condexp, 0);
1615
1616 /* If more than one delay type, do the same for computing the delay type. */
1617 if (num_delays > 1)
1618 {
1619 condexp = rtx_alloc (COND);
1620 XVEC (condexp, 0) = rtvec_alloc (num_delays * 2);
1621 XEXP (condexp, 1) = make_numeric_value (0);
1622
1623 for (i = 0, delay = delays; delay; i += 2, delay = delay->next)
1624 {
1625 XVECEXP (condexp, 0, i) = XEXP (delay->def, 0);
1626 XVECEXP (condexp, 0, i + 1) = make_numeric_value (delay->num);
1627 }
1628
1629 make_internal_attr ("*delay_type", condexp, 1);
1630 }
1631
1632 /* For each delay possibility and delay slot, compute an eligibility
1633 attribute for non-annulled insns and for each type of annulled (annul
1634 if true and annul if false). */
1635 for (delay = delays; delay; delay = delay->next)
1636 {
1637 for (i = 0; i < XVECLEN (delay->def, 1); i += 3)
1638 {
1639 condexp = XVECEXP (delay->def, 1, i);
1640 if (condexp == 0)
1641 condexp = false_rtx;
1642 newexp = attr_rtx (IF_THEN_ELSE, condexp,
1643 make_numeric_value (1), make_numeric_value (0));
1644
1645 p = attr_printf (sizeof ("*delay__") + MAX_DIGITS * 2,
1646 "*delay_%d_%d",
1647 delay->num, i / 3);
1648 make_internal_attr (p, newexp, 1);
1649
1650 if (have_annul_true)
1651 {
1652 condexp = XVECEXP (delay->def, 1, i + 1);
1653 if (condexp == 0) condexp = false_rtx;
1654 newexp = attr_rtx (IF_THEN_ELSE, condexp,
1655 make_numeric_value (1),
1656 make_numeric_value (0));
1657 p = attr_printf (sizeof ("*annul_true__") + MAX_DIGITS * 2,
1658 "*annul_true_%d_%d", delay->num, i / 3);
1659 make_internal_attr (p, newexp, 1);
1660 }
1661
1662 if (have_annul_false)
1663 {
1664 condexp = XVECEXP (delay->def, 1, i + 2);
1665 if (condexp == 0) condexp = false_rtx;
1666 newexp = attr_rtx (IF_THEN_ELSE, condexp,
1667 make_numeric_value (1),
1668 make_numeric_value (0));
1669 p = attr_printf (sizeof ("*annul_false__") + MAX_DIGITS * 2,
1670 "*annul_false_%d_%d", delay->num, i / 3);
1671 make_internal_attr (p, newexp, 1);
1672 }
1673 }
1674 }
1675 }
1676 \f
1677 /* This function is given a left and right side expression and an operator.
1678 Each side is a conditional expression, each alternative of which has a
1679 numerical value. The function returns another conditional expression
1680 which, for every possible set of condition values, returns a value that is
1681 the operator applied to the values of the two sides.
1682
1683 Since this is called early, it must also support IF_THEN_ELSE. */
1684
1685 static rtx
1686 operate_exp (op, left, right)
1687 enum operator op;
1688 rtx left, right;
1689 {
1690 int left_value, right_value;
1691 rtx newexp;
1692 int i;
1693
1694 /* If left is a string, apply operator to it and the right side. */
1695 if (GET_CODE (left) == CONST_STRING)
1696 {
1697 /* If right is also a string, just perform the operation. */
1698 if (GET_CODE (right) == CONST_STRING)
1699 {
1700 left_value = atoi (XSTR (left, 0));
1701 right_value = atoi (XSTR (right, 0));
1702 switch (op)
1703 {
1704 case PLUS_OP:
1705 i = left_value + right_value;
1706 break;
1707
1708 case MINUS_OP:
1709 i = left_value - right_value;
1710 break;
1711
1712 case POS_MINUS_OP: /* The positive part of LEFT - RIGHT. */
1713 if (left_value > right_value)
1714 i = left_value - right_value;
1715 else
1716 i = 0;
1717 break;
1718
1719 case OR_OP:
1720 case ORX_OP:
1721 i = left_value | right_value;
1722 break;
1723
1724 case EQ_OP:
1725 i = left_value == right_value;
1726 break;
1727
1728 case RANGE_OP:
1729 i = (left_value << (HOST_BITS_PER_INT / 2)) | right_value;
1730 break;
1731
1732 case MAX_OP:
1733 if (left_value > right_value)
1734 i = left_value;
1735 else
1736 i = right_value;
1737 break;
1738
1739 case MIN_OP:
1740 if (left_value < right_value)
1741 i = left_value;
1742 else
1743 i = right_value;
1744 break;
1745
1746 default:
1747 abort ();
1748 }
1749
1750 if (i == left_value)
1751 return left;
1752 if (i == right_value)
1753 return right;
1754 return make_numeric_value (i);
1755 }
1756 else if (GET_CODE (right) == IF_THEN_ELSE)
1757 {
1758 /* Apply recursively to all values within. */
1759 rtx newleft = operate_exp (op, left, XEXP (right, 1));
1760 rtx newright = operate_exp (op, left, XEXP (right, 2));
1761 if (rtx_equal_p (newleft, newright))
1762 return newleft;
1763 return attr_rtx (IF_THEN_ELSE, XEXP (right, 0), newleft, newright);
1764 }
1765 else if (GET_CODE (right) == COND)
1766 {
1767 int allsame = 1;
1768 rtx defval;
1769
1770 newexp = rtx_alloc (COND);
1771 XVEC (newexp, 0) = rtvec_alloc (XVECLEN (right, 0));
1772 defval = XEXP (newexp, 1) = operate_exp (op, left, XEXP (right, 1));
1773
1774 for (i = 0; i < XVECLEN (right, 0); i += 2)
1775 {
1776 XVECEXP (newexp, 0, i) = XVECEXP (right, 0, i);
1777 XVECEXP (newexp, 0, i + 1)
1778 = operate_exp (op, left, XVECEXP (right, 0, i + 1));
1779 if (! rtx_equal_p (XVECEXP (newexp, 0, i + 1),
1780 defval))
1781 allsame = 0;
1782 }
1783
1784 /* If the resulting cond is trivial (all alternatives
1785 give the same value), optimize it away. */
1786 if (allsame)
1787 return operate_exp (op, left, XEXP (right, 1));
1788
1789 return newexp;
1790 }
1791 else
1792 fatal ("Badly formed attribute value");
1793 }
1794
1795 /* A hack to prevent expand_units from completely blowing up: ORX_OP does
1796 not associate through IF_THEN_ELSE. */
1797 else if (op == ORX_OP && GET_CODE (right) == IF_THEN_ELSE)
1798 {
1799 return attr_rtx (IOR, left, right);
1800 }
1801
1802 /* Otherwise, do recursion the other way. */
1803 else if (GET_CODE (left) == IF_THEN_ELSE)
1804 {
1805 rtx newleft = operate_exp (op, XEXP (left, 1), right);
1806 rtx newright = operate_exp (op, XEXP (left, 2), right);
1807 if (rtx_equal_p (newleft, newright))
1808 return newleft;
1809 return attr_rtx (IF_THEN_ELSE, XEXP (left, 0), newleft, newright);
1810 }
1811 else if (GET_CODE (left) == COND)
1812 {
1813 int allsame = 1;
1814 rtx defval;
1815
1816 newexp = rtx_alloc (COND);
1817 XVEC (newexp, 0) = rtvec_alloc (XVECLEN (left, 0));
1818 defval = XEXP (newexp, 1) = operate_exp (op, XEXP (left, 1), right);
1819
1820 for (i = 0; i < XVECLEN (left, 0); i += 2)
1821 {
1822 XVECEXP (newexp, 0, i) = XVECEXP (left, 0, i);
1823 XVECEXP (newexp, 0, i + 1)
1824 = operate_exp (op, XVECEXP (left, 0, i + 1), right);
1825 if (! rtx_equal_p (XVECEXP (newexp, 0, i + 1),
1826 defval))
1827 allsame = 0;
1828 }
1829
1830 /* If the cond is trivial (all alternatives give the same value),
1831 optimize it away. */
1832 if (allsame)
1833 return operate_exp (op, XEXP (left, 1), right);
1834
1835 /* If the result is the same as the LEFT operand,
1836 just use that. */
1837 if (rtx_equal_p (newexp, left))
1838 return left;
1839
1840 return newexp;
1841 }
1842
1843 else
1844 fatal ("Badly formed attribute value.");
1845 /* NOTREACHED */
1846 return NULL;
1847 }
1848 \f
1849 /* Once all attributes and DEFINE_FUNCTION_UNITs have been read, we
1850 construct a number of attributes.
1851
1852 The first produces a function `function_units_used' which is given an
1853 insn and produces an encoding showing which function units are required
1854 for the execution of that insn. If the value is non-negative, the insn
1855 uses that unit; otherwise, the value is a one's compliment mask of units
1856 used.
1857
1858 The second produces a function `result_ready_cost' which is used to
1859 determine the time that the result of an insn will be ready and hence
1860 a worst-case schedule.
1861
1862 Both of these produce quite complex expressions which are then set as the
1863 default value of internal attributes. Normal attribute simplification
1864 should produce reasonable expressions.
1865
1866 For each unit, a `<name>_unit_ready_cost' function will take an
1867 insn and give the delay until that unit will be ready with the result
1868 and a `<name>_unit_conflict_cost' function is given an insn already
1869 executing on the unit and a candidate to execute and will give the
1870 cost from the time the executing insn started until the candidate
1871 can start (ignore limitations on the number of simultaneous insns).
1872
1873 For each unit, a `<name>_unit_blockage' function is given an insn
1874 already executing on the unit and a candidate to execute and will
1875 give the delay incurred due to function unit conflicts. The range of
1876 blockage cost values for a given executing insn is given by the
1877 `<name>_unit_blockage_range' function. These values are encoded in
1878 an int where the upper half gives the minimum value and the lower
1879 half gives the maximum value. */
1880
1881 static void
1882 expand_units ()
1883 {
1884 struct function_unit *unit, **unit_num;
1885 struct function_unit_op *op, **op_array, ***unit_ops;
1886 rtx unitsmask;
1887 rtx readycost;
1888 rtx newexp;
1889 const char *str;
1890 int i, j, u, num, nvalues;
1891
1892 /* Rebuild the condition for the unit to share the RTL expressions.
1893 Sharing is required by simplify_by_exploding. Build the issue delay
1894 expressions. Validate the expressions we were given for the conditions
1895 and conflict vector. Then make attributes for use in the conflict
1896 function. */
1897
1898 for (unit = units; unit; unit = unit->next)
1899 {
1900 unit->condexp = check_attr_test (unit->condexp, 0, unit->first_lineno);
1901
1902 for (op = unit->ops; op; op = op->next)
1903 {
1904 rtx issue_delay = make_numeric_value (op->issue_delay);
1905 rtx issue_exp = issue_delay;
1906
1907 /* Build, validate, and simplify the issue delay expression. */
1908 if (op->conflict_exp != true_rtx)
1909 issue_exp = attr_rtx (IF_THEN_ELSE, op->conflict_exp,
1910 issue_exp, make_numeric_value (0));
1911 issue_exp = check_attr_value (make_canonical (NULL_ATTR,
1912 issue_exp),
1913 NULL_ATTR);
1914 issue_exp = simplify_knowing (issue_exp, unit->condexp);
1915 op->issue_exp = issue_exp;
1916
1917 /* Make an attribute for use in the conflict function if needed. */
1918 unit->needs_conflict_function = (unit->issue_delay.min
1919 != unit->issue_delay.max);
1920 if (unit->needs_conflict_function)
1921 {
1922 str = attr_printf (strlen (unit->name) + sizeof ("*_cost_") + MAX_DIGITS,
1923 "*%s_cost_%d", unit->name, op->num);
1924 make_internal_attr (str, issue_exp, 1);
1925 }
1926
1927 /* Validate the condition. */
1928 op->condexp = check_attr_test (op->condexp, 0, op->lineno);
1929 }
1930 }
1931
1932 /* Compute the mask of function units used. Initially, the unitsmask is
1933 zero. Set up a conditional to compute each unit's contribution. */
1934 unitsmask = make_numeric_value (0);
1935 newexp = rtx_alloc (IF_THEN_ELSE);
1936 XEXP (newexp, 2) = make_numeric_value (0);
1937
1938 /* If we have just a few units, we may be all right expanding the whole
1939 thing. But the expansion is 2**N in space on the number of opclasses,
1940 so we can't do this for very long -- Alpha and MIPS in particular have
1941 problems with this. So in that situation, we fall back on an alternate
1942 implementation method. */
1943 #define NUM_UNITOP_CUTOFF 20
1944
1945 if (num_unit_opclasses < NUM_UNITOP_CUTOFF)
1946 {
1947 /* Merge each function unit into the unit mask attributes. */
1948 for (unit = units; unit; unit = unit->next)
1949 {
1950 XEXP (newexp, 0) = unit->condexp;
1951 XEXP (newexp, 1) = make_numeric_value (1 << unit->num);
1952 unitsmask = operate_exp (OR_OP, unitsmask, newexp);
1953 }
1954 }
1955 else
1956 {
1957 /* Merge each function unit into the unit mask attributes. */
1958 for (unit = units; unit; unit = unit->next)
1959 {
1960 XEXP (newexp, 0) = unit->condexp;
1961 XEXP (newexp, 1) = make_numeric_value (1 << unit->num);
1962 unitsmask = operate_exp (ORX_OP, unitsmask, attr_copy_rtx (newexp));
1963 }
1964 }
1965
1966 /* Simplify the unit mask expression, encode it, and make an attribute
1967 for the function_units_used function. */
1968 unitsmask = simplify_by_exploding (unitsmask);
1969
1970 if (num_unit_opclasses < NUM_UNITOP_CUTOFF)
1971 unitsmask = encode_units_mask (unitsmask);
1972 else
1973 {
1974 /* We can no longer encode unitsmask at compile time, so emit code to
1975 calculate it at runtime. Rather, put a marker for where we'd do
1976 the code, and actually output it in write_attr_get(). */
1977 unitsmask = attr_rtx (FFS, unitsmask);
1978 }
1979
1980 make_internal_attr ("*function_units_used", unitsmask, 10);
1981
1982 /* Create an array of ops for each unit. Add an extra unit for the
1983 result_ready_cost function that has the ops of all other units. */
1984 unit_ops = (struct function_unit_op ***)
1985 alloca ((num_units + 1) * sizeof (struct function_unit_op **));
1986 unit_num = (struct function_unit **)
1987 alloca ((num_units + 1) * sizeof (struct function_unit *));
1988
1989 unit_num[num_units] = unit = (struct function_unit *)
1990 alloca (sizeof (struct function_unit));
1991 unit->num = num_units;
1992 unit->num_opclasses = 0;
1993
1994 for (unit = units; unit; unit = unit->next)
1995 {
1996 unit_num[num_units]->num_opclasses += unit->num_opclasses;
1997 unit_num[unit->num] = unit;
1998 unit_ops[unit->num] = op_array = (struct function_unit_op **)
1999 alloca (unit->num_opclasses * sizeof (struct function_unit_op *));
2000
2001 for (op = unit->ops; op; op = op->next)
2002 op_array[op->num] = op;
2003 }
2004
2005 /* Compose the array of ops for the extra unit. */
2006 unit_ops[num_units] = op_array = (struct function_unit_op **)
2007 alloca (unit_num[num_units]->num_opclasses
2008 * sizeof (struct function_unit_op *));
2009
2010 for (unit = units, i = 0; unit; i += unit->num_opclasses, unit = unit->next)
2011 bcopy ((char *) unit_ops[unit->num], (char *) &op_array[i],
2012 unit->num_opclasses * sizeof (struct function_unit_op *));
2013
2014 /* Compute the ready cost function for each unit by computing the
2015 condition for each non-default value. */
2016 for (u = 0; u <= num_units; u++)
2017 {
2018 rtx orexp;
2019 int value;
2020
2021 unit = unit_num[u];
2022 op_array = unit_ops[unit->num];
2023 num = unit->num_opclasses;
2024
2025 /* Sort the array of ops into increasing ready cost order. */
2026 for (i = 0; i < num; i++)
2027 for (j = num - 1; j > i; j--)
2028 if (op_array[j - 1]->ready < op_array[j]->ready)
2029 {
2030 op = op_array[j];
2031 op_array[j] = op_array[j - 1];
2032 op_array[j - 1] = op;
2033 }
2034
2035 /* Determine how many distinct non-default ready cost values there
2036 are. We use a default ready cost value of 1. */
2037 nvalues = 0; value = 1;
2038 for (i = num - 1; i >= 0; i--)
2039 if (op_array[i]->ready > value)
2040 {
2041 value = op_array[i]->ready;
2042 nvalues++;
2043 }
2044
2045 if (nvalues == 0)
2046 readycost = make_numeric_value (1);
2047 else
2048 {
2049 /* Construct the ready cost expression as a COND of each value from
2050 the largest to the smallest. */
2051 readycost = rtx_alloc (COND);
2052 XVEC (readycost, 0) = rtvec_alloc (nvalues * 2);
2053 XEXP (readycost, 1) = make_numeric_value (1);
2054
2055 nvalues = 0;
2056 orexp = false_rtx;
2057 value = op_array[0]->ready;
2058 for (i = 0; i < num; i++)
2059 {
2060 op = op_array[i];
2061 if (op->ready <= 1)
2062 break;
2063 else if (op->ready == value)
2064 orexp = insert_right_side (IOR, orexp, op->condexp, -2, -2);
2065 else
2066 {
2067 XVECEXP (readycost, 0, nvalues * 2) = orexp;
2068 XVECEXP (readycost, 0, nvalues * 2 + 1)
2069 = make_numeric_value (value);
2070 nvalues++;
2071 value = op->ready;
2072 orexp = op->condexp;
2073 }
2074 }
2075 XVECEXP (readycost, 0, nvalues * 2) = orexp;
2076 XVECEXP (readycost, 0, nvalues * 2 + 1) = make_numeric_value (value);
2077 }
2078
2079 if (u < num_units)
2080 {
2081 rtx max_blockage = 0, min_blockage = 0;
2082
2083 /* Simplify the readycost expression by only considering insns
2084 that use the unit. */
2085 readycost = simplify_knowing (readycost, unit->condexp);
2086
2087 /* Determine the blockage cost the executing insn (E) given
2088 the candidate insn (C). This is the maximum of the issue
2089 delay, the pipeline delay, and the simultaneity constraint.
2090 Each function_unit_op represents the characteristics of the
2091 candidate insn, so in the expressions below, C is a known
2092 term and E is an unknown term.
2093
2094 We compute the blockage cost for each E for every possible C.
2095 Thus OP represents E, and READYCOST is a list of values for
2096 every possible C.
2097
2098 The issue delay function for C is op->issue_exp and is used to
2099 write the `<name>_unit_conflict_cost' function. Symbolicly
2100 this is "ISSUE-DELAY (E,C)".
2101
2102 The pipeline delay results form the FIFO constraint on the
2103 function unit and is "READY-COST (E) + 1 - READY-COST (C)".
2104
2105 The simultaneity constraint is based on how long it takes to
2106 fill the unit given the minimum issue delay. FILL-TIME is the
2107 constant "MIN (ISSUE-DELAY (*,*)) * (SIMULTANEITY - 1)", and
2108 the simultaneity constraint is "READY-COST (E) - FILL-TIME"
2109 if SIMULTANEITY is non-zero and zero otherwise.
2110
2111 Thus, BLOCKAGE (E,C) when SIMULTANEITY is zero is
2112
2113 MAX (ISSUE-DELAY (E,C),
2114 READY-COST (E) - (READY-COST (C) - 1))
2115
2116 and otherwise
2117
2118 MAX (ISSUE-DELAY (E,C),
2119 READY-COST (E) - (READY-COST (C) - 1),
2120 READY-COST (E) - FILL-TIME)
2121
2122 The `<name>_unit_blockage' function is computed by determining
2123 this value for each candidate insn. As these values are
2124 computed, we also compute the upper and lower bounds for
2125 BLOCKAGE (E,*). These are combined to form the function
2126 `<name>_unit_blockage_range'. Finally, the maximum blockage
2127 cost, MAX (BLOCKAGE (*,*)), is computed. */
2128
2129 for (op = unit->ops; op; op = op->next)
2130 {
2131 rtx blockage = op->issue_exp;
2132 blockage = simplify_knowing (blockage, unit->condexp);
2133
2134 /* Add this op's contribution to MAX (BLOCKAGE (E,*)) and
2135 MIN (BLOCKAGE (E,*)). */
2136 if (max_blockage == 0)
2137 max_blockage = min_blockage = blockage;
2138 else
2139 {
2140 max_blockage
2141 = simplify_knowing (operate_exp (MAX_OP, max_blockage,
2142 blockage),
2143 unit->condexp);
2144 min_blockage
2145 = simplify_knowing (operate_exp (MIN_OP, min_blockage,
2146 blockage),
2147 unit->condexp);
2148 }
2149
2150 /* Make an attribute for use in the blockage function. */
2151 str = attr_printf (strlen (unit->name) + sizeof ("*_block_") + MAX_DIGITS,
2152 "*%s_block_%d", unit->name, op->num);
2153 make_internal_attr (str, blockage, 1);
2154 }
2155
2156 /* Record MAX (BLOCKAGE (*,*)). */
2157 {
2158 int unknown;
2159 unit->max_blockage = max_attr_value (max_blockage, &unknown);
2160 }
2161
2162 /* See if the upper and lower bounds of BLOCKAGE (E,*) are the
2163 same. If so, the blockage function carries no additional
2164 information and is not written. */
2165 newexp = operate_exp (EQ_OP, max_blockage, min_blockage);
2166 newexp = simplify_knowing (newexp, unit->condexp);
2167 unit->needs_blockage_function
2168 = (GET_CODE (newexp) != CONST_STRING
2169 || atoi (XSTR (newexp, 0)) != 1);
2170
2171 /* If the all values of BLOCKAGE (E,C) have the same value,
2172 neither blockage function is written. */
2173 unit->needs_range_function
2174 = (unit->needs_blockage_function
2175 || GET_CODE (max_blockage) != CONST_STRING);
2176
2177 if (unit->needs_range_function)
2178 {
2179 /* Compute the blockage range function and make an attribute
2180 for writing its value. */
2181 newexp = operate_exp (RANGE_OP, min_blockage, max_blockage);
2182 newexp = simplify_knowing (newexp, unit->condexp);
2183
2184 str = attr_printf (strlen (unit->name) + sizeof ("*_unit_blockage_range"),
2185 "*%s_unit_blockage_range", unit->name);
2186 make_internal_attr (str, newexp, 20);
2187 }
2188
2189 str = attr_printf (strlen (unit->name) + sizeof ("*_unit_ready_cost"),
2190 "*%s_unit_ready_cost", unit->name);
2191 }
2192 else
2193 str = "*result_ready_cost";
2194
2195 /* Make an attribute for the ready_cost function. Simplifying
2196 further with simplify_by_exploding doesn't win. */
2197 make_internal_attr (str, readycost, 0);
2198 }
2199
2200 /* For each unit that requires a conflict cost function, make an attribute
2201 that maps insns to the operation number. */
2202 for (unit = units; unit; unit = unit->next)
2203 {
2204 rtx caseexp;
2205
2206 if (! unit->needs_conflict_function
2207 && ! unit->needs_blockage_function)
2208 continue;
2209
2210 caseexp = rtx_alloc (COND);
2211 XVEC (caseexp, 0) = rtvec_alloc ((unit->num_opclasses - 1) * 2);
2212
2213 for (op = unit->ops; op; op = op->next)
2214 {
2215 /* Make our adjustment to the COND being computed. If we are the
2216 last operation class, place our values into the default of the
2217 COND. */
2218 if (op->num == unit->num_opclasses - 1)
2219 {
2220 XEXP (caseexp, 1) = make_numeric_value (op->num);
2221 }
2222 else
2223 {
2224 XVECEXP (caseexp, 0, op->num * 2) = op->condexp;
2225 XVECEXP (caseexp, 0, op->num * 2 + 1)
2226 = make_numeric_value (op->num);
2227 }
2228 }
2229
2230 /* Simplifying caseexp with simplify_by_exploding doesn't win. */
2231 str = attr_printf (strlen (unit->name) + sizeof ("*_cases"),
2232 "*%s_cases", unit->name);
2233 make_internal_attr (str, caseexp, 1);
2234 }
2235 }
2236
2237 /* Simplify EXP given KNOWN_TRUE. */
2238
2239 static rtx
2240 simplify_knowing (exp, known_true)
2241 rtx exp, known_true;
2242 {
2243 if (GET_CODE (exp) != CONST_STRING)
2244 {
2245 int unknown = 0, max;
2246 max = max_attr_value (exp, &unknown);
2247 if (! unknown)
2248 {
2249 exp = attr_rtx (IF_THEN_ELSE, known_true, exp,
2250 make_numeric_value (max));
2251 exp = simplify_by_exploding (exp);
2252 }
2253 }
2254 return exp;
2255 }
2256
2257 /* Translate the CONST_STRING expressions in X to change the encoding of
2258 value. On input, the value is a bitmask with a one bit for each unit
2259 used; on output, the value is the unit number (zero based) if one
2260 and only one unit is used or the one's compliment of the bitmask. */
2261
2262 static rtx
2263 encode_units_mask (x)
2264 rtx x;
2265 {
2266 register int i;
2267 register int j;
2268 register enum rtx_code code;
2269 register const char *fmt;
2270
2271 code = GET_CODE (x);
2272
2273 switch (code)
2274 {
2275 case CONST_STRING:
2276 i = atoi (XSTR (x, 0));
2277 if (i < 0)
2278 /* The sign bit encodes a one's compliment mask. */
2279 abort ();
2280 else if (i != 0 && i == (i & -i))
2281 /* Only one bit is set, so yield that unit number. */
2282 for (j = 0; (i >>= 1) != 0; j++)
2283 ;
2284 else
2285 j = ~i;
2286 return attr_rtx (CONST_STRING, attr_printf (MAX_DIGITS, "%d", j));
2287
2288 case REG:
2289 case QUEUED:
2290 case CONST_INT:
2291 case CONST_DOUBLE:
2292 case SYMBOL_REF:
2293 case CODE_LABEL:
2294 case PC:
2295 case CC0:
2296 case EQ_ATTR:
2297 return x;
2298
2299 default:
2300 break;
2301 }
2302
2303 /* Compare the elements. If any pair of corresponding elements
2304 fail to match, return 0 for the whole things. */
2305
2306 fmt = GET_RTX_FORMAT (code);
2307 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
2308 {
2309 switch (fmt[i])
2310 {
2311 case 'V':
2312 case 'E':
2313 for (j = 0; j < XVECLEN (x, i); j++)
2314 XVECEXP (x, i, j) = encode_units_mask (XVECEXP (x, i, j));
2315 break;
2316
2317 case 'e':
2318 XEXP (x, i) = encode_units_mask (XEXP (x, i));
2319 break;
2320 }
2321 }
2322 return x;
2323 }
2324 \f
2325 /* Once all attributes and insns have been read and checked, we construct for
2326 each attribute value a list of all the insns that have that value for
2327 the attribute. */
2328
2329 static void
2330 fill_attr (attr)
2331 struct attr_desc *attr;
2332 {
2333 struct attr_value *av;
2334 struct insn_ent *ie;
2335 struct insn_def *id;
2336 int i;
2337 rtx value;
2338
2339 /* Don't fill constant attributes. The value is independent of
2340 any particular insn. */
2341 if (attr->is_const)
2342 return;
2343
2344 for (id = defs; id; id = id->next)
2345 {
2346 /* If no value is specified for this insn for this attribute, use the
2347 default. */
2348 value = NULL;
2349 if (XVEC (id->def, id->vec_idx))
2350 for (i = 0; i < XVECLEN (id->def, id->vec_idx); i++)
2351 if (! strcmp (XSTR (XEXP (XVECEXP (id->def, id->vec_idx, i), 0), 0),
2352 attr->name))
2353 value = XEXP (XVECEXP (id->def, id->vec_idx, i), 1);
2354
2355 if (value == NULL)
2356 av = attr->default_val;
2357 else
2358 av = get_attr_value (value, attr, id->insn_code);
2359
2360 ie = (struct insn_ent *) oballoc (sizeof (struct insn_ent));
2361 ie->insn_code = id->insn_code;
2362 ie->insn_index = id->insn_code;
2363 insert_insn_ent (av, ie);
2364 }
2365 }
2366 \f
2367 /* Given an expression EXP, see if it is a COND or IF_THEN_ELSE that has a
2368 test that checks relative positions of insns (uses MATCH_DUP or PC).
2369 If so, replace it with what is obtained by passing the expression to
2370 ADDRESS_FN. If not but it is a COND or IF_THEN_ELSE, call this routine
2371 recursively on each value (including the default value). Otherwise,
2372 return the value returned by NO_ADDRESS_FN applied to EXP. */
2373
2374 static rtx
2375 substitute_address (exp, no_address_fn, address_fn)
2376 rtx exp;
2377 rtx (*no_address_fn) PARAMS ((rtx));
2378 rtx (*address_fn) PARAMS ((rtx));
2379 {
2380 int i;
2381 rtx newexp;
2382
2383 if (GET_CODE (exp) == COND)
2384 {
2385 /* See if any tests use addresses. */
2386 address_used = 0;
2387 for (i = 0; i < XVECLEN (exp, 0); i += 2)
2388 walk_attr_value (XVECEXP (exp, 0, i));
2389
2390 if (address_used)
2391 return (*address_fn) (exp);
2392
2393 /* Make a new copy of this COND, replacing each element. */
2394 newexp = rtx_alloc (COND);
2395 XVEC (newexp, 0) = rtvec_alloc (XVECLEN (exp, 0));
2396 for (i = 0; i < XVECLEN (exp, 0); i += 2)
2397 {
2398 XVECEXP (newexp, 0, i) = XVECEXP (exp, 0, i);
2399 XVECEXP (newexp, 0, i + 1)
2400 = substitute_address (XVECEXP (exp, 0, i + 1),
2401 no_address_fn, address_fn);
2402 }
2403
2404 XEXP (newexp, 1) = substitute_address (XEXP (exp, 1),
2405 no_address_fn, address_fn);
2406
2407 return newexp;
2408 }
2409
2410 else if (GET_CODE (exp) == IF_THEN_ELSE)
2411 {
2412 address_used = 0;
2413 walk_attr_value (XEXP (exp, 0));
2414 if (address_used)
2415 return (*address_fn) (exp);
2416
2417 return attr_rtx (IF_THEN_ELSE,
2418 substitute_address (XEXP (exp, 0),
2419 no_address_fn, address_fn),
2420 substitute_address (XEXP (exp, 1),
2421 no_address_fn, address_fn),
2422 substitute_address (XEXP (exp, 2),
2423 no_address_fn, address_fn));
2424 }
2425
2426 return (*no_address_fn) (exp);
2427 }
2428 \f
2429 /* Make new attributes from the `length' attribute. The following are made,
2430 each corresponding to a function called from `shorten_branches' or
2431 `get_attr_length':
2432
2433 *insn_default_length This is the length of the insn to be returned
2434 by `get_attr_length' before `shorten_branches'
2435 has been called. In each case where the length
2436 depends on relative addresses, the largest
2437 possible is used. This routine is also used
2438 to compute the initial size of the insn.
2439
2440 *insn_variable_length_p This returns 1 if the insn's length depends
2441 on relative addresses, zero otherwise.
2442
2443 *insn_current_length This is only called when it is known that the
2444 insn has a variable length and returns the
2445 current length, based on relative addresses.
2446 */
2447
2448 static void
2449 make_length_attrs ()
2450 {
2451 static const char *new_names[] = {"*insn_default_length",
2452 "*insn_variable_length_p",
2453 "*insn_current_length"};
2454 static rtx (*no_address_fn[]) PARAMS ((rtx)) = {identity_fn, zero_fn, zero_fn};
2455 static rtx (*address_fn[]) PARAMS ((rtx)) = {max_fn, one_fn, identity_fn};
2456 size_t i;
2457 struct attr_desc *length_attr, *new_attr;
2458 struct attr_value *av, *new_av;
2459 struct insn_ent *ie, *new_ie;
2460
2461 /* See if length attribute is defined. If so, it must be numeric. Make
2462 it special so we don't output anything for it. */
2463 length_attr = find_attr ("length", 0);
2464 if (length_attr == 0)
2465 return;
2466
2467 if (! length_attr->is_numeric)
2468 fatal ("length attribute must be numeric.");
2469
2470 length_attr->is_const = 0;
2471 length_attr->is_special = 1;
2472
2473 /* Make each new attribute, in turn. */
2474 for (i = 0; i < ARRAY_SIZE (new_names); i++)
2475 {
2476 make_internal_attr (new_names[i],
2477 substitute_address (length_attr->default_val->value,
2478 no_address_fn[i], address_fn[i]),
2479 0);
2480 new_attr = find_attr (new_names[i], 0);
2481 for (av = length_attr->first_value; av; av = av->next)
2482 for (ie = av->first_insn; ie; ie = ie->next)
2483 {
2484 new_av = get_attr_value (substitute_address (av->value,
2485 no_address_fn[i],
2486 address_fn[i]),
2487 new_attr, ie->insn_code);
2488 new_ie = (struct insn_ent *) oballoc (sizeof (struct insn_ent));
2489 new_ie->insn_code = ie->insn_code;
2490 new_ie->insn_index = ie->insn_index;
2491 insert_insn_ent (new_av, new_ie);
2492 }
2493 }
2494 }
2495
2496 /* Utility functions called from above routine. */
2497
2498 static rtx
2499 identity_fn (exp)
2500 rtx exp;
2501 {
2502 return exp;
2503 }
2504
2505 static rtx
2506 zero_fn (exp)
2507 rtx exp ATTRIBUTE_UNUSED;
2508 {
2509 return make_numeric_value (0);
2510 }
2511
2512 static rtx
2513 one_fn (exp)
2514 rtx exp ATTRIBUTE_UNUSED;
2515 {
2516 return make_numeric_value (1);
2517 }
2518
2519 static rtx
2520 max_fn (exp)
2521 rtx exp;
2522 {
2523 int unknown;
2524 return make_numeric_value (max_attr_value (exp, &unknown));
2525 }
2526
2527 static void
2528 write_length_unit_log ()
2529 {
2530 struct attr_desc *length_attr = find_attr ("length", 0);
2531 struct attr_value *av;
2532 struct insn_ent *ie;
2533 unsigned int length_unit_log, length_or;
2534 int unknown = 0;
2535
2536 if (length_attr == 0)
2537 return;
2538 length_or = or_attr_value (length_attr->default_val->value, &unknown);
2539 for (av = length_attr->first_value; av; av = av->next)
2540 for (ie = av->first_insn; ie; ie = ie->next)
2541 length_or |= or_attr_value (av->value, &unknown);
2542
2543 if (unknown)
2544 length_unit_log = 0;
2545 else
2546 {
2547 length_or = ~length_or;
2548 for (length_unit_log = 0; length_or & 1; length_or >>= 1)
2549 length_unit_log++;
2550 }
2551 printf ("int length_unit_log = %u;\n", length_unit_log);
2552 }
2553 \f
2554 /* Take a COND expression and see if any of the conditions in it can be
2555 simplified. If any are known true or known false for the particular insn
2556 code, the COND can be further simplified.
2557
2558 Also call ourselves on any COND operations that are values of this COND.
2559
2560 We do not modify EXP; rather, we make and return a new rtx. */
2561
2562 static rtx
2563 simplify_cond (exp, insn_code, insn_index)
2564 rtx exp;
2565 int insn_code, insn_index;
2566 {
2567 int i, j;
2568 /* We store the desired contents here,
2569 then build a new expression if they don't match EXP. */
2570 rtx defval = XEXP (exp, 1);
2571 rtx new_defval = XEXP (exp, 1);
2572 int len = XVECLEN (exp, 0);
2573 rtx *tests = (rtx *) alloca (len * sizeof (rtx));
2574 int allsame = 1;
2575 char *first_spacer;
2576
2577 /* This lets us free all storage allocated below, if appropriate. */
2578 first_spacer = (char *) obstack_finish (rtl_obstack);
2579
2580 bcopy ((char *) XVEC (exp, 0)->elem, (char *) tests, len * sizeof (rtx));
2581
2582 /* See if default value needs simplification. */
2583 if (GET_CODE (defval) == COND)
2584 new_defval = simplify_cond (defval, insn_code, insn_index);
2585
2586 /* Simplify the subexpressions, and see what tests we can get rid of. */
2587
2588 for (i = 0; i < len; i += 2)
2589 {
2590 rtx newtest, newval;
2591
2592 /* Simplify this test. */
2593 newtest = SIMPLIFY_TEST_EXP (tests[i], insn_code, insn_index);
2594 tests[i] = newtest;
2595
2596 newval = tests[i + 1];
2597 /* See if this value may need simplification. */
2598 if (GET_CODE (newval) == COND)
2599 newval = simplify_cond (newval, insn_code, insn_index);
2600
2601 /* Look for ways to delete or combine this test. */
2602 if (newtest == true_rtx)
2603 {
2604 /* If test is true, make this value the default
2605 and discard this + any following tests. */
2606 len = i;
2607 defval = tests[i + 1];
2608 new_defval = newval;
2609 }
2610
2611 else if (newtest == false_rtx)
2612 {
2613 /* If test is false, discard it and its value. */
2614 for (j = i; j < len - 2; j++)
2615 tests[j] = tests[j + 2];
2616 len -= 2;
2617 }
2618
2619 else if (i > 0 && attr_equal_p (newval, tests[i - 1]))
2620 {
2621 /* If this value and the value for the prev test are the same,
2622 merge the tests. */
2623
2624 tests[i - 2]
2625 = insert_right_side (IOR, tests[i - 2], newtest,
2626 insn_code, insn_index);
2627
2628 /* Delete this test/value. */
2629 for (j = i; j < len - 2; j++)
2630 tests[j] = tests[j + 2];
2631 len -= 2;
2632 }
2633
2634 else
2635 tests[i + 1] = newval;
2636 }
2637
2638 /* If the last test in a COND has the same value
2639 as the default value, that test isn't needed. */
2640
2641 while (len > 0 && attr_equal_p (tests[len - 1], new_defval))
2642 len -= 2;
2643
2644 /* See if we changed anything. */
2645 if (len != XVECLEN (exp, 0) || new_defval != XEXP (exp, 1))
2646 allsame = 0;
2647 else
2648 for (i = 0; i < len; i++)
2649 if (! attr_equal_p (tests[i], XVECEXP (exp, 0, i)))
2650 {
2651 allsame = 0;
2652 break;
2653 }
2654
2655 if (len == 0)
2656 {
2657 if (GET_CODE (defval) == COND)
2658 return simplify_cond (defval, insn_code, insn_index);
2659 return defval;
2660 }
2661 else if (allsame)
2662 return exp;
2663 else
2664 {
2665 rtx newexp = rtx_alloc (COND);
2666
2667 XVEC (newexp, 0) = rtvec_alloc (len);
2668 bcopy ((char *) tests, (char *) XVEC (newexp, 0)->elem,
2669 len * sizeof (rtx));
2670 XEXP (newexp, 1) = new_defval;
2671 return newexp;
2672 }
2673 }
2674 \f
2675 /* Remove an insn entry from an attribute value. */
2676
2677 static void
2678 remove_insn_ent (av, ie)
2679 struct attr_value *av;
2680 struct insn_ent *ie;
2681 {
2682 struct insn_ent *previe;
2683
2684 if (av->first_insn == ie)
2685 av->first_insn = ie->next;
2686 else
2687 {
2688 for (previe = av->first_insn; previe->next != ie; previe = previe->next)
2689 ;
2690 previe->next = ie->next;
2691 }
2692
2693 av->num_insns--;
2694 if (ie->insn_code == -1)
2695 av->has_asm_insn = 0;
2696
2697 num_insn_ents--;
2698 }
2699
2700 /* Insert an insn entry in an attribute value list. */
2701
2702 static void
2703 insert_insn_ent (av, ie)
2704 struct attr_value *av;
2705 struct insn_ent *ie;
2706 {
2707 ie->next = av->first_insn;
2708 av->first_insn = ie;
2709 av->num_insns++;
2710 if (ie->insn_code == -1)
2711 av->has_asm_insn = 1;
2712
2713 num_insn_ents++;
2714 }
2715 \f
2716 /* This is a utility routine to take an expression that is a tree of either
2717 AND or IOR expressions and insert a new term. The new term will be
2718 inserted at the right side of the first node whose code does not match
2719 the root. A new node will be created with the root's code. Its left
2720 side will be the old right side and its right side will be the new
2721 term.
2722
2723 If the `term' is itself a tree, all its leaves will be inserted. */
2724
2725 static rtx
2726 insert_right_side (code, exp, term, insn_code, insn_index)
2727 enum rtx_code code;
2728 rtx exp;
2729 rtx term;
2730 int insn_code, insn_index;
2731 {
2732 rtx newexp;
2733
2734 /* Avoid consing in some special cases. */
2735 if (code == AND && term == true_rtx)
2736 return exp;
2737 if (code == AND && term == false_rtx)
2738 return false_rtx;
2739 if (code == AND && exp == true_rtx)
2740 return term;
2741 if (code == AND && exp == false_rtx)
2742 return false_rtx;
2743 if (code == IOR && term == true_rtx)
2744 return true_rtx;
2745 if (code == IOR && term == false_rtx)
2746 return exp;
2747 if (code == IOR && exp == true_rtx)
2748 return true_rtx;
2749 if (code == IOR && exp == false_rtx)
2750 return term;
2751 if (attr_equal_p (exp, term))
2752 return exp;
2753
2754 if (GET_CODE (term) == code)
2755 {
2756 exp = insert_right_side (code, exp, XEXP (term, 0),
2757 insn_code, insn_index);
2758 exp = insert_right_side (code, exp, XEXP (term, 1),
2759 insn_code, insn_index);
2760
2761 return exp;
2762 }
2763
2764 if (GET_CODE (exp) == code)
2765 {
2766 rtx new = insert_right_side (code, XEXP (exp, 1),
2767 term, insn_code, insn_index);
2768 if (new != XEXP (exp, 1))
2769 /* Make a copy of this expression and call recursively. */
2770 newexp = attr_rtx (code, XEXP (exp, 0), new);
2771 else
2772 newexp = exp;
2773 }
2774 else
2775 {
2776 /* Insert the new term. */
2777 newexp = attr_rtx (code, exp, term);
2778 }
2779
2780 return SIMPLIFY_TEST_EXP (newexp, insn_code, insn_index);
2781 }
2782 \f
2783 /* If we have an expression which AND's a bunch of
2784 (not (eq_attrq "alternative" "n"))
2785 terms, we may have covered all or all but one of the possible alternatives.
2786 If so, we can optimize. Similarly for IOR's of EQ_ATTR.
2787
2788 This routine is passed an expression and either AND or IOR. It returns a
2789 bitmask indicating which alternatives are mentioned within EXP. */
2790
2791 static int
2792 compute_alternative_mask (exp, code)
2793 rtx exp;
2794 enum rtx_code code;
2795 {
2796 const char *string;
2797 if (GET_CODE (exp) == code)
2798 return compute_alternative_mask (XEXP (exp, 0), code)
2799 | compute_alternative_mask (XEXP (exp, 1), code);
2800
2801 else if (code == AND && GET_CODE (exp) == NOT
2802 && GET_CODE (XEXP (exp, 0)) == EQ_ATTR
2803 && XSTR (XEXP (exp, 0), 0) == alternative_name)
2804 string = XSTR (XEXP (exp, 0), 1);
2805
2806 else if (code == IOR && GET_CODE (exp) == EQ_ATTR
2807 && XSTR (exp, 0) == alternative_name)
2808 string = XSTR (exp, 1);
2809
2810 else
2811 return 0;
2812
2813 if (string[1] == 0)
2814 return 1 << (string[0] - '0');
2815 return 1 << atoi (string);
2816 }
2817
2818 /* Given I, a single-bit mask, return RTX to compare the `alternative'
2819 attribute with the value represented by that bit. */
2820
2821 static rtx
2822 make_alternative_compare (mask)
2823 int mask;
2824 {
2825 rtx newexp;
2826 int i;
2827
2828 /* Find the bit. */
2829 for (i = 0; (mask & (1 << i)) == 0; i++)
2830 ;
2831
2832 newexp = attr_rtx (EQ_ATTR, alternative_name, attr_numeral (i));
2833 RTX_UNCHANGING_P (newexp) = 1;
2834
2835 return newexp;
2836 }
2837 \f
2838 /* If we are processing an (eq_attr "attr" "value") test, we find the value
2839 of "attr" for this insn code. From that value, we can compute a test
2840 showing when the EQ_ATTR will be true. This routine performs that
2841 computation. If a test condition involves an address, we leave the EQ_ATTR
2842 intact because addresses are only valid for the `length' attribute.
2843
2844 EXP is the EQ_ATTR expression and VALUE is the value of that attribute
2845 for the insn corresponding to INSN_CODE and INSN_INDEX. */
2846
2847 static rtx
2848 evaluate_eq_attr (exp, value, insn_code, insn_index)
2849 rtx exp;
2850 rtx value;
2851 int insn_code, insn_index;
2852 {
2853 rtx orexp, andexp;
2854 rtx right;
2855 rtx newexp;
2856 int i;
2857
2858 if (GET_CODE (value) == CONST_STRING)
2859 {
2860 if (! strcmp (XSTR (value, 0), XSTR (exp, 1)))
2861 newexp = true_rtx;
2862 else
2863 newexp = false_rtx;
2864 }
2865 else if (GET_CODE (value) == SYMBOL_REF)
2866 {
2867 char *p, *string;
2868
2869 if (GET_CODE (exp) != EQ_ATTR)
2870 abort ();
2871
2872 string = (char *) alloca (2 + strlen (XSTR (exp, 0))
2873 + strlen (XSTR (exp, 1)));
2874 strcpy (string, XSTR (exp, 0));
2875 strcat (string, "_");
2876 strcat (string, XSTR (exp, 1));
2877 for (p = string; *p; p++)
2878 *p = TOUPPER (*p);
2879
2880 newexp = attr_rtx (EQ, value,
2881 attr_rtx (SYMBOL_REF,
2882 attr_string (string, strlen (string))));
2883 }
2884 else if (GET_CODE (value) == COND)
2885 {
2886 /* We construct an IOR of all the cases for which the requested attribute
2887 value is present. Since we start with FALSE, if it is not present,
2888 FALSE will be returned.
2889
2890 Each case is the AND of the NOT's of the previous conditions with the
2891 current condition; in the default case the current condition is TRUE.
2892
2893 For each possible COND value, call ourselves recursively.
2894
2895 The extra TRUE and FALSE expressions will be eliminated by another
2896 call to the simplification routine. */
2897
2898 orexp = false_rtx;
2899 andexp = true_rtx;
2900
2901 if (current_alternative_string)
2902 clear_struct_flag (value);
2903
2904 for (i = 0; i < XVECLEN (value, 0); i += 2)
2905 {
2906 rtx this = SIMPLIFY_TEST_EXP (XVECEXP (value, 0, i),
2907 insn_code, insn_index);
2908
2909 SIMPLIFY_ALTERNATIVE (this);
2910
2911 right = insert_right_side (AND, andexp, this,
2912 insn_code, insn_index);
2913 right = insert_right_side (AND, right,
2914 evaluate_eq_attr (exp,
2915 XVECEXP (value, 0,
2916 i + 1),
2917 insn_code, insn_index),
2918 insn_code, insn_index);
2919 orexp = insert_right_side (IOR, orexp, right,
2920 insn_code, insn_index);
2921
2922 /* Add this condition into the AND expression. */
2923 newexp = attr_rtx (NOT, this);
2924 andexp = insert_right_side (AND, andexp, newexp,
2925 insn_code, insn_index);
2926 }
2927
2928 /* Handle the default case. */
2929 right = insert_right_side (AND, andexp,
2930 evaluate_eq_attr (exp, XEXP (value, 1),
2931 insn_code, insn_index),
2932 insn_code, insn_index);
2933 newexp = insert_right_side (IOR, orexp, right, insn_code, insn_index);
2934 }
2935 else
2936 abort ();
2937
2938 /* If uses an address, must return original expression. But set the
2939 RTX_UNCHANGING_P bit so we don't try to simplify it again. */
2940
2941 address_used = 0;
2942 walk_attr_value (newexp);
2943
2944 if (address_used)
2945 {
2946 /* This had `&& current_alternative_string', which seems to be wrong. */
2947 if (! RTX_UNCHANGING_P (exp))
2948 return copy_rtx_unchanging (exp);
2949 return exp;
2950 }
2951 else
2952 return newexp;
2953 }
2954 \f
2955 /* This routine is called when an AND of a term with a tree of AND's is
2956 encountered. If the term or its complement is present in the tree, it
2957 can be replaced with TRUE or FALSE, respectively.
2958
2959 Note that (eq_attr "att" "v1") and (eq_attr "att" "v2") cannot both
2960 be true and hence are complementary.
2961
2962 There is one special case: If we see
2963 (and (not (eq_attr "att" "v1"))
2964 (eq_attr "att" "v2"))
2965 this can be replaced by (eq_attr "att" "v2"). To do this we need to
2966 replace the term, not anything in the AND tree. So we pass a pointer to
2967 the term. */
2968
2969 static rtx
2970 simplify_and_tree (exp, pterm, insn_code, insn_index)
2971 rtx exp;
2972 rtx *pterm;
2973 int insn_code, insn_index;
2974 {
2975 rtx left, right;
2976 rtx newexp;
2977 rtx temp;
2978 int left_eliminates_term, right_eliminates_term;
2979
2980 if (GET_CODE (exp) == AND)
2981 {
2982 left = simplify_and_tree (XEXP (exp, 0), pterm, insn_code, insn_index);
2983 right = simplify_and_tree (XEXP (exp, 1), pterm, insn_code, insn_index);
2984 if (left != XEXP (exp, 0) || right != XEXP (exp, 1))
2985 {
2986 newexp = attr_rtx (GET_CODE (exp), left, right);
2987
2988 exp = SIMPLIFY_TEST_EXP (newexp, insn_code, insn_index);
2989 }
2990 }
2991
2992 else if (GET_CODE (exp) == IOR)
2993 {
2994 /* For the IOR case, we do the same as above, except that we can
2995 only eliminate `term' if both sides of the IOR would do so. */
2996 temp = *pterm;
2997 left = simplify_and_tree (XEXP (exp, 0), &temp, insn_code, insn_index);
2998 left_eliminates_term = (temp == true_rtx);
2999
3000 temp = *pterm;
3001 right = simplify_and_tree (XEXP (exp, 1), &temp, insn_code, insn_index);
3002 right_eliminates_term = (temp == true_rtx);
3003
3004 if (left_eliminates_term && right_eliminates_term)
3005 *pterm = true_rtx;
3006
3007 if (left != XEXP (exp, 0) || right != XEXP (exp, 1))
3008 {
3009 newexp = attr_rtx (GET_CODE (exp), left, right);
3010
3011 exp = SIMPLIFY_TEST_EXP (newexp, insn_code, insn_index);
3012 }
3013 }
3014
3015 /* Check for simplifications. Do some extra checking here since this
3016 routine is called so many times. */
3017
3018 if (exp == *pterm)
3019 return true_rtx;
3020
3021 else if (GET_CODE (exp) == NOT && XEXP (exp, 0) == *pterm)
3022 return false_rtx;
3023
3024 else if (GET_CODE (*pterm) == NOT && exp == XEXP (*pterm, 0))
3025 return false_rtx;
3026
3027 else if (GET_CODE (exp) == EQ_ATTR && GET_CODE (*pterm) == EQ_ATTR)
3028 {
3029 if (XSTR (exp, 0) != XSTR (*pterm, 0))
3030 return exp;
3031
3032 if (! strcmp (XSTR (exp, 1), XSTR (*pterm, 1)))
3033 return true_rtx;
3034 else
3035 return false_rtx;
3036 }
3037
3038 else if (GET_CODE (*pterm) == EQ_ATTR && GET_CODE (exp) == NOT
3039 && GET_CODE (XEXP (exp, 0)) == EQ_ATTR)
3040 {
3041 if (XSTR (*pterm, 0) != XSTR (XEXP (exp, 0), 0))
3042 return exp;
3043
3044 if (! strcmp (XSTR (*pterm, 1), XSTR (XEXP (exp, 0), 1)))
3045 return false_rtx;
3046 else
3047 return true_rtx;
3048 }
3049
3050 else if (GET_CODE (exp) == EQ_ATTR && GET_CODE (*pterm) == NOT
3051 && GET_CODE (XEXP (*pterm, 0)) == EQ_ATTR)
3052 {
3053 if (XSTR (exp, 0) != XSTR (XEXP (*pterm, 0), 0))
3054 return exp;
3055
3056 if (! strcmp (XSTR (exp, 1), XSTR (XEXP (*pterm, 0), 1)))
3057 return false_rtx;
3058 else
3059 *pterm = true_rtx;
3060 }
3061
3062 else if (GET_CODE (exp) == NOT && GET_CODE (*pterm) == NOT)
3063 {
3064 if (attr_equal_p (XEXP (exp, 0), XEXP (*pterm, 0)))
3065 return true_rtx;
3066 }
3067
3068 else if (GET_CODE (exp) == NOT)
3069 {
3070 if (attr_equal_p (XEXP (exp, 0), *pterm))
3071 return false_rtx;
3072 }
3073
3074 else if (GET_CODE (*pterm) == NOT)
3075 {
3076 if (attr_equal_p (XEXP (*pterm, 0), exp))
3077 return false_rtx;
3078 }
3079
3080 else if (attr_equal_p (exp, *pterm))
3081 return true_rtx;
3082
3083 return exp;
3084 }
3085 \f
3086 /* Similar to `simplify_and_tree', but for IOR trees. */
3087
3088 static rtx
3089 simplify_or_tree (exp, pterm, insn_code, insn_index)
3090 rtx exp;
3091 rtx *pterm;
3092 int insn_code, insn_index;
3093 {
3094 rtx left, right;
3095 rtx newexp;
3096 rtx temp;
3097 int left_eliminates_term, right_eliminates_term;
3098
3099 if (GET_CODE (exp) == IOR)
3100 {
3101 left = simplify_or_tree (XEXP (exp, 0), pterm, insn_code, insn_index);
3102 right = simplify_or_tree (XEXP (exp, 1), pterm, insn_code, insn_index);
3103 if (left != XEXP (exp, 0) || right != XEXP (exp, 1))
3104 {
3105 newexp = attr_rtx (GET_CODE (exp), left, right);
3106
3107 exp = SIMPLIFY_TEST_EXP (newexp, insn_code, insn_index);
3108 }
3109 }
3110
3111 else if (GET_CODE (exp) == AND)
3112 {
3113 /* For the AND case, we do the same as above, except that we can
3114 only eliminate `term' if both sides of the AND would do so. */
3115 temp = *pterm;
3116 left = simplify_or_tree (XEXP (exp, 0), &temp, insn_code, insn_index);
3117 left_eliminates_term = (temp == false_rtx);
3118
3119 temp = *pterm;
3120 right = simplify_or_tree (XEXP (exp, 1), &temp, insn_code, insn_index);
3121 right_eliminates_term = (temp == false_rtx);
3122
3123 if (left_eliminates_term && right_eliminates_term)
3124 *pterm = false_rtx;
3125
3126 if (left != XEXP (exp, 0) || right != XEXP (exp, 1))
3127 {
3128 newexp = attr_rtx (GET_CODE (exp), left, right);
3129
3130 exp = SIMPLIFY_TEST_EXP (newexp, insn_code, insn_index);
3131 }
3132 }
3133
3134 if (attr_equal_p (exp, *pterm))
3135 return false_rtx;
3136
3137 else if (GET_CODE (exp) == NOT && attr_equal_p (XEXP (exp, 0), *pterm))
3138 return true_rtx;
3139
3140 else if (GET_CODE (*pterm) == NOT && attr_equal_p (XEXP (*pterm, 0), exp))
3141 return true_rtx;
3142
3143 else if (GET_CODE (*pterm) == EQ_ATTR && GET_CODE (exp) == NOT
3144 && GET_CODE (XEXP (exp, 0)) == EQ_ATTR
3145 && XSTR (*pterm, 0) == XSTR (XEXP (exp, 0), 0))
3146 *pterm = false_rtx;
3147
3148 else if (GET_CODE (exp) == EQ_ATTR && GET_CODE (*pterm) == NOT
3149 && GET_CODE (XEXP (*pterm, 0)) == EQ_ATTR
3150 && XSTR (exp, 0) == XSTR (XEXP (*pterm, 0), 0))
3151 return false_rtx;
3152
3153 return exp;
3154 }
3155 \f
3156 /* Given an expression, see if it can be simplified for a particular insn
3157 code based on the values of other attributes being tested. This can
3158 eliminate nested get_attr_... calls.
3159
3160 Note that if an endless recursion is specified in the patterns, the
3161 optimization will loop. However, it will do so in precisely the cases where
3162 an infinite recursion loop could occur during compilation. It's better that
3163 it occurs here! */
3164
3165 static rtx
3166 simplify_test_exp (exp, insn_code, insn_index)
3167 rtx exp;
3168 int insn_code, insn_index;
3169 {
3170 rtx left, right;
3171 struct attr_desc *attr;
3172 struct attr_value *av;
3173 struct insn_ent *ie;
3174 int i;
3175 rtx newexp = exp;
3176
3177 /* Don't re-simplify something we already simplified. */
3178 if (RTX_UNCHANGING_P (exp) || MEM_IN_STRUCT_P (exp))
3179 return exp;
3180
3181 switch (GET_CODE (exp))
3182 {
3183 case AND:
3184 left = SIMPLIFY_TEST_EXP (XEXP (exp, 0), insn_code, insn_index);
3185 SIMPLIFY_ALTERNATIVE (left);
3186 if (left == false_rtx)
3187 return false_rtx;
3188 right = SIMPLIFY_TEST_EXP (XEXP (exp, 1), insn_code, insn_index);
3189 SIMPLIFY_ALTERNATIVE (right);
3190 if (left == false_rtx)
3191 return false_rtx;
3192
3193 /* If either side is an IOR and we have (eq_attr "alternative" ..")
3194 present on both sides, apply the distributive law since this will
3195 yield simplifications. */
3196 if ((GET_CODE (left) == IOR || GET_CODE (right) == IOR)
3197 && compute_alternative_mask (left, IOR)
3198 && compute_alternative_mask (right, IOR))
3199 {
3200 if (GET_CODE (left) == IOR)
3201 {
3202 rtx tem = left;
3203 left = right;
3204 right = tem;
3205 }
3206
3207 newexp = attr_rtx (IOR,
3208 attr_rtx (AND, left, XEXP (right, 0)),
3209 attr_rtx (AND, left, XEXP (right, 1)));
3210
3211 return SIMPLIFY_TEST_EXP (newexp, insn_code, insn_index);
3212 }
3213
3214 /* Try with the term on both sides. */
3215 right = simplify_and_tree (right, &left, insn_code, insn_index);
3216 if (left == XEXP (exp, 0) && right == XEXP (exp, 1))
3217 left = simplify_and_tree (left, &right, insn_code, insn_index);
3218
3219 if (left == false_rtx || right == false_rtx)
3220 return false_rtx;
3221 else if (left == true_rtx)
3222 {
3223 return right;
3224 }
3225 else if (right == true_rtx)
3226 {
3227 return left;
3228 }
3229 /* See if all or all but one of the insn's alternatives are specified
3230 in this tree. Optimize if so. */
3231
3232 else if (insn_code >= 0
3233 && (GET_CODE (left) == AND
3234 || (GET_CODE (left) == NOT
3235 && GET_CODE (XEXP (left, 0)) == EQ_ATTR
3236 && XSTR (XEXP (left, 0), 0) == alternative_name)
3237 || GET_CODE (right) == AND
3238 || (GET_CODE (right) == NOT
3239 && GET_CODE (XEXP (right, 0)) == EQ_ATTR
3240 && XSTR (XEXP (right, 0), 0) == alternative_name)))
3241 {
3242 i = compute_alternative_mask (exp, AND);
3243 if (i & ~insn_alternatives[insn_code])
3244 fatal ("Invalid alternative specified for pattern number %d",
3245 insn_index);
3246
3247 /* If all alternatives are excluded, this is false. */
3248 i ^= insn_alternatives[insn_code];
3249 if (i == 0)
3250 return false_rtx;
3251 else if ((i & (i - 1)) == 0 && insn_alternatives[insn_code] > 1)
3252 {
3253 /* If just one excluded, AND a comparison with that one to the
3254 front of the tree. The others will be eliminated by
3255 optimization. We do not want to do this if the insn has one
3256 alternative and we have tested none of them! */
3257 left = make_alternative_compare (i);
3258 right = simplify_and_tree (exp, &left, insn_code, insn_index);
3259 newexp = attr_rtx (AND, left, right);
3260
3261 return SIMPLIFY_TEST_EXP (newexp, insn_code, insn_index);
3262 }
3263 }
3264
3265 if (left != XEXP (exp, 0) || right != XEXP (exp, 1))
3266 {
3267 newexp = attr_rtx (AND, left, right);
3268 return SIMPLIFY_TEST_EXP (newexp, insn_code, insn_index);
3269 }
3270 break;
3271
3272 case IOR:
3273 left = SIMPLIFY_TEST_EXP (XEXP (exp, 0), insn_code, insn_index);
3274 SIMPLIFY_ALTERNATIVE (left);
3275 if (left == true_rtx)
3276 return true_rtx;
3277 right = SIMPLIFY_TEST_EXP (XEXP (exp, 1), insn_code, insn_index);
3278 SIMPLIFY_ALTERNATIVE (right);
3279 if (right == true_rtx)
3280 return true_rtx;
3281
3282 right = simplify_or_tree (right, &left, insn_code, insn_index);
3283 if (left == XEXP (exp, 0) && right == XEXP (exp, 1))
3284 left = simplify_or_tree (left, &right, insn_code, insn_index);
3285
3286 if (right == true_rtx || left == true_rtx)
3287 return true_rtx;
3288 else if (left == false_rtx)
3289 {
3290 return right;
3291 }
3292 else if (right == false_rtx)
3293 {
3294 return left;
3295 }
3296
3297 /* Test for simple cases where the distributive law is useful. I.e.,
3298 convert (ior (and (x) (y))
3299 (and (x) (z)))
3300 to (and (x)
3301 (ior (y) (z)))
3302 */
3303
3304 else if (GET_CODE (left) == AND && GET_CODE (right) == AND
3305 && attr_equal_p (XEXP (left, 0), XEXP (right, 0)))
3306 {
3307 newexp = attr_rtx (IOR, XEXP (left, 1), XEXP (right, 1));
3308
3309 left = XEXP (left, 0);
3310 right = newexp;
3311 newexp = attr_rtx (AND, left, right);
3312 return SIMPLIFY_TEST_EXP (newexp, insn_code, insn_index);
3313 }
3314
3315 /* See if all or all but one of the insn's alternatives are specified
3316 in this tree. Optimize if so. */
3317
3318 else if (insn_code >= 0
3319 && (GET_CODE (left) == IOR
3320 || (GET_CODE (left) == EQ_ATTR
3321 && XSTR (left, 0) == alternative_name)
3322 || GET_CODE (right) == IOR
3323 || (GET_CODE (right) == EQ_ATTR
3324 && XSTR (right, 0) == alternative_name)))
3325 {
3326 i = compute_alternative_mask (exp, IOR);
3327 if (i & ~insn_alternatives[insn_code])
3328 fatal ("Invalid alternative specified for pattern number %d",
3329 insn_index);
3330
3331 /* If all alternatives are included, this is true. */
3332 i ^= insn_alternatives[insn_code];
3333 if (i == 0)
3334 return true_rtx;
3335 else if ((i & (i - 1)) == 0 && insn_alternatives[insn_code] > 1)
3336 {
3337 /* If just one excluded, IOR a comparison with that one to the
3338 front of the tree. The others will be eliminated by
3339 optimization. We do not want to do this if the insn has one
3340 alternative and we have tested none of them! */
3341 left = make_alternative_compare (i);
3342 right = simplify_and_tree (exp, &left, insn_code, insn_index);
3343 newexp = attr_rtx (IOR, attr_rtx (NOT, left), right);
3344
3345 return SIMPLIFY_TEST_EXP (newexp, insn_code, insn_index);
3346 }
3347 }
3348
3349 if (left != XEXP (exp, 0) || right != XEXP (exp, 1))
3350 {
3351 newexp = attr_rtx (IOR, left, right);
3352 return SIMPLIFY_TEST_EXP (newexp, insn_code, insn_index);
3353 }
3354 break;
3355
3356 case NOT:
3357 if (GET_CODE (XEXP (exp, 0)) == NOT)
3358 {
3359 left = SIMPLIFY_TEST_EXP (XEXP (XEXP (exp, 0), 0),
3360 insn_code, insn_index);
3361 SIMPLIFY_ALTERNATIVE (left);
3362 return left;
3363 }
3364
3365 left = SIMPLIFY_TEST_EXP (XEXP (exp, 0), insn_code, insn_index);
3366 SIMPLIFY_ALTERNATIVE (left);
3367 if (GET_CODE (left) == NOT)
3368 return XEXP (left, 0);
3369
3370 if (left == false_rtx)
3371 return true_rtx;
3372 else if (left == true_rtx)
3373 return false_rtx;
3374
3375 /* Try to apply De`Morgan's laws. */
3376 else if (GET_CODE (left) == IOR)
3377 {
3378 newexp = attr_rtx (AND,
3379 attr_rtx (NOT, XEXP (left, 0)),
3380 attr_rtx (NOT, XEXP (left, 1)));
3381
3382 newexp = SIMPLIFY_TEST_EXP (newexp, insn_code, insn_index);
3383 }
3384 else if (GET_CODE (left) == AND)
3385 {
3386 newexp = attr_rtx (IOR,
3387 attr_rtx (NOT, XEXP (left, 0)),
3388 attr_rtx (NOT, XEXP (left, 1)));
3389
3390 newexp = SIMPLIFY_TEST_EXP (newexp, insn_code, insn_index);
3391 }
3392 else if (left != XEXP (exp, 0))
3393 {
3394 newexp = attr_rtx (NOT, left);
3395 }
3396 break;
3397
3398 case EQ_ATTR:
3399 if (current_alternative_string && XSTR (exp, 0) == alternative_name)
3400 return (XSTR (exp, 1) == current_alternative_string
3401 ? true_rtx : false_rtx);
3402
3403 /* Look at the value for this insn code in the specified attribute.
3404 We normally can replace this comparison with the condition that
3405 would give this insn the values being tested for. */
3406 if (XSTR (exp, 0) != alternative_name
3407 && (attr = find_attr (XSTR (exp, 0), 0)) != NULL)
3408 for (av = attr->first_value; av; av = av->next)
3409 for (ie = av->first_insn; ie; ie = ie->next)
3410 if (ie->insn_code == insn_code)
3411 return evaluate_eq_attr (exp, av->value, insn_code, insn_index);
3412 break;
3413
3414 default:
3415 break;
3416 }
3417
3418 /* We have already simplified this expression. Simplifying it again
3419 won't buy anything unless we weren't given a valid insn code
3420 to process (i.e., we are canonicalizing something.). */
3421 if (insn_code != -2 /* Seems wrong: && current_alternative_string. */
3422 && ! RTX_UNCHANGING_P (newexp))
3423 return copy_rtx_unchanging (newexp);
3424
3425 return newexp;
3426 }
3427 \f
3428 /* Optimize the attribute lists by seeing if we can determine conditional
3429 values from the known values of other attributes. This will save subroutine
3430 calls during the compilation. */
3431
3432 static void
3433 optimize_attrs ()
3434 {
3435 struct attr_desc *attr;
3436 struct attr_value *av;
3437 struct insn_ent *ie;
3438 rtx newexp;
3439 int something_changed = 1;
3440 int i;
3441 struct attr_value_list
3442 {
3443 struct attr_value *av;
3444 struct insn_ent *ie;
3445 struct attr_desc *attr;
3446 struct attr_value_list *next;
3447 };
3448 struct attr_value_list **insn_code_values;
3449 struct attr_value_list *ivbuf;
3450 struct attr_value_list *iv;
3451
3452 /* For each insn code, make a list of all the insn_ent's for it,
3453 for all values for all attributes. */
3454
3455 if (num_insn_ents == 0)
3456 return;
3457
3458 /* Make 2 extra elements, for "code" values -2 and -1. */
3459 insn_code_values
3460 = (struct attr_value_list **) alloca ((insn_code_number + 2)
3461 * sizeof (struct attr_value_list *));
3462 memset ((char *) insn_code_values, 0,
3463 (insn_code_number + 2) * sizeof (struct attr_value_list *));
3464
3465 /* Offset the table address so we can index by -2 or -1. */
3466 insn_code_values += 2;
3467
3468 /* Allocate the attr_value_list structures using xmalloc rather than
3469 alloca, because using alloca can overflow the maximum permitted
3470 stack limit on SPARC Lynx. */
3471 iv = ivbuf = ((struct attr_value_list *)
3472 xmalloc (num_insn_ents * sizeof (struct attr_value_list)));
3473
3474 for (i = 0; i < MAX_ATTRS_INDEX; i++)
3475 for (attr = attrs[i]; attr; attr = attr->next)
3476 for (av = attr->first_value; av; av = av->next)
3477 for (ie = av->first_insn; ie; ie = ie->next)
3478 {
3479 iv->attr = attr;
3480 iv->av = av;
3481 iv->ie = ie;
3482 iv->next = insn_code_values[ie->insn_code];
3483 insn_code_values[ie->insn_code] = iv;
3484 iv++;
3485 }
3486
3487 /* Sanity check on num_insn_ents. */
3488 if (iv != ivbuf + num_insn_ents)
3489 abort ();
3490
3491 /* Process one insn code at a time. */
3492 for (i = -2; i < insn_code_number; i++)
3493 {
3494 /* Clear the MEM_IN_STRUCT_P flag everywhere relevant.
3495 We use it to mean "already simplified for this insn". */
3496 for (iv = insn_code_values[i]; iv; iv = iv->next)
3497 clear_struct_flag (iv->av->value);
3498
3499 /* Loop until nothing changes for one iteration. */
3500 something_changed = 1;
3501 while (something_changed)
3502 {
3503 something_changed = 0;
3504 for (iv = insn_code_values[i]; iv; iv = iv->next)
3505 {
3506 struct obstack *old = rtl_obstack;
3507
3508 attr = iv->attr;
3509 av = iv->av;
3510 ie = iv->ie;
3511 if (GET_CODE (av->value) != COND)
3512 continue;
3513
3514 rtl_obstack = temp_obstack;
3515 #if 0 /* This was intended as a speed up, but it was slower. */
3516 if (insn_n_alternatives[ie->insn_code] > 6
3517 && count_sub_rtxs (av->value, 200) >= 200)
3518 newexp = simplify_by_alternatives (av->value, ie->insn_code,
3519 ie->insn_index);
3520 else
3521 #endif
3522 newexp = simplify_cond (av->value, ie->insn_code,
3523 ie->insn_index);
3524
3525 rtl_obstack = old;
3526 if (newexp != av->value)
3527 {
3528 newexp = attr_copy_rtx (newexp);
3529 remove_insn_ent (av, ie);
3530 av = get_attr_value (newexp, attr, ie->insn_code);
3531 iv->av = av;
3532 insert_insn_ent (av, ie);
3533 something_changed = 1;
3534 }
3535 }
3536 }
3537 }
3538
3539 free (ivbuf);
3540 }
3541
3542 #if 0
3543 static rtx
3544 simplify_by_alternatives (exp, insn_code, insn_index)
3545 rtx exp;
3546 int insn_code, insn_index;
3547 {
3548 int i;
3549 int len = insn_n_alternatives[insn_code];
3550 rtx newexp = rtx_alloc (COND);
3551 rtx ultimate;
3552
3553 XVEC (newexp, 0) = rtvec_alloc (len * 2);
3554
3555 /* It will not matter what value we use as the default value
3556 of the new COND, since that default will never be used.
3557 Choose something of the right type. */
3558 for (ultimate = exp; GET_CODE (ultimate) == COND;)
3559 ultimate = XEXP (ultimate, 1);
3560 XEXP (newexp, 1) = ultimate;
3561
3562 for (i = 0; i < insn_n_alternatives[insn_code]; i++)
3563 {
3564 current_alternative_string = attr_numeral (i);
3565 XVECEXP (newexp, 0, i * 2) = make_alternative_compare (1 << i);
3566 XVECEXP (newexp, 0, i * 2 + 1)
3567 = simplify_cond (exp, insn_code, insn_index);
3568 }
3569
3570 current_alternative_string = 0;
3571 return simplify_cond (newexp, insn_code, insn_index);
3572 }
3573 #endif
3574 \f
3575 /* If EXP is a suitable expression, reorganize it by constructing an
3576 equivalent expression that is a COND with the tests being all combinations
3577 of attribute values and the values being simple constants. */
3578
3579 static rtx
3580 simplify_by_exploding (exp)
3581 rtx exp;
3582 {
3583 rtx list = 0, link, condexp, defval = NULL_RTX;
3584 struct dimension *space;
3585 rtx *condtest, *condval;
3586 int i, j, total, ndim = 0;
3587 int most_tests, num_marks, new_marks;
3588
3589 /* Locate all the EQ_ATTR expressions. */
3590 if (! find_and_mark_used_attributes (exp, &list, &ndim) || ndim == 0)
3591 {
3592 unmark_used_attributes (list, 0, 0);
3593 return exp;
3594 }
3595
3596 /* Create an attribute space from the list of used attributes. For each
3597 dimension in the attribute space, record the attribute, list of values
3598 used, and number of values used. Add members to the list of values to
3599 cover the domain of the attribute. This makes the expanded COND form
3600 order independent. */
3601
3602 space = (struct dimension *) alloca (ndim * sizeof (struct dimension));
3603
3604 total = 1;
3605 for (ndim = 0; list; ndim++)
3606 {
3607 /* Pull the first attribute value from the list and record that
3608 attribute as another dimension in the attribute space. */
3609 const char *name = XSTR (XEXP (list, 0), 0);
3610 rtx *prev;
3611
3612 if ((space[ndim].attr = find_attr (name, 0)) == 0
3613 || space[ndim].attr->is_numeric)
3614 {
3615 unmark_used_attributes (list, space, ndim);
3616 return exp;
3617 }
3618
3619 /* Add all remaining attribute values that refer to this attribute. */
3620 space[ndim].num_values = 0;
3621 space[ndim].values = 0;
3622 prev = &list;
3623 for (link = list; link; link = *prev)
3624 if (! strcmp (XSTR (XEXP (link, 0), 0), name))
3625 {
3626 space[ndim].num_values++;
3627 *prev = XEXP (link, 1);
3628 XEXP (link, 1) = space[ndim].values;
3629 space[ndim].values = link;
3630 }
3631 else
3632 prev = &XEXP (link, 1);
3633
3634 /* Add sufficient members to the list of values to make the list
3635 mutually exclusive and record the total size of the attribute
3636 space. */
3637 total *= add_values_to_cover (&space[ndim]);
3638 }
3639
3640 /* Sort the attribute space so that the attributes go from non-constant
3641 to constant and from most values to least values. */
3642 for (i = 0; i < ndim; i++)
3643 for (j = ndim - 1; j > i; j--)
3644 if ((space[j-1].attr->is_const && !space[j].attr->is_const)
3645 || space[j-1].num_values < space[j].num_values)
3646 {
3647 struct dimension tmp;
3648 tmp = space[j];
3649 space[j] = space[j - 1];
3650 space[j - 1] = tmp;
3651 }
3652
3653 /* Establish the initial current value. */
3654 for (i = 0; i < ndim; i++)
3655 space[i].current_value = space[i].values;
3656
3657 condtest = (rtx *) alloca (total * sizeof (rtx));
3658 condval = (rtx *) alloca (total * sizeof (rtx));
3659
3660 /* Expand the tests and values by iterating over all values in the
3661 attribute space. */
3662 for (i = 0;; i++)
3663 {
3664 condtest[i] = test_for_current_value (space, ndim);
3665 condval[i] = simplify_with_current_value (exp, space, ndim);
3666 if (! increment_current_value (space, ndim))
3667 break;
3668 }
3669 if (i != total - 1)
3670 abort ();
3671
3672 /* We are now finished with the original expression. */
3673 unmark_used_attributes (0, space, ndim);
3674
3675 /* Find the most used constant value and make that the default. */
3676 most_tests = -1;
3677 for (i = num_marks = 0; i < total; i++)
3678 if (GET_CODE (condval[i]) == CONST_STRING
3679 && ! MEM_VOLATILE_P (condval[i]))
3680 {
3681 /* Mark the unmarked constant value and count how many are marked. */
3682 MEM_VOLATILE_P (condval[i]) = 1;
3683 for (j = new_marks = 0; j < total; j++)
3684 if (GET_CODE (condval[j]) == CONST_STRING
3685 && MEM_VOLATILE_P (condval[j]))
3686 new_marks++;
3687 if (new_marks - num_marks > most_tests)
3688 {
3689 most_tests = new_marks - num_marks;
3690 defval = condval[i];
3691 }
3692 num_marks = new_marks;
3693 }
3694 /* Clear all the marks. */
3695 for (i = 0; i < total; i++)
3696 MEM_VOLATILE_P (condval[i]) = 0;
3697
3698 /* Give up if nothing is constant. */
3699 if (num_marks == 0)
3700 return exp;
3701
3702 /* If all values are the default, use that. */
3703 if (total == most_tests)
3704 return defval;
3705
3706 /* Make a COND with the most common constant value the default. (A more
3707 complex method where tests with the same value were combined didn't
3708 seem to improve things.) */
3709 condexp = rtx_alloc (COND);
3710 XVEC (condexp, 0) = rtvec_alloc ((total - most_tests) * 2);
3711 XEXP (condexp, 1) = defval;
3712 for (i = j = 0; i < total; i++)
3713 if (condval[i] != defval)
3714 {
3715 XVECEXP (condexp, 0, 2 * j) = condtest[i];
3716 XVECEXP (condexp, 0, 2 * j + 1) = condval[i];
3717 j++;
3718 }
3719
3720 return condexp;
3721 }
3722
3723 /* Set the MEM_VOLATILE_P flag for all EQ_ATTR expressions in EXP and
3724 verify that EXP can be simplified to a constant term if all the EQ_ATTR
3725 tests have known value. */
3726
3727 static int
3728 find_and_mark_used_attributes (exp, terms, nterms)
3729 rtx exp, *terms;
3730 int *nterms;
3731 {
3732 int i;
3733
3734 switch (GET_CODE (exp))
3735 {
3736 case EQ_ATTR:
3737 if (! MEM_VOLATILE_P (exp))
3738 {
3739 rtx link = rtx_alloc (EXPR_LIST);
3740 XEXP (link, 0) = exp;
3741 XEXP (link, 1) = *terms;
3742 *terms = link;
3743 *nterms += 1;
3744 MEM_VOLATILE_P (exp) = 1;
3745 }
3746 return 1;
3747
3748 case CONST_STRING:
3749 case CONST_INT:
3750 return 1;
3751
3752 case IF_THEN_ELSE:
3753 if (! find_and_mark_used_attributes (XEXP (exp, 2), terms, nterms))
3754 return 0;
3755 case IOR:
3756 case AND:
3757 if (! find_and_mark_used_attributes (XEXP (exp, 1), terms, nterms))
3758 return 0;
3759 case NOT:
3760 if (! find_and_mark_used_attributes (XEXP (exp, 0), terms, nterms))
3761 return 0;
3762 return 1;
3763
3764 case COND:
3765 for (i = 0; i < XVECLEN (exp, 0); i++)
3766 if (! find_and_mark_used_attributes (XVECEXP (exp, 0, i), terms, nterms))
3767 return 0;
3768 if (! find_and_mark_used_attributes (XEXP (exp, 1), terms, nterms))
3769 return 0;
3770 return 1;
3771
3772 default:
3773 return 0;
3774 }
3775 }
3776
3777 /* Clear the MEM_VOLATILE_P flag in all EQ_ATTR expressions on LIST and
3778 in the values of the NDIM-dimensional attribute space SPACE. */
3779
3780 static void
3781 unmark_used_attributes (list, space, ndim)
3782 rtx list;
3783 struct dimension *space;
3784 int ndim;
3785 {
3786 rtx link, exp;
3787 int i;
3788
3789 for (i = 0; i < ndim; i++)
3790 unmark_used_attributes (space[i].values, 0, 0);
3791
3792 for (link = list; link; link = XEXP (link, 1))
3793 {
3794 exp = XEXP (link, 0);
3795 if (GET_CODE (exp) == EQ_ATTR)
3796 MEM_VOLATILE_P (exp) = 0;
3797 }
3798 }
3799
3800 /* Update the attribute dimension DIM so that all values of the attribute
3801 are tested. Return the updated number of values. */
3802
3803 static int
3804 add_values_to_cover (dim)
3805 struct dimension *dim;
3806 {
3807 struct attr_value *av;
3808 rtx exp, link, *prev;
3809 int nalt = 0;
3810
3811 for (av = dim->attr->first_value; av; av = av->next)
3812 if (GET_CODE (av->value) == CONST_STRING)
3813 nalt++;
3814
3815 if (nalt < dim->num_values)
3816 abort ();
3817 else if (nalt == dim->num_values)
3818 /* OK. */
3819 ;
3820 else if (nalt * 2 < dim->num_values * 3)
3821 {
3822 /* Most all the values of the attribute are used, so add all the unused
3823 values. */
3824 prev = &dim->values;
3825 for (link = dim->values; link; link = *prev)
3826 prev = &XEXP (link, 1);
3827
3828 for (av = dim->attr->first_value; av; av = av->next)
3829 if (GET_CODE (av->value) == CONST_STRING)
3830 {
3831 exp = attr_eq (dim->attr->name, XSTR (av->value, 0));
3832 if (MEM_VOLATILE_P (exp))
3833 continue;
3834
3835 link = rtx_alloc (EXPR_LIST);
3836 XEXP (link, 0) = exp;
3837 XEXP (link, 1) = 0;
3838 *prev = link;
3839 prev = &XEXP (link, 1);
3840 }
3841 dim->num_values = nalt;
3842 }
3843 else
3844 {
3845 rtx orexp = false_rtx;
3846
3847 /* Very few values are used, so compute a mutually exclusive
3848 expression. (We could do this for numeric values if that becomes
3849 important.) */
3850 prev = &dim->values;
3851 for (link = dim->values; link; link = *prev)
3852 {
3853 orexp = insert_right_side (IOR, orexp, XEXP (link, 0), -2, -2);
3854 prev = &XEXP (link, 1);
3855 }
3856 link = rtx_alloc (EXPR_LIST);
3857 XEXP (link, 0) = attr_rtx (NOT, orexp);
3858 XEXP (link, 1) = 0;
3859 *prev = link;
3860 dim->num_values++;
3861 }
3862 return dim->num_values;
3863 }
3864
3865 /* Increment the current value for the NDIM-dimensional attribute space SPACE
3866 and return FALSE if the increment overflowed. */
3867
3868 static int
3869 increment_current_value (space, ndim)
3870 struct dimension *space;
3871 int ndim;
3872 {
3873 int i;
3874
3875 for (i = ndim - 1; i >= 0; i--)
3876 {
3877 if ((space[i].current_value = XEXP (space[i].current_value, 1)) == 0)
3878 space[i].current_value = space[i].values;
3879 else
3880 return 1;
3881 }
3882 return 0;
3883 }
3884
3885 /* Construct an expression corresponding to the current value for the
3886 NDIM-dimensional attribute space SPACE. */
3887
3888 static rtx
3889 test_for_current_value (space, ndim)
3890 struct dimension *space;
3891 int ndim;
3892 {
3893 int i;
3894 rtx exp = true_rtx;
3895
3896 for (i = 0; i < ndim; i++)
3897 exp = insert_right_side (AND, exp, XEXP (space[i].current_value, 0),
3898 -2, -2);
3899
3900 return exp;
3901 }
3902
3903 /* Given the current value of the NDIM-dimensional attribute space SPACE,
3904 set the corresponding EQ_ATTR expressions to that value and reduce
3905 the expression EXP as much as possible. On input [and output], all
3906 known EQ_ATTR expressions are set to FALSE. */
3907
3908 static rtx
3909 simplify_with_current_value (exp, space, ndim)
3910 rtx exp;
3911 struct dimension *space;
3912 int ndim;
3913 {
3914 int i;
3915 rtx x;
3916
3917 /* Mark each current value as TRUE. */
3918 for (i = 0; i < ndim; i++)
3919 {
3920 x = XEXP (space[i].current_value, 0);
3921 if (GET_CODE (x) == EQ_ATTR)
3922 MEM_VOLATILE_P (x) = 0;
3923 }
3924
3925 exp = simplify_with_current_value_aux (exp);
3926
3927 /* Change each current value back to FALSE. */
3928 for (i = 0; i < ndim; i++)
3929 {
3930 x = XEXP (space[i].current_value, 0);
3931 if (GET_CODE (x) == EQ_ATTR)
3932 MEM_VOLATILE_P (x) = 1;
3933 }
3934
3935 return exp;
3936 }
3937
3938 /* Reduce the expression EXP based on the MEM_VOLATILE_P settings of
3939 all EQ_ATTR expressions. */
3940
3941 static rtx
3942 simplify_with_current_value_aux (exp)
3943 rtx exp;
3944 {
3945 register int i;
3946 rtx cond;
3947
3948 switch (GET_CODE (exp))
3949 {
3950 case EQ_ATTR:
3951 if (MEM_VOLATILE_P (exp))
3952 return false_rtx;
3953 else
3954 return true_rtx;
3955 case CONST_STRING:
3956 case CONST_INT:
3957 return exp;
3958
3959 case IF_THEN_ELSE:
3960 cond = simplify_with_current_value_aux (XEXP (exp, 0));
3961 if (cond == true_rtx)
3962 return simplify_with_current_value_aux (XEXP (exp, 1));
3963 else if (cond == false_rtx)
3964 return simplify_with_current_value_aux (XEXP (exp, 2));
3965 else
3966 return attr_rtx (IF_THEN_ELSE, cond,
3967 simplify_with_current_value_aux (XEXP (exp, 1)),
3968 simplify_with_current_value_aux (XEXP (exp, 2)));
3969
3970 case IOR:
3971 cond = simplify_with_current_value_aux (XEXP (exp, 1));
3972 if (cond == true_rtx)
3973 return cond;
3974 else if (cond == false_rtx)
3975 return simplify_with_current_value_aux (XEXP (exp, 0));
3976 else
3977 return attr_rtx (IOR, cond,
3978 simplify_with_current_value_aux (XEXP (exp, 0)));
3979
3980 case AND:
3981 cond = simplify_with_current_value_aux (XEXP (exp, 1));
3982 if (cond == true_rtx)
3983 return simplify_with_current_value_aux (XEXP (exp, 0));
3984 else if (cond == false_rtx)
3985 return cond;
3986 else
3987 return attr_rtx (AND, cond,
3988 simplify_with_current_value_aux (XEXP (exp, 0)));
3989
3990 case NOT:
3991 cond = simplify_with_current_value_aux (XEXP (exp, 0));
3992 if (cond == true_rtx)
3993 return false_rtx;
3994 else if (cond == false_rtx)
3995 return true_rtx;
3996 else
3997 return attr_rtx (NOT, cond);
3998
3999 case COND:
4000 for (i = 0; i < XVECLEN (exp, 0); i += 2)
4001 {
4002 cond = simplify_with_current_value_aux (XVECEXP (exp, 0, i));
4003 if (cond == true_rtx)
4004 return simplify_with_current_value_aux (XVECEXP (exp, 0, i + 1));
4005 else if (cond == false_rtx)
4006 continue;
4007 else
4008 abort (); /* With all EQ_ATTR's of known value, a case should
4009 have been selected. */
4010 }
4011 return simplify_with_current_value_aux (XEXP (exp, 1));
4012
4013 default:
4014 abort ();
4015 }
4016 }
4017 \f
4018 /* Clear the MEM_IN_STRUCT_P flag in EXP and its subexpressions. */
4019
4020 static void
4021 clear_struct_flag (x)
4022 rtx x;
4023 {
4024 register int i;
4025 register int j;
4026 register enum rtx_code code;
4027 register const char *fmt;
4028
4029 MEM_IN_STRUCT_P (x) = 0;
4030 if (RTX_UNCHANGING_P (x))
4031 return;
4032
4033 code = GET_CODE (x);
4034
4035 switch (code)
4036 {
4037 case REG:
4038 case QUEUED:
4039 case CONST_INT:
4040 case CONST_DOUBLE:
4041 case SYMBOL_REF:
4042 case CODE_LABEL:
4043 case PC:
4044 case CC0:
4045 case EQ_ATTR:
4046 case ATTR_FLAG:
4047 return;
4048
4049 default:
4050 break;
4051 }
4052
4053 /* Compare the elements. If any pair of corresponding elements
4054 fail to match, return 0 for the whole things. */
4055
4056 fmt = GET_RTX_FORMAT (code);
4057 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
4058 {
4059 switch (fmt[i])
4060 {
4061 case 'V':
4062 case 'E':
4063 for (j = 0; j < XVECLEN (x, i); j++)
4064 clear_struct_flag (XVECEXP (x, i, j));
4065 break;
4066
4067 case 'e':
4068 clear_struct_flag (XEXP (x, i));
4069 break;
4070 }
4071 }
4072 }
4073
4074 /* Return the number of RTX objects making up the expression X.
4075 But if we count more than MAX objects, stop counting. */
4076
4077 static int
4078 count_sub_rtxs (x, max)
4079 rtx x;
4080 int max;
4081 {
4082 register int i;
4083 register int j;
4084 register enum rtx_code code;
4085 register const char *fmt;
4086 int total = 0;
4087
4088 code = GET_CODE (x);
4089
4090 switch (code)
4091 {
4092 case REG:
4093 case QUEUED:
4094 case CONST_INT:
4095 case CONST_DOUBLE:
4096 case SYMBOL_REF:
4097 case CODE_LABEL:
4098 case PC:
4099 case CC0:
4100 case EQ_ATTR:
4101 case ATTR_FLAG:
4102 return 1;
4103
4104 default:
4105 break;
4106 }
4107
4108 /* Compare the elements. If any pair of corresponding elements
4109 fail to match, return 0 for the whole things. */
4110
4111 fmt = GET_RTX_FORMAT (code);
4112 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
4113 {
4114 if (total >= max)
4115 return total;
4116
4117 switch (fmt[i])
4118 {
4119 case 'V':
4120 case 'E':
4121 for (j = 0; j < XVECLEN (x, i); j++)
4122 total += count_sub_rtxs (XVECEXP (x, i, j), max);
4123 break;
4124
4125 case 'e':
4126 total += count_sub_rtxs (XEXP (x, i), max);
4127 break;
4128 }
4129 }
4130 return total;
4131
4132 }
4133 \f
4134 /* Create table entries for DEFINE_ATTR. */
4135
4136 static void
4137 gen_attr (exp, lineno)
4138 rtx exp;
4139 int lineno;
4140 {
4141 struct attr_desc *attr;
4142 struct attr_value *av;
4143 const char *name_ptr;
4144 char *p;
4145
4146 /* Make a new attribute structure. Check for duplicate by looking at
4147 attr->default_val, since it is initialized by this routine. */
4148 attr = find_attr (XSTR (exp, 0), 1);
4149 if (attr->default_val)
4150 {
4151 message_with_line (lineno, "duplicate definition for attribute %s",
4152 attr->name);
4153 message_with_line (attr->lineno, "previous definition");
4154 have_error = 1;
4155 return;
4156 }
4157 attr->lineno = lineno;
4158
4159 if (*XSTR (exp, 1) == '\0')
4160 attr->is_numeric = 1;
4161 else
4162 {
4163 name_ptr = XSTR (exp, 1);
4164 while ((p = next_comma_elt (&name_ptr)) != NULL)
4165 {
4166 av = (struct attr_value *) oballoc (sizeof (struct attr_value));
4167 av->value = attr_rtx (CONST_STRING, p);
4168 av->next = attr->first_value;
4169 attr->first_value = av;
4170 av->first_insn = NULL;
4171 av->num_insns = 0;
4172 av->has_asm_insn = 0;
4173 }
4174 }
4175
4176 if (GET_CODE (XEXP (exp, 2)) == CONST)
4177 {
4178 attr->is_const = 1;
4179 if (attr->is_numeric)
4180 {
4181 message_with_line (lineno,
4182 "constant attributes may not take numeric values");
4183 have_error = 1;
4184 }
4185
4186 /* Get rid of the CONST node. It is allowed only at top-level. */
4187 XEXP (exp, 2) = XEXP (XEXP (exp, 2), 0);
4188 }
4189
4190 if (! strcmp (attr->name, "length") && ! attr->is_numeric)
4191 {
4192 message_with_line (lineno,
4193 "`length' attribute must take numeric values");
4194 have_error = 1;
4195 }
4196
4197 /* Set up the default value. */
4198 XEXP (exp, 2) = check_attr_value (XEXP (exp, 2), attr);
4199 attr->default_val = get_attr_value (XEXP (exp, 2), attr, -2);
4200 }
4201 \f
4202 /* Given a pattern for DEFINE_PEEPHOLE or DEFINE_INSN, return the number of
4203 alternatives in the constraints. Assume all MATCH_OPERANDs have the same
4204 number of alternatives as this should be checked elsewhere. */
4205
4206 static int
4207 count_alternatives (exp)
4208 rtx exp;
4209 {
4210 int i, j, n;
4211 const char *fmt;
4212
4213 if (GET_CODE (exp) == MATCH_OPERAND)
4214 return n_comma_elts (XSTR (exp, 2));
4215
4216 for (i = 0, fmt = GET_RTX_FORMAT (GET_CODE (exp));
4217 i < GET_RTX_LENGTH (GET_CODE (exp)); i++)
4218 switch (*fmt++)
4219 {
4220 case 'e':
4221 case 'u':
4222 n = count_alternatives (XEXP (exp, i));
4223 if (n)
4224 return n;
4225 break;
4226
4227 case 'E':
4228 case 'V':
4229 if (XVEC (exp, i) != NULL)
4230 for (j = 0; j < XVECLEN (exp, i); j++)
4231 {
4232 n = count_alternatives (XVECEXP (exp, i, j));
4233 if (n)
4234 return n;
4235 }
4236 }
4237
4238 return 0;
4239 }
4240 \f
4241 /* Returns non-zero if the given expression contains an EQ_ATTR with the
4242 `alternative' attribute. */
4243
4244 static int
4245 compares_alternatives_p (exp)
4246 rtx exp;
4247 {
4248 int i, j;
4249 const char *fmt;
4250
4251 if (GET_CODE (exp) == EQ_ATTR && XSTR (exp, 0) == alternative_name)
4252 return 1;
4253
4254 for (i = 0, fmt = GET_RTX_FORMAT (GET_CODE (exp));
4255 i < GET_RTX_LENGTH (GET_CODE (exp)); i++)
4256 switch (*fmt++)
4257 {
4258 case 'e':
4259 case 'u':
4260 if (compares_alternatives_p (XEXP (exp, i)))
4261 return 1;
4262 break;
4263
4264 case 'E':
4265 for (j = 0; j < XVECLEN (exp, i); j++)
4266 if (compares_alternatives_p (XVECEXP (exp, i, j)))
4267 return 1;
4268 break;
4269 }
4270
4271 return 0;
4272 }
4273 \f
4274 /* Returns non-zero is INNER is contained in EXP. */
4275
4276 static int
4277 contained_in_p (inner, exp)
4278 rtx inner;
4279 rtx exp;
4280 {
4281 int i, j;
4282 const char *fmt;
4283
4284 if (rtx_equal_p (inner, exp))
4285 return 1;
4286
4287 for (i = 0, fmt = GET_RTX_FORMAT (GET_CODE (exp));
4288 i < GET_RTX_LENGTH (GET_CODE (exp)); i++)
4289 switch (*fmt++)
4290 {
4291 case 'e':
4292 case 'u':
4293 if (contained_in_p (inner, XEXP (exp, i)))
4294 return 1;
4295 break;
4296
4297 case 'E':
4298 for (j = 0; j < XVECLEN (exp, i); j++)
4299 if (contained_in_p (inner, XVECEXP (exp, i, j)))
4300 return 1;
4301 break;
4302 }
4303
4304 return 0;
4305 }
4306 \f
4307 /* Process DEFINE_PEEPHOLE, DEFINE_INSN, and DEFINE_ASM_ATTRIBUTES. */
4308
4309 static void
4310 gen_insn (exp, lineno)
4311 rtx exp;
4312 int lineno;
4313 {
4314 struct insn_def *id;
4315
4316 id = (struct insn_def *) oballoc (sizeof (struct insn_def));
4317 id->next = defs;
4318 defs = id;
4319 id->def = exp;
4320 id->lineno = lineno;
4321
4322 switch (GET_CODE (exp))
4323 {
4324 case DEFINE_INSN:
4325 id->insn_code = insn_code_number;
4326 id->insn_index = insn_index_number;
4327 id->num_alternatives = count_alternatives (exp);
4328 if (id->num_alternatives == 0)
4329 id->num_alternatives = 1;
4330 id->vec_idx = 4;
4331 break;
4332
4333 case DEFINE_PEEPHOLE:
4334 id->insn_code = insn_code_number;
4335 id->insn_index = insn_index_number;
4336 id->num_alternatives = count_alternatives (exp);
4337 if (id->num_alternatives == 0)
4338 id->num_alternatives = 1;
4339 id->vec_idx = 3;
4340 break;
4341
4342 case DEFINE_ASM_ATTRIBUTES:
4343 id->insn_code = -1;
4344 id->insn_index = -1;
4345 id->num_alternatives = 1;
4346 id->vec_idx = 0;
4347 got_define_asm_attributes = 1;
4348 break;
4349
4350 default:
4351 abort ();
4352 }
4353 }
4354 \f
4355 /* Process a DEFINE_DELAY. Validate the vector length, check if annul
4356 true or annul false is specified, and make a `struct delay_desc'. */
4357
4358 static void
4359 gen_delay (def, lineno)
4360 rtx def;
4361 int lineno;
4362 {
4363 struct delay_desc *delay;
4364 int i;
4365
4366 if (XVECLEN (def, 1) % 3 != 0)
4367 {
4368 message_with_line (lineno,
4369 "number of elements in DEFINE_DELAY must be multiple of three");
4370 have_error = 1;
4371 return;
4372 }
4373
4374 for (i = 0; i < XVECLEN (def, 1); i += 3)
4375 {
4376 if (XVECEXP (def, 1, i + 1))
4377 have_annul_true = 1;
4378 if (XVECEXP (def, 1, i + 2))
4379 have_annul_false = 1;
4380 }
4381
4382 delay = (struct delay_desc *) oballoc (sizeof (struct delay_desc));
4383 delay->def = def;
4384 delay->num = ++num_delays;
4385 delay->next = delays;
4386 delay->lineno = lineno;
4387 delays = delay;
4388 }
4389 \f
4390 /* Process a DEFINE_FUNCTION_UNIT.
4391
4392 This gives information about a function unit contained in the CPU.
4393 We fill in a `struct function_unit_op' and a `struct function_unit'
4394 with information used later by `expand_unit'. */
4395
4396 static void
4397 gen_unit (def, lineno)
4398 rtx def;
4399 int lineno;
4400 {
4401 struct function_unit *unit;
4402 struct function_unit_op *op;
4403 const char *name = XSTR (def, 0);
4404 int multiplicity = XINT (def, 1);
4405 int simultaneity = XINT (def, 2);
4406 rtx condexp = XEXP (def, 3);
4407 int ready_cost = MAX (XINT (def, 4), 1);
4408 int issue_delay = MAX (XINT (def, 5), 1);
4409
4410 /* See if we have already seen this function unit. If so, check that
4411 the multiplicity and simultaneity values are the same. If not, make
4412 a structure for this function unit. */
4413 for (unit = units; unit; unit = unit->next)
4414 if (! strcmp (unit->name, name))
4415 {
4416 if (unit->multiplicity != multiplicity
4417 || unit->simultaneity != simultaneity)
4418 {
4419 message_with_line (lineno,
4420 "differing specifications given for function unit %s",
4421 unit->name);
4422 message_with_line (unit->first_lineno, "previous definition");
4423 have_error = 1;
4424 return;
4425 }
4426 break;
4427 }
4428
4429 if (unit == 0)
4430 {
4431 unit = (struct function_unit *) oballoc (sizeof (struct function_unit));
4432 unit->name = name;
4433 unit->multiplicity = multiplicity;
4434 unit->simultaneity = simultaneity;
4435 unit->issue_delay.min = unit->issue_delay.max = issue_delay;
4436 unit->num = num_units++;
4437 unit->num_opclasses = 0;
4438 unit->condexp = false_rtx;
4439 unit->ops = 0;
4440 unit->next = units;
4441 unit->first_lineno = lineno;
4442 units = unit;
4443 }
4444
4445 /* Make a new operation class structure entry and initialize it. */
4446 op = (struct function_unit_op *) oballoc (sizeof (struct function_unit_op));
4447 op->condexp = condexp;
4448 op->num = unit->num_opclasses++;
4449 op->ready = ready_cost;
4450 op->issue_delay = issue_delay;
4451 op->next = unit->ops;
4452 op->lineno = lineno;
4453 unit->ops = op;
4454 num_unit_opclasses++;
4455
4456 /* Set our issue expression based on whether or not an optional conflict
4457 vector was specified. */
4458 if (XVEC (def, 6))
4459 {
4460 /* Compute the IOR of all the specified expressions. */
4461 rtx orexp = false_rtx;
4462 int i;
4463
4464 for (i = 0; i < XVECLEN (def, 6); i++)
4465 orexp = insert_right_side (IOR, orexp, XVECEXP (def, 6, i), -2, -2);
4466
4467 op->conflict_exp = orexp;
4468 extend_range (&unit->issue_delay, 1, issue_delay);
4469 }
4470 else
4471 {
4472 op->conflict_exp = true_rtx;
4473 extend_range (&unit->issue_delay, issue_delay, issue_delay);
4474 }
4475
4476 /* Merge our conditional into that of the function unit so we can determine
4477 which insns are used by the function unit. */
4478 unit->condexp = insert_right_side (IOR, unit->condexp, op->condexp, -2, -2);
4479 }
4480 \f
4481 /* Given a piece of RTX, print a C expression to test its truth value.
4482 We use AND and IOR both for logical and bit-wise operations, so
4483 interpret them as logical unless they are inside a comparison expression.
4484 The first bit of FLAGS will be non-zero in that case.
4485
4486 Set the second bit of FLAGS to make references to attribute values use
4487 a cached local variable instead of calling a function. */
4488
4489 static void
4490 write_test_expr (exp, flags)
4491 rtx exp;
4492 int flags;
4493 {
4494 int comparison_operator = 0;
4495 RTX_CODE code;
4496 struct attr_desc *attr;
4497
4498 /* In order not to worry about operator precedence, surround our part of
4499 the expression with parentheses. */
4500
4501 printf ("(");
4502 code = GET_CODE (exp);
4503 switch (code)
4504 {
4505 /* Binary operators. */
4506 case EQ: case NE:
4507 case GE: case GT: case GEU: case GTU:
4508 case LE: case LT: case LEU: case LTU:
4509 comparison_operator = 1;
4510
4511 case PLUS: case MINUS: case MULT: case DIV: case MOD:
4512 case AND: case IOR: case XOR:
4513 case ASHIFT: case LSHIFTRT: case ASHIFTRT:
4514 write_test_expr (XEXP (exp, 0), flags | comparison_operator);
4515 switch (code)
4516 {
4517 case EQ:
4518 printf (" == ");
4519 break;
4520 case NE:
4521 printf (" != ");
4522 break;
4523 case GE:
4524 printf (" >= ");
4525 break;
4526 case GT:
4527 printf (" > ");
4528 break;
4529 case GEU:
4530 printf (" >= (unsigned) ");
4531 break;
4532 case GTU:
4533 printf (" > (unsigned) ");
4534 break;
4535 case LE:
4536 printf (" <= ");
4537 break;
4538 case LT:
4539 printf (" < ");
4540 break;
4541 case LEU:
4542 printf (" <= (unsigned) ");
4543 break;
4544 case LTU:
4545 printf (" < (unsigned) ");
4546 break;
4547 case PLUS:
4548 printf (" + ");
4549 break;
4550 case MINUS:
4551 printf (" - ");
4552 break;
4553 case MULT:
4554 printf (" * ");
4555 break;
4556 case DIV:
4557 printf (" / ");
4558 break;
4559 case MOD:
4560 printf (" %% ");
4561 break;
4562 case AND:
4563 if (flags & 1)
4564 printf (" & ");
4565 else
4566 printf (" && ");
4567 break;
4568 case IOR:
4569 if (flags & 1)
4570 printf (" | ");
4571 else
4572 printf (" || ");
4573 break;
4574 case XOR:
4575 printf (" ^ ");
4576 break;
4577 case ASHIFT:
4578 printf (" << ");
4579 break;
4580 case LSHIFTRT:
4581 case ASHIFTRT:
4582 printf (" >> ");
4583 break;
4584 default:
4585 abort ();
4586 }
4587
4588 write_test_expr (XEXP (exp, 1), flags | comparison_operator);
4589 break;
4590
4591 case NOT:
4592 /* Special-case (not (eq_attrq "alternative" "x")) */
4593 if (! (flags & 1) && GET_CODE (XEXP (exp, 0)) == EQ_ATTR
4594 && XSTR (XEXP (exp, 0), 0) == alternative_name)
4595 {
4596 printf ("which_alternative != %s", XSTR (XEXP (exp, 0), 1));
4597 break;
4598 }
4599
4600 /* Otherwise, fall through to normal unary operator. */
4601
4602 /* Unary operators. */
4603 case ABS: case NEG:
4604 switch (code)
4605 {
4606 case NOT:
4607 if (flags & 1)
4608 printf ("~ ");
4609 else
4610 printf ("! ");
4611 break;
4612 case ABS:
4613 printf ("abs ");
4614 break;
4615 case NEG:
4616 printf ("-");
4617 break;
4618 default:
4619 abort ();
4620 }
4621
4622 write_test_expr (XEXP (exp, 0), flags);
4623 break;
4624
4625 /* Comparison test of an attribute with a value. Most of these will
4626 have been removed by optimization. Handle "alternative"
4627 specially and give error if EQ_ATTR present inside a comparison. */
4628 case EQ_ATTR:
4629 if (flags & 1)
4630 fatal ("EQ_ATTR not valid inside comparison");
4631
4632 if (XSTR (exp, 0) == alternative_name)
4633 {
4634 printf ("which_alternative == %s", XSTR (exp, 1));
4635 break;
4636 }
4637
4638 attr = find_attr (XSTR (exp, 0), 0);
4639 if (! attr)
4640 abort ();
4641
4642 /* Now is the time to expand the value of a constant attribute. */
4643 if (attr->is_const)
4644 {
4645 write_test_expr (evaluate_eq_attr (exp, attr->default_val->value,
4646 -2, -2),
4647 flags);
4648 }
4649 else
4650 {
4651 if (flags & 2)
4652 printf ("attr_%s", attr->name);
4653 else
4654 printf ("get_attr_%s (insn)", attr->name);
4655 printf (" == ");
4656 write_attr_valueq (attr, XSTR (exp, 1));
4657 }
4658 break;
4659
4660 /* Comparison test of flags for define_delays. */
4661 case ATTR_FLAG:
4662 if (flags & 1)
4663 fatal ("ATTR_FLAG not valid inside comparison");
4664 printf ("(flags & ATTR_FLAG_%s) != 0", XSTR (exp, 0));
4665 break;
4666
4667 /* See if an operand matches a predicate. */
4668 case MATCH_OPERAND:
4669 /* If only a mode is given, just ensure the mode matches the operand.
4670 If neither a mode nor predicate is given, error. */
4671 if (XSTR (exp, 1) == NULL || *XSTR (exp, 1) == '\0')
4672 {
4673 if (GET_MODE (exp) == VOIDmode)
4674 fatal ("Null MATCH_OPERAND specified as test");
4675 else
4676 printf ("GET_MODE (operands[%d]) == %smode",
4677 XINT (exp, 0), GET_MODE_NAME (GET_MODE (exp)));
4678 }
4679 else
4680 printf ("%s (operands[%d], %smode)",
4681 XSTR (exp, 1), XINT (exp, 0), GET_MODE_NAME (GET_MODE (exp)));
4682 break;
4683
4684 case MATCH_INSN:
4685 printf ("%s (insn)", XSTR (exp, 0));
4686 break;
4687
4688 /* Constant integer. */
4689 case CONST_INT:
4690 printf (HOST_WIDE_INT_PRINT_DEC, XWINT (exp, 0));
4691 break;
4692
4693 /* A random C expression. */
4694 case SYMBOL_REF:
4695 printf ("%s", XSTR (exp, 0));
4696 break;
4697
4698 /* The address of the branch target. */
4699 case MATCH_DUP:
4700 printf ("INSN_ADDRESSES_SET_P () ? INSN_ADDRESSES (INSN_UID (GET_CODE (operands[%d]) == LABEL_REF ? XEXP (operands[%d], 0) : operands[%d])) : 0",
4701 XINT (exp, 0), XINT (exp, 0), XINT (exp, 0));
4702 break;
4703
4704 case PC:
4705 /* The address of the current insn. We implement this actually as the
4706 address of the current insn for backward branches, but the last
4707 address of the next insn for forward branches, and both with
4708 adjustments that account for the worst-case possible stretching of
4709 intervening alignments between this insn and its destination. */
4710 printf ("insn_current_reference_address (insn)");
4711 break;
4712
4713 case CONST_STRING:
4714 printf ("%s", XSTR (exp, 0));
4715 break;
4716
4717 case IF_THEN_ELSE:
4718 write_test_expr (XEXP (exp, 0), flags & 2);
4719 printf (" ? ");
4720 write_test_expr (XEXP (exp, 1), flags | 1);
4721 printf (" : ");
4722 write_test_expr (XEXP (exp, 2), flags | 1);
4723 break;
4724
4725 default:
4726 fatal ("bad RTX code `%s' in attribute calculation\n",
4727 GET_RTX_NAME (code));
4728 }
4729
4730 printf (")");
4731 }
4732 \f
4733 /* Given an attribute value, return the maximum CONST_STRING argument
4734 encountered. Set *UNKNOWNP and return INT_MAX if the value is unknown. */
4735
4736 static int
4737 max_attr_value (exp, unknownp)
4738 rtx exp;
4739 int *unknownp;
4740 {
4741 int current_max;
4742 int i, n;
4743
4744 switch (GET_CODE (exp))
4745 {
4746 case CONST_STRING:
4747 current_max = atoi (XSTR (exp, 0));
4748 break;
4749
4750 case COND:
4751 current_max = max_attr_value (XEXP (exp, 1), unknownp);
4752 for (i = 0; i < XVECLEN (exp, 0); i += 2)
4753 {
4754 n = max_attr_value (XVECEXP (exp, 0, i + 1), unknownp);
4755 if (n > current_max)
4756 current_max = n;
4757 }
4758 break;
4759
4760 case IF_THEN_ELSE:
4761 current_max = max_attr_value (XEXP (exp, 1), unknownp);
4762 n = max_attr_value (XEXP (exp, 2), unknownp);
4763 if (n > current_max)
4764 current_max = n;
4765 break;
4766
4767 default:
4768 *unknownp = 1;
4769 current_max = INT_MAX;
4770 break;
4771 }
4772
4773 return current_max;
4774 }
4775
4776 /* Given an attribute value, return the result of ORing together all
4777 CONST_STRING arguments encountered. Set *UNKNOWNP and return -1
4778 if the numeric value is not known. */
4779
4780 static int
4781 or_attr_value (exp, unknownp)
4782 rtx exp;
4783 int *unknownp;
4784 {
4785 int current_or;
4786 int i;
4787
4788 switch (GET_CODE (exp))
4789 {
4790 case CONST_STRING:
4791 current_or = atoi (XSTR (exp, 0));
4792 break;
4793
4794 case COND:
4795 current_or = or_attr_value (XEXP (exp, 1), unknownp);
4796 for (i = 0; i < XVECLEN (exp, 0); i += 2)
4797 current_or |= or_attr_value (XVECEXP (exp, 0, i + 1), unknownp);
4798 break;
4799
4800 case IF_THEN_ELSE:
4801 current_or = or_attr_value (XEXP (exp, 1), unknownp);
4802 current_or |= or_attr_value (XEXP (exp, 2), unknownp);
4803 break;
4804
4805 default:
4806 *unknownp = 1;
4807 current_or = -1;
4808 break;
4809 }
4810
4811 return current_or;
4812 }
4813 \f
4814 /* Scan an attribute value, possibly a conditional, and record what actions
4815 will be required to do any conditional tests in it.
4816
4817 Specifically, set
4818 `must_extract' if we need to extract the insn operands
4819 `must_constrain' if we must compute `which_alternative'
4820 `address_used' if an address expression was used
4821 `length_used' if an (eq_attr "length" ...) was used
4822 */
4823
4824 static void
4825 walk_attr_value (exp)
4826 rtx exp;
4827 {
4828 register int i, j;
4829 register const char *fmt;
4830 RTX_CODE code;
4831
4832 if (exp == NULL)
4833 return;
4834
4835 code = GET_CODE (exp);
4836 switch (code)
4837 {
4838 case SYMBOL_REF:
4839 if (! RTX_UNCHANGING_P (exp))
4840 /* Since this is an arbitrary expression, it can look at anything.
4841 However, constant expressions do not depend on any particular
4842 insn. */
4843 must_extract = must_constrain = 1;
4844 return;
4845
4846 case MATCH_OPERAND:
4847 must_extract = 1;
4848 return;
4849
4850 case EQ_ATTR:
4851 if (XSTR (exp, 0) == alternative_name)
4852 must_extract = must_constrain = 1;
4853 else if (strcmp (XSTR (exp, 0), "length") == 0)
4854 length_used = 1;
4855 return;
4856
4857 case MATCH_DUP:
4858 must_extract = 1;
4859 address_used = 1;
4860 return;
4861
4862 case PC:
4863 address_used = 1;
4864 return;
4865
4866 case ATTR_FLAG:
4867 return;
4868
4869 default:
4870 break;
4871 }
4872
4873 for (i = 0, fmt = GET_RTX_FORMAT (code); i < GET_RTX_LENGTH (code); i++)
4874 switch (*fmt++)
4875 {
4876 case 'e':
4877 case 'u':
4878 walk_attr_value (XEXP (exp, i));
4879 break;
4880
4881 case 'E':
4882 if (XVEC (exp, i) != NULL)
4883 for (j = 0; j < XVECLEN (exp, i); j++)
4884 walk_attr_value (XVECEXP (exp, i, j));
4885 break;
4886 }
4887 }
4888 \f
4889 /* Write out a function to obtain the attribute for a given INSN. */
4890
4891 static void
4892 write_attr_get (attr)
4893 struct attr_desc *attr;
4894 {
4895 struct attr_value *av, *common_av;
4896
4897 /* Find the most used attribute value. Handle that as the `default' of the
4898 switch we will generate. */
4899 common_av = find_most_used (attr);
4900
4901 /* Write out prototype of function. */
4902 if (!attr->is_numeric)
4903 printf ("extern enum attr_%s ", attr->name);
4904 else if (attr->unsigned_p)
4905 printf ("extern unsigned int ");
4906 else
4907 printf ("extern int ");
4908 /* If the attribute name starts with a star, the remainder is the name of
4909 the subroutine to use, instead of `get_attr_...'. */
4910 if (attr->name[0] == '*')
4911 printf ("%s PARAMS ((rtx));\n", &attr->name[1]);
4912 else
4913 printf ("get_attr_%s PARAMS ((%s));\n", attr->name,
4914 (attr->is_const ? "void" : "rtx"));
4915
4916 /* Write out start of function, then all values with explicit `case' lines,
4917 then a `default', then the value with the most uses. */
4918 if (!attr->is_numeric)
4919 printf ("enum attr_%s\n", attr->name);
4920 else if (attr->unsigned_p)
4921 printf ("unsigned int\n");
4922 else
4923 printf ("int\n");
4924
4925 /* If the attribute name starts with a star, the remainder is the name of
4926 the subroutine to use, instead of `get_attr_...'. */
4927 if (attr->name[0] == '*')
4928 printf ("%s (insn)\n", &attr->name[1]);
4929 else if (attr->is_const == 0)
4930 printf ("get_attr_%s (insn)\n", attr->name);
4931 else
4932 {
4933 printf ("get_attr_%s ()\n", attr->name);
4934 printf ("{\n");
4935
4936 for (av = attr->first_value; av; av = av->next)
4937 if (av->num_insns != 0)
4938 write_attr_set (attr, 2, av->value, "return", ";",
4939 true_rtx, av->first_insn->insn_code,
4940 av->first_insn->insn_index);
4941
4942 printf ("}\n\n");
4943 return;
4944 }
4945
4946 printf (" rtx insn;\n");
4947 printf ("{\n");
4948
4949 if (GET_CODE (common_av->value) == FFS)
4950 {
4951 rtx p = XEXP (common_av->value, 0);
4952
4953 /* No need to emit code to abort if the insn is unrecognized; the
4954 other get_attr_foo functions will do that when we call them. */
4955
4956 write_toplevel_expr (p);
4957
4958 printf ("\n if (accum && accum == (accum & -accum))\n");
4959 printf (" {\n");
4960 printf (" int i;\n");
4961 printf (" for (i = 0; accum >>= 1; ++i) continue;\n");
4962 printf (" accum = i;\n");
4963 printf (" }\n else\n");
4964 printf (" accum = ~accum;\n");
4965 printf (" return accum;\n}\n\n");
4966 }
4967 else
4968 {
4969 printf (" switch (recog_memoized (insn))\n");
4970 printf (" {\n");
4971
4972 for (av = attr->first_value; av; av = av->next)
4973 if (av != common_av)
4974 write_attr_case (attr, av, 1, "return", ";", 4, true_rtx);
4975
4976 write_attr_case (attr, common_av, 0, "return", ";", 4, true_rtx);
4977 printf (" }\n}\n\n");
4978 }
4979 }
4980 \f
4981 /* Given an AND tree of known true terms (because we are inside an `if' with
4982 that as the condition or are in an `else' clause) and an expression,
4983 replace any known true terms with TRUE. Use `simplify_and_tree' to do
4984 the bulk of the work. */
4985
4986 static rtx
4987 eliminate_known_true (known_true, exp, insn_code, insn_index)
4988 rtx known_true;
4989 rtx exp;
4990 int insn_code, insn_index;
4991 {
4992 rtx term;
4993
4994 known_true = SIMPLIFY_TEST_EXP (known_true, insn_code, insn_index);
4995
4996 if (GET_CODE (known_true) == AND)
4997 {
4998 exp = eliminate_known_true (XEXP (known_true, 0), exp,
4999 insn_code, insn_index);
5000 exp = eliminate_known_true (XEXP (known_true, 1), exp,
5001 insn_code, insn_index);
5002 }
5003 else
5004 {
5005 term = known_true;
5006 exp = simplify_and_tree (exp, &term, insn_code, insn_index);
5007 }
5008
5009 return exp;
5010 }
5011 \f
5012 /* Write out a series of tests and assignment statements to perform tests and
5013 sets of an attribute value. We are passed an indentation amount and prefix
5014 and suffix strings to write around each attribute value (e.g., "return"
5015 and ";"). */
5016
5017 static void
5018 write_attr_set (attr, indent, value, prefix, suffix, known_true,
5019 insn_code, insn_index)
5020 struct attr_desc *attr;
5021 int indent;
5022 rtx value;
5023 const char *prefix;
5024 const char *suffix;
5025 rtx known_true;
5026 int insn_code, insn_index;
5027 {
5028 if (GET_CODE (value) == COND)
5029 {
5030 /* Assume the default value will be the default of the COND unless we
5031 find an always true expression. */
5032 rtx default_val = XEXP (value, 1);
5033 rtx our_known_true = known_true;
5034 rtx newexp;
5035 int first_if = 1;
5036 int i;
5037
5038 for (i = 0; i < XVECLEN (value, 0); i += 2)
5039 {
5040 rtx testexp;
5041 rtx inner_true;
5042
5043 testexp = eliminate_known_true (our_known_true,
5044 XVECEXP (value, 0, i),
5045 insn_code, insn_index);
5046 newexp = attr_rtx (NOT, testexp);
5047 newexp = insert_right_side (AND, our_known_true, newexp,
5048 insn_code, insn_index);
5049
5050 /* If the test expression is always true or if the next `known_true'
5051 expression is always false, this is the last case, so break
5052 out and let this value be the `else' case. */
5053 if (testexp == true_rtx || newexp == false_rtx)
5054 {
5055 default_val = XVECEXP (value, 0, i + 1);
5056 break;
5057 }
5058
5059 /* Compute the expression to pass to our recursive call as being
5060 known true. */
5061 inner_true = insert_right_side (AND, our_known_true,
5062 testexp, insn_code, insn_index);
5063
5064 /* If this is always false, skip it. */
5065 if (inner_true == false_rtx)
5066 continue;
5067
5068 write_indent (indent);
5069 printf ("%sif ", first_if ? "" : "else ");
5070 first_if = 0;
5071 write_test_expr (testexp, 0);
5072 printf ("\n");
5073 write_indent (indent + 2);
5074 printf ("{\n");
5075
5076 write_attr_set (attr, indent + 4,
5077 XVECEXP (value, 0, i + 1), prefix, suffix,
5078 inner_true, insn_code, insn_index);
5079 write_indent (indent + 2);
5080 printf ("}\n");
5081 our_known_true = newexp;
5082 }
5083
5084 if (! first_if)
5085 {
5086 write_indent (indent);
5087 printf ("else\n");
5088 write_indent (indent + 2);
5089 printf ("{\n");
5090 }
5091
5092 write_attr_set (attr, first_if ? indent : indent + 4, default_val,
5093 prefix, suffix, our_known_true, insn_code, insn_index);
5094
5095 if (! first_if)
5096 {
5097 write_indent (indent + 2);
5098 printf ("}\n");
5099 }
5100 }
5101 else
5102 {
5103 write_indent (indent);
5104 printf ("%s ", prefix);
5105 write_attr_value (attr, value);
5106 printf ("%s\n", suffix);
5107 }
5108 }
5109 \f
5110 /* Write out the computation for one attribute value. */
5111
5112 static void
5113 write_attr_case (attr, av, write_case_lines, prefix, suffix, indent,
5114 known_true)
5115 struct attr_desc *attr;
5116 struct attr_value *av;
5117 int write_case_lines;
5118 const char *prefix, *suffix;
5119 int indent;
5120 rtx known_true;
5121 {
5122 struct insn_ent *ie;
5123
5124 if (av->num_insns == 0)
5125 return;
5126
5127 if (av->has_asm_insn)
5128 {
5129 write_indent (indent);
5130 printf ("case -1:\n");
5131 write_indent (indent + 2);
5132 printf ("if (GET_CODE (PATTERN (insn)) != ASM_INPUT\n");
5133 write_indent (indent + 2);
5134 printf (" && asm_noperands (PATTERN (insn)) < 0)\n");
5135 write_indent (indent + 2);
5136 printf (" fatal_insn_not_found (insn);\n");
5137 }
5138
5139 if (write_case_lines)
5140 {
5141 for (ie = av->first_insn; ie; ie = ie->next)
5142 if (ie->insn_code != -1)
5143 {
5144 write_indent (indent);
5145 printf ("case %d:\n", ie->insn_code);
5146 }
5147 }
5148 else
5149 {
5150 write_indent (indent);
5151 printf ("default:\n");
5152 }
5153
5154 /* See what we have to do to output this value. */
5155 must_extract = must_constrain = address_used = 0;
5156 walk_attr_value (av->value);
5157
5158 if (must_constrain)
5159 {
5160 write_indent (indent + 2);
5161 printf ("extract_constrain_insn_cached (insn);\n");
5162 }
5163 else if (must_extract)
5164 {
5165 write_indent (indent + 2);
5166 printf ("extract_insn_cached (insn);\n");
5167 }
5168
5169 write_attr_set (attr, indent + 2, av->value, prefix, suffix,
5170 known_true, av->first_insn->insn_code,
5171 av->first_insn->insn_index);
5172
5173 if (strncmp (prefix, "return", 6))
5174 {
5175 write_indent (indent + 2);
5176 printf ("break;\n");
5177 }
5178 printf ("\n");
5179 }
5180 \f
5181 /* Search for uses of non-const attributes and write code to cache them. */
5182
5183 static int
5184 write_expr_attr_cache (p, attr)
5185 rtx p;
5186 struct attr_desc *attr;
5187 {
5188 const char *fmt;
5189 int i, ie, j, je;
5190
5191 if (GET_CODE (p) == EQ_ATTR)
5192 {
5193 if (XSTR (p, 0) != attr->name)
5194 return 0;
5195
5196 if (!attr->is_numeric)
5197 printf (" register enum attr_%s ", attr->name);
5198 else if (attr->unsigned_p)
5199 printf (" register unsigned int ");
5200 else
5201 printf (" register int ");
5202
5203 printf ("attr_%s = get_attr_%s (insn);\n", attr->name, attr->name);
5204 return 1;
5205 }
5206
5207 fmt = GET_RTX_FORMAT (GET_CODE (p));
5208 ie = GET_RTX_LENGTH (GET_CODE (p));
5209 for (i = 0; i < ie; i++)
5210 {
5211 switch (*fmt++)
5212 {
5213 case 'e':
5214 if (write_expr_attr_cache (XEXP (p, i), attr))
5215 return 1;
5216 break;
5217
5218 case 'E':
5219 je = XVECLEN (p, i);
5220 for (j = 0; j < je; ++j)
5221 if (write_expr_attr_cache (XVECEXP (p, i, j), attr))
5222 return 1;
5223 break;
5224 }
5225 }
5226
5227 return 0;
5228 }
5229
5230 /* Evaluate an expression at top level. A front end to write_test_expr,
5231 in which we cache attribute values and break up excessively large
5232 expressions to cater to older compilers. */
5233
5234 static void
5235 write_toplevel_expr (p)
5236 rtx p;
5237 {
5238 struct attr_desc *attr;
5239 int i;
5240
5241 for (i = 0; i < MAX_ATTRS_INDEX; ++i)
5242 for (attr = attrs[i]; attr; attr = attr->next)
5243 if (!attr->is_const)
5244 write_expr_attr_cache (p, attr);
5245
5246 printf (" register unsigned long accum = 0;\n\n");
5247
5248 while (GET_CODE (p) == IOR)
5249 {
5250 rtx e;
5251 if (GET_CODE (XEXP (p, 0)) == IOR)
5252 e = XEXP (p, 1), p = XEXP (p, 0);
5253 else
5254 e = XEXP (p, 0), p = XEXP (p, 1);
5255
5256 printf (" accum |= ");
5257 write_test_expr (e, 3);
5258 printf (";\n");
5259 }
5260 printf (" accum |= ");
5261 write_test_expr (p, 3);
5262 printf (";\n");
5263 }
5264 \f
5265 /* Utilities to write names in various forms. */
5266
5267 static void
5268 write_unit_name (prefix, num, suffix)
5269 const char *prefix;
5270 int num;
5271 const char *suffix;
5272 {
5273 struct function_unit *unit;
5274
5275 for (unit = units; unit; unit = unit->next)
5276 if (unit->num == num)
5277 {
5278 printf ("%s%s%s", prefix, unit->name, suffix);
5279 return;
5280 }
5281
5282 printf ("%s<unknown>%s", prefix, suffix);
5283 }
5284
5285 static void
5286 write_attr_valueq (attr, s)
5287 struct attr_desc *attr;
5288 const char *s;
5289 {
5290 if (attr->is_numeric)
5291 {
5292 int num = atoi (s);
5293
5294 printf ("%d", num);
5295
5296 /* Make the blockage range values and function units used values easier
5297 to read. */
5298 if (attr->func_units_p)
5299 {
5300 if (num == -1)
5301 printf (" /* units: none */");
5302 else if (num >= 0)
5303 write_unit_name (" /* units: ", num, " */");
5304 else
5305 {
5306 int i;
5307 const char *sep = " /* units: ";
5308 for (i = 0, num = ~num; num; i++, num >>= 1)
5309 if (num & 1)
5310 {
5311 write_unit_name (sep, i, (num == 1) ? " */" : "");
5312 sep = ", ";
5313 }
5314 }
5315 }
5316
5317 else if (attr->blockage_p)
5318 printf (" /* min %d, max %d */", num >> (HOST_BITS_PER_INT / 2),
5319 num & ((1 << (HOST_BITS_PER_INT / 2)) - 1));
5320
5321 else if (num > 9 || num < 0)
5322 printf (" /* 0x%x */", num);
5323 }
5324 else
5325 {
5326 write_upcase (attr->name);
5327 printf ("_");
5328 write_upcase (s);
5329 }
5330 }
5331
5332 static void
5333 write_attr_value (attr, value)
5334 struct attr_desc *attr;
5335 rtx value;
5336 {
5337 int op;
5338
5339 switch (GET_CODE (value))
5340 {
5341 case CONST_STRING:
5342 write_attr_valueq (attr, XSTR (value, 0));
5343 break;
5344
5345 case CONST_INT:
5346 printf (HOST_WIDE_INT_PRINT_DEC, INTVAL (value));
5347 break;
5348
5349 case SYMBOL_REF:
5350 fputs (XSTR (value, 0), stdout);
5351 break;
5352
5353 case ATTR:
5354 {
5355 struct attr_desc *attr2 = find_attr (XSTR (value, 0), 0);
5356 printf ("get_attr_%s (%s)", attr2->name,
5357 (attr2->is_const ? "" : "insn"));
5358 }
5359 break;
5360
5361 case PLUS:
5362 op = '+';
5363 goto do_operator;
5364 case MINUS:
5365 op = '-';
5366 goto do_operator;
5367 case MULT:
5368 op = '*';
5369 goto do_operator;
5370 case DIV:
5371 op = '/';
5372 goto do_operator;
5373 case MOD:
5374 op = '%';
5375 goto do_operator;
5376
5377 do_operator:
5378 write_attr_value (attr, XEXP (value, 0));
5379 putchar (' ');
5380 putchar (op);
5381 putchar (' ');
5382 write_attr_value (attr, XEXP (value, 1));
5383 break;
5384
5385 default:
5386 abort ();
5387 }
5388 }
5389
5390 static void
5391 write_upcase (str)
5392 const char *str;
5393 {
5394 while (*str)
5395 {
5396 /* The argument of TOUPPER should not have side effects. */
5397 putchar (TOUPPER(*str));
5398 str++;
5399 }
5400 }
5401
5402 static void
5403 write_indent (indent)
5404 int indent;
5405 {
5406 for (; indent > 8; indent -= 8)
5407 printf ("\t");
5408
5409 for (; indent; indent--)
5410 printf (" ");
5411 }
5412 \f
5413 /* Write a subroutine that is given an insn that requires a delay slot, a
5414 delay slot ordinal, and a candidate insn. It returns non-zero if the
5415 candidate can be placed in the specified delay slot of the insn.
5416
5417 We can write as many as three subroutines. `eligible_for_delay'
5418 handles normal delay slots, `eligible_for_annul_true' indicates that
5419 the specified insn can be annulled if the branch is true, and likewise
5420 for `eligible_for_annul_false'.
5421
5422 KIND is a string distinguishing these three cases ("delay", "annul_true",
5423 or "annul_false"). */
5424
5425 static void
5426 write_eligible_delay (kind)
5427 const char *kind;
5428 {
5429 struct delay_desc *delay;
5430 int max_slots;
5431 char str[50];
5432 struct attr_desc *attr;
5433 struct attr_value *av, *common_av;
5434 int i;
5435
5436 /* Compute the maximum number of delay slots required. We use the delay
5437 ordinal times this number plus one, plus the slot number as an index into
5438 the appropriate predicate to test. */
5439
5440 for (delay = delays, max_slots = 0; delay; delay = delay->next)
5441 if (XVECLEN (delay->def, 1) / 3 > max_slots)
5442 max_slots = XVECLEN (delay->def, 1) / 3;
5443
5444 /* Write function prelude. */
5445
5446 printf ("int\n");
5447 printf ("eligible_for_%s (delay_insn, slot, candidate_insn, flags)\n",
5448 kind);
5449 printf (" rtx delay_insn;\n");
5450 printf (" int slot;\n");
5451 printf (" rtx candidate_insn;\n");
5452 printf (" int flags ATTRIBUTE_UNUSED;\n");
5453 printf ("{\n");
5454 printf (" rtx insn;\n");
5455 printf ("\n");
5456 printf (" if (slot >= %d)\n", max_slots);
5457 printf (" abort ();\n");
5458 printf ("\n");
5459
5460 /* If more than one delay type, find out which type the delay insn is. */
5461
5462 if (num_delays > 1)
5463 {
5464 attr = find_attr ("*delay_type", 0);
5465 if (! attr)
5466 abort ();
5467 common_av = find_most_used (attr);
5468
5469 printf (" insn = delay_insn;\n");
5470 printf (" switch (recog_memoized (insn))\n");
5471 printf (" {\n");
5472
5473 sprintf (str, " * %d;\n break;", max_slots);
5474 for (av = attr->first_value; av; av = av->next)
5475 if (av != common_av)
5476 write_attr_case (attr, av, 1, "slot +=", str, 4, true_rtx);
5477
5478 write_attr_case (attr, common_av, 0, "slot +=", str, 4, true_rtx);
5479 printf (" }\n\n");
5480
5481 /* Ensure matched. Otherwise, shouldn't have been called. */
5482 printf (" if (slot < %d)\n", max_slots);
5483 printf (" abort ();\n\n");
5484 }
5485
5486 /* If just one type of delay slot, write simple switch. */
5487 if (num_delays == 1 && max_slots == 1)
5488 {
5489 printf (" insn = candidate_insn;\n");
5490 printf (" switch (recog_memoized (insn))\n");
5491 printf (" {\n");
5492
5493 attr = find_attr ("*delay_1_0", 0);
5494 if (! attr)
5495 abort ();
5496 common_av = find_most_used (attr);
5497
5498 for (av = attr->first_value; av; av = av->next)
5499 if (av != common_av)
5500 write_attr_case (attr, av, 1, "return", ";", 4, true_rtx);
5501
5502 write_attr_case (attr, common_av, 0, "return", ";", 4, true_rtx);
5503 printf (" }\n");
5504 }
5505
5506 else
5507 {
5508 /* Write a nested CASE. The first indicates which condition we need to
5509 test, and the inner CASE tests the condition. */
5510 printf (" insn = candidate_insn;\n");
5511 printf (" switch (slot)\n");
5512 printf (" {\n");
5513
5514 for (delay = delays; delay; delay = delay->next)
5515 for (i = 0; i < XVECLEN (delay->def, 1); i += 3)
5516 {
5517 printf (" case %d:\n",
5518 (i / 3) + (num_delays == 1 ? 0 : delay->num * max_slots));
5519 printf (" switch (recog_memoized (insn))\n");
5520 printf ("\t{\n");
5521
5522 sprintf (str, "*%s_%d_%d", kind, delay->num, i / 3);
5523 attr = find_attr (str, 0);
5524 if (! attr)
5525 abort ();
5526 common_av = find_most_used (attr);
5527
5528 for (av = attr->first_value; av; av = av->next)
5529 if (av != common_av)
5530 write_attr_case (attr, av, 1, "return", ";", 8, true_rtx);
5531
5532 write_attr_case (attr, common_av, 0, "return", ";", 8, true_rtx);
5533 printf (" }\n");
5534 }
5535
5536 printf (" default:\n");
5537 printf (" abort ();\n");
5538 printf (" }\n");
5539 }
5540
5541 printf ("}\n\n");
5542 }
5543 \f
5544 /* Write routines to compute conflict cost for function units. Then write a
5545 table describing the available function units. */
5546
5547 static void
5548 write_function_unit_info ()
5549 {
5550 struct function_unit *unit;
5551 int i;
5552
5553 /* Write out conflict routines for function units. Don't bother writing
5554 one if there is only one issue delay value. */
5555
5556 for (unit = units; unit; unit = unit->next)
5557 {
5558 if (unit->needs_blockage_function)
5559 write_complex_function (unit, "blockage", "block");
5560
5561 /* If the minimum and maximum conflict costs are the same, there
5562 is only one value, so we don't need a function. */
5563 if (! unit->needs_conflict_function)
5564 {
5565 unit->default_cost = make_numeric_value (unit->issue_delay.max);
5566 continue;
5567 }
5568
5569 /* The function first computes the case from the candidate insn. */
5570 unit->default_cost = make_numeric_value (0);
5571 write_complex_function (unit, "conflict_cost", "cost");
5572 }
5573
5574 /* Now that all functions have been written, write the table describing
5575 the function units. The name is included for documentation purposes
5576 only. */
5577
5578 printf ("struct function_unit_desc function_units[] = {\n");
5579
5580 /* Write out the descriptions in numeric order, but don't force that order
5581 on the list. Doing so increases the runtime of genattrtab.c. */
5582 for (i = 0; i < num_units; i++)
5583 {
5584 for (unit = units; unit; unit = unit->next)
5585 if (unit->num == i)
5586 break;
5587
5588 printf (" {\"%s\", %d, %d, %d, %s, %d, %s_unit_ready_cost, ",
5589 unit->name, 1 << unit->num, unit->multiplicity,
5590 unit->simultaneity, XSTR (unit->default_cost, 0),
5591 unit->issue_delay.max, unit->name);
5592
5593 if (unit->needs_conflict_function)
5594 printf ("%s_unit_conflict_cost, ", unit->name);
5595 else
5596 printf ("0, ");
5597
5598 printf ("%d, ", unit->max_blockage);
5599
5600 if (unit->needs_range_function)
5601 printf ("%s_unit_blockage_range, ", unit->name);
5602 else
5603 printf ("0, ");
5604
5605 if (unit->needs_blockage_function)
5606 printf ("%s_unit_blockage", unit->name);
5607 else
5608 printf ("0");
5609
5610 printf ("}, \n");
5611 }
5612
5613 printf ("};\n\n");
5614 }
5615
5616 static void
5617 write_complex_function (unit, name, connection)
5618 struct function_unit *unit;
5619 const char *name, *connection;
5620 {
5621 struct attr_desc *case_attr, *attr;
5622 struct attr_value *av, *common_av;
5623 rtx value;
5624 char *str;
5625 int using_case;
5626 int i;
5627
5628 printf ("static int %s_unit_%s PARAMS ((rtx, rtx));\n", unit->name, name);
5629 printf ("static int\n");
5630 printf ("%s_unit_%s (executing_insn, candidate_insn)\n", unit->name, name);
5631 printf (" rtx executing_insn;\n");
5632 printf (" rtx candidate_insn;\n");
5633 printf ("{\n");
5634 printf (" rtx insn;\n");
5635 printf (" int casenum;\n\n");
5636 printf (" insn = executing_insn;\n");
5637 printf (" switch (recog_memoized (insn))\n");
5638 printf (" {\n");
5639
5640 /* Write the `switch' statement to get the case value. */
5641 str = (char *) alloca (strlen (unit->name) + strlen (name) + strlen (connection) + 10);
5642 sprintf (str, "*%s_cases", unit->name);
5643 case_attr = find_attr (str, 0);
5644 if (! case_attr)
5645 abort ();
5646 common_av = find_most_used (case_attr);
5647
5648 for (av = case_attr->first_value; av; av = av->next)
5649 if (av != common_av)
5650 write_attr_case (case_attr, av, 1,
5651 "casenum =", ";", 4, unit->condexp);
5652
5653 write_attr_case (case_attr, common_av, 0,
5654 "casenum =", ";", 4, unit->condexp);
5655 printf (" }\n\n");
5656
5657 /* Now write an outer switch statement on each case. Then write
5658 the tests on the executing function within each. */
5659 printf (" insn = candidate_insn;\n");
5660 printf (" switch (casenum)\n");
5661 printf (" {\n");
5662
5663 for (i = 0; i < unit->num_opclasses; i++)
5664 {
5665 /* Ensure using this case. */
5666 using_case = 0;
5667 for (av = case_attr->first_value; av; av = av->next)
5668 if (av->num_insns
5669 && contained_in_p (make_numeric_value (i), av->value))
5670 using_case = 1;
5671
5672 if (! using_case)
5673 continue;
5674
5675 printf (" case %d:\n", i);
5676 sprintf (str, "*%s_%s_%d", unit->name, connection, i);
5677 attr = find_attr (str, 0);
5678 if (! attr)
5679 abort ();
5680
5681 /* If single value, just write it. */
5682 value = find_single_value (attr);
5683 if (value)
5684 write_attr_set (attr, 6, value, "return", ";\n", true_rtx, -2, -2);
5685 else
5686 {
5687 common_av = find_most_used (attr);
5688 printf (" switch (recog_memoized (insn))\n");
5689 printf ("\t{\n");
5690
5691 for (av = attr->first_value; av; av = av->next)
5692 if (av != common_av)
5693 write_attr_case (attr, av, 1,
5694 "return", ";", 8, unit->condexp);
5695
5696 write_attr_case (attr, common_av, 0,
5697 "return", ";", 8, unit->condexp);
5698 printf (" }\n\n");
5699 }
5700 }
5701
5702 /* This default case should not be needed, but gcc's analysis is not
5703 good enough to realize that the default case is not needed for the
5704 second switch statement. */
5705 printf (" default:\n abort ();\n");
5706 printf (" }\n}\n\n");
5707 }
5708 \f
5709 /* This page contains miscellaneous utility routines. */
5710
5711 /* Given a string, return the number of comma-separated elements in it.
5712 Return 0 for the null string. */
5713
5714 static int
5715 n_comma_elts (s)
5716 const char *s;
5717 {
5718 int n;
5719
5720 if (*s == '\0')
5721 return 0;
5722
5723 for (n = 1; *s; s++)
5724 if (*s == ',')
5725 n++;
5726
5727 return n;
5728 }
5729
5730 /* Given a pointer to a (char *), return a malloc'ed string containing the
5731 next comma-separated element. Advance the pointer to after the string
5732 scanned, or the end-of-string. Return NULL if at end of string. */
5733
5734 static char *
5735 next_comma_elt (pstr)
5736 const char **pstr;
5737 {
5738 char *out_str;
5739 const char *p;
5740
5741 if (**pstr == '\0')
5742 return NULL;
5743
5744 /* Find end of string to compute length. */
5745 for (p = *pstr; *p != ',' && *p != '\0'; p++)
5746 ;
5747
5748 out_str = attr_string (*pstr, p - *pstr);
5749 *pstr = p;
5750
5751 if (**pstr == ',')
5752 (*pstr)++;
5753
5754 return out_str;
5755 }
5756
5757 /* Return a `struct attr_desc' pointer for a given named attribute. If CREATE
5758 is non-zero, build a new attribute, if one does not exist. */
5759
5760 static struct attr_desc *
5761 find_attr (name, create)
5762 const char *name;
5763 int create;
5764 {
5765 struct attr_desc *attr;
5766 int index;
5767
5768 /* Before we resort to using `strcmp', see if the string address matches
5769 anywhere. In most cases, it should have been canonicalized to do so. */
5770 if (name == alternative_name)
5771 return NULL;
5772
5773 index = name[0] & (MAX_ATTRS_INDEX - 1);
5774 for (attr = attrs[index]; attr; attr = attr->next)
5775 if (name == attr->name)
5776 return attr;
5777
5778 /* Otherwise, do it the slow way. */
5779 for (attr = attrs[index]; attr; attr = attr->next)
5780 if (name[0] == attr->name[0] && ! strcmp (name, attr->name))
5781 return attr;
5782
5783 if (! create)
5784 return NULL;
5785
5786 attr = (struct attr_desc *) oballoc (sizeof (struct attr_desc));
5787 attr->name = attr_string (name, strlen (name));
5788 attr->first_value = attr->default_val = NULL;
5789 attr->is_numeric = attr->negative_ok = attr->is_const = attr->is_special = 0;
5790 attr->unsigned_p = attr->func_units_p = attr->blockage_p = 0;
5791 attr->next = attrs[index];
5792 attrs[index] = attr;
5793
5794 return attr;
5795 }
5796
5797 /* Create internal attribute with the given default value. */
5798
5799 static void
5800 make_internal_attr (name, value, special)
5801 const char *name;
5802 rtx value;
5803 int special;
5804 {
5805 struct attr_desc *attr;
5806
5807 attr = find_attr (name, 1);
5808 if (attr->default_val)
5809 abort ();
5810
5811 attr->is_numeric = 1;
5812 attr->is_const = 0;
5813 attr->is_special = (special & 1) != 0;
5814 attr->negative_ok = (special & 2) != 0;
5815 attr->unsigned_p = (special & 4) != 0;
5816 attr->func_units_p = (special & 8) != 0;
5817 attr->blockage_p = (special & 16) != 0;
5818 attr->default_val = get_attr_value (value, attr, -2);
5819 }
5820
5821 /* Find the most used value of an attribute. */
5822
5823 static struct attr_value *
5824 find_most_used (attr)
5825 struct attr_desc *attr;
5826 {
5827 struct attr_value *av;
5828 struct attr_value *most_used;
5829 int nuses;
5830
5831 most_used = NULL;
5832 nuses = -1;
5833
5834 for (av = attr->first_value; av; av = av->next)
5835 if (av->num_insns > nuses)
5836 nuses = av->num_insns, most_used = av;
5837
5838 return most_used;
5839 }
5840
5841 /* If an attribute only has a single value used, return it. Otherwise
5842 return NULL. */
5843
5844 static rtx
5845 find_single_value (attr)
5846 struct attr_desc *attr;
5847 {
5848 struct attr_value *av;
5849 rtx unique_value;
5850
5851 unique_value = NULL;
5852 for (av = attr->first_value; av; av = av->next)
5853 if (av->num_insns)
5854 {
5855 if (unique_value)
5856 return NULL;
5857 else
5858 unique_value = av->value;
5859 }
5860
5861 return unique_value;
5862 }
5863
5864 /* Return (attr_value "n") */
5865
5866 static rtx
5867 make_numeric_value (n)
5868 int n;
5869 {
5870 static rtx int_values[20];
5871 rtx exp;
5872 char *p;
5873
5874 if (n < 0)
5875 abort ();
5876
5877 if (n < 20 && int_values[n])
5878 return int_values[n];
5879
5880 p = attr_printf (MAX_DIGITS, "%d", n);
5881 exp = attr_rtx (CONST_STRING, p);
5882
5883 if (n < 20)
5884 int_values[n] = exp;
5885
5886 return exp;
5887 }
5888 \f
5889 static void
5890 extend_range (range, min, max)
5891 struct range *range;
5892 int min;
5893 int max;
5894 {
5895 if (range->min > min)
5896 range->min = min;
5897 if (range->max < max)
5898 range->max = max;
5899 }
5900
5901 static rtx
5902 copy_rtx_unchanging (orig)
5903 register rtx orig;
5904 {
5905 #if 0
5906 register rtx copy;
5907 register RTX_CODE code;
5908 #endif
5909
5910 if (RTX_UNCHANGING_P (orig) || MEM_IN_STRUCT_P (orig))
5911 return orig;
5912
5913 MEM_IN_STRUCT_P (orig) = 1;
5914 return orig;
5915
5916 #if 0
5917 code = GET_CODE (orig);
5918 switch (code)
5919 {
5920 case CONST_INT:
5921 case CONST_DOUBLE:
5922 case SYMBOL_REF:
5923 case CODE_LABEL:
5924 return orig;
5925
5926 default:
5927 break;
5928 }
5929
5930 copy = rtx_alloc (code);
5931 PUT_MODE (copy, GET_MODE (orig));
5932 RTX_UNCHANGING_P (copy) = 1;
5933
5934 bcopy ((char *) &XEXP (orig, 0), (char *) &XEXP (copy, 0),
5935 GET_RTX_LENGTH (GET_CODE (copy)) * sizeof (rtx));
5936 return copy;
5937 #endif
5938 }
5939
5940 /* Determine if an insn has a constant number of delay slots, i.e., the
5941 number of delay slots is not a function of the length of the insn. */
5942
5943 static void
5944 write_const_num_delay_slots ()
5945 {
5946 struct attr_desc *attr = find_attr ("*num_delay_slots", 0);
5947 struct attr_value *av;
5948 struct insn_ent *ie;
5949
5950 if (attr)
5951 {
5952 printf ("int\nconst_num_delay_slots (insn)\n");
5953 printf (" rtx insn;\n");
5954 printf ("{\n");
5955 printf (" switch (recog_memoized (insn))\n");
5956 printf (" {\n");
5957
5958 for (av = attr->first_value; av; av = av->next)
5959 {
5960 length_used = 0;
5961 walk_attr_value (av->value);
5962 if (length_used)
5963 {
5964 for (ie = av->first_insn; ie; ie = ie->next)
5965 if (ie->insn_code != -1)
5966 printf (" case %d:\n", ie->insn_code);
5967 printf (" return 0;\n");
5968 }
5969 }
5970
5971 printf (" default:\n");
5972 printf (" return 1;\n");
5973 printf (" }\n}\n\n");
5974 }
5975 }
5976 \f
5977 extern int main PARAMS ((int, char **));
5978
5979 int
5980 main (argc, argv)
5981 int argc;
5982 char **argv;
5983 {
5984 rtx desc;
5985 struct attr_desc *attr;
5986 struct insn_def *id;
5987 rtx tem;
5988 int i;
5989
5990 progname = "genattrtab";
5991
5992 if (argc <= 1)
5993 fatal ("No input file name.");
5994
5995 #if defined (RLIMIT_STACK) && defined (HAVE_GETRLIMIT) && defined (HAVE_SETRLIMIT)
5996 /* Get rid of any avoidable limit on stack size. */
5997 {
5998 struct rlimit rlim;
5999
6000 /* Set the stack limit huge so that alloca does not fail. */
6001 getrlimit (RLIMIT_STACK, &rlim);
6002 rlim.rlim_cur = rlim.rlim_max;
6003 setrlimit (RLIMIT_STACK, &rlim);
6004 }
6005 #endif
6006
6007 if (init_md_reader (argv[1]) != SUCCESS_EXIT_CODE)
6008 return (FATAL_EXIT_CODE);
6009
6010 obstack_init (hash_obstack);
6011 obstack_init (temp_obstack);
6012
6013 /* Set up true and false rtx's */
6014 true_rtx = rtx_alloc (CONST_INT);
6015 XWINT (true_rtx, 0) = 1;
6016 false_rtx = rtx_alloc (CONST_INT);
6017 XWINT (false_rtx, 0) = 0;
6018 RTX_UNCHANGING_P (true_rtx) = RTX_UNCHANGING_P (false_rtx) = 1;
6019 RTX_INTEGRATED_P (true_rtx) = RTX_INTEGRATED_P (false_rtx) = 1;
6020
6021 alternative_name = attr_string ("alternative", strlen ("alternative"));
6022
6023 printf ("/* Generated automatically by the program `genattrtab'\n\
6024 from the machine description file `md'. */\n\n");
6025
6026 /* Read the machine description. */
6027
6028 while (1)
6029 {
6030 int lineno;
6031
6032 desc = read_md_rtx (&lineno, &insn_code_number);
6033 if (desc == NULL)
6034 break;
6035
6036 switch (GET_CODE (desc))
6037 {
6038 case DEFINE_INSN:
6039 case DEFINE_PEEPHOLE:
6040 case DEFINE_ASM_ATTRIBUTES:
6041 gen_insn (desc, lineno);
6042 break;
6043
6044 case DEFINE_ATTR:
6045 gen_attr (desc, lineno);
6046 break;
6047
6048 case DEFINE_DELAY:
6049 gen_delay (desc, lineno);
6050 break;
6051
6052 case DEFINE_FUNCTION_UNIT:
6053 gen_unit (desc, lineno);
6054 break;
6055
6056 default:
6057 break;
6058 }
6059 if (GET_CODE (desc) != DEFINE_ASM_ATTRIBUTES)
6060 insn_index_number++;
6061 }
6062
6063 if (have_error)
6064 return FATAL_EXIT_CODE;
6065
6066 insn_code_number++;
6067
6068 /* If we didn't have a DEFINE_ASM_ATTRIBUTES, make a null one. */
6069 if (! got_define_asm_attributes)
6070 {
6071 tem = rtx_alloc (DEFINE_ASM_ATTRIBUTES);
6072 XVEC (tem, 0) = rtvec_alloc (0);
6073 gen_insn (tem, 0);
6074 }
6075
6076 /* Expand DEFINE_DELAY information into new attribute. */
6077 if (num_delays)
6078 expand_delays ();
6079
6080 /* Expand DEFINE_FUNCTION_UNIT information into new attributes. */
6081 if (num_units)
6082 expand_units ();
6083
6084 printf ("#include \"config.h\"\n");
6085 printf ("#include \"system.h\"\n");
6086 printf ("#include \"rtl.h\"\n");
6087 printf ("#include \"tm_p.h\"\n");
6088 printf ("#include \"insn-config.h\"\n");
6089 printf ("#include \"recog.h\"\n");
6090 printf ("#include \"regs.h\"\n");
6091 printf ("#include \"real.h\"\n");
6092 printf ("#include \"output.h\"\n");
6093 printf ("#include \"insn-attr.h\"\n");
6094 printf ("#include \"toplev.h\"\n");
6095 printf ("\n");
6096 printf ("#define operands recog_data.operand\n\n");
6097
6098 /* Make `insn_alternatives'. */
6099 insn_alternatives = (int *) oballoc (insn_code_number * sizeof (int));
6100 for (id = defs; id; id = id->next)
6101 if (id->insn_code >= 0)
6102 insn_alternatives[id->insn_code] = (1 << id->num_alternatives) - 1;
6103
6104 /* Make `insn_n_alternatives'. */
6105 insn_n_alternatives = (int *) oballoc (insn_code_number * sizeof (int));
6106 for (id = defs; id; id = id->next)
6107 if (id->insn_code >= 0)
6108 insn_n_alternatives[id->insn_code] = id->num_alternatives;
6109
6110 /* Prepare to write out attribute subroutines by checking everything stored
6111 away and building the attribute cases. */
6112
6113 check_defs ();
6114
6115 for (i = 0; i < MAX_ATTRS_INDEX; i++)
6116 for (attr = attrs[i]; attr; attr = attr->next)
6117 attr->default_val->value
6118 = check_attr_value (attr->default_val->value, attr);
6119
6120 if (have_error)
6121 return FATAL_EXIT_CODE;
6122
6123 for (i = 0; i < MAX_ATTRS_INDEX; i++)
6124 for (attr = attrs[i]; attr; attr = attr->next)
6125 fill_attr (attr);
6126
6127 /* Construct extra attributes for `length'. */
6128 make_length_attrs ();
6129
6130 /* Perform any possible optimizations to speed up compilation. */
6131 optimize_attrs ();
6132
6133 /* Now write out all the `gen_attr_...' routines. Do these before the
6134 special routines (specifically before write_function_unit_info), so
6135 that they get defined before they are used. */
6136
6137 for (i = 0; i < MAX_ATTRS_INDEX; i++)
6138 for (attr = attrs[i]; attr; attr = attr->next)
6139 {
6140 if (! attr->is_special && ! attr->is_const)
6141 write_attr_get (attr);
6142 }
6143
6144 /* Write out delay eligibility information, if DEFINE_DELAY present.
6145 (The function to compute the number of delay slots will be written
6146 below.) */
6147 if (num_delays)
6148 {
6149 write_eligible_delay ("delay");
6150 if (have_annul_true)
6151 write_eligible_delay ("annul_true");
6152 if (have_annul_false)
6153 write_eligible_delay ("annul_false");
6154 }
6155
6156 /* Write out information about function units. */
6157 if (num_units)
6158 write_function_unit_info ();
6159
6160 /* Write out constant delay slot info */
6161 write_const_num_delay_slots ();
6162
6163 write_length_unit_log ();
6164
6165 fflush (stdout);
6166 return (ferror (stdout) != 0 ? FATAL_EXIT_CODE : SUCCESS_EXIT_CODE);
6167 }
6168
6169 /* Define this so we can link with print-rtl.o to get debug_rtx function. */
6170 const char *
6171 get_insn_name (code)
6172 int code ATTRIBUTE_UNUSED;
6173 {
6174 return NULL;
6175 }
Mirror of the offical gcc git repository hosted at gcc.gnu.org