1 /* Generate code from machine description to compute values of attributes. 2 Copyright (C) 1991, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 3 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 4 Free Software Foundation, Inc. 5 Contributed by Richard Kenner (kenner@vlsi1.ultra.nyu.edu) 6 7 This file is part of GCC. 8 9 GCC is free software; you can redistribute it and/or modify it under 10 the terms of the GNU General Public License as published by the Free 11 Software Foundation; either version 3, or (at your option) any later 12 version. 13 14 GCC is distributed in the hope that it will be useful, but WITHOUT ANY 15 WARRANTY; without even the implied warranty of MERCHANTABILITY or 16 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 17 for more details. 18 19 You should have received a copy of the GNU General Public License 20 along with GCC; see the file COPYING3. If not see 21 <http://www.gnu.org/licenses/>. */ 22 23 /* This program handles insn attributes and the DEFINE_DELAY and 24 DEFINE_INSN_RESERVATION 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_INSN_RESERVATION. 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 definitions is to create 74 arbitrarily complex expressions and have the optimization simplify them. 75 76 Once optimization is complete, any required routines and definitions 77 will be written. 78 79 An optimization that is not yet implemented is to hoist the constant 80 expressions entirely out of the routines and definitions that are written. 81 A way to do this is to iterate over all possible combinations of values 82 for constant attributes and generate a set of functions for that given 83 combination. An initialization function would be written that evaluates 84 the attributes and installs the corresponding set of routines and 85 definitions (each would be accessed through a pointer). 86 87 We use the flags in an RTX as follows: 88 `unchanging' (ATTR_IND_SIMPLIFIED_P): This rtx is fully simplified 89 independent of the insn code. 90 `in_struct' (ATTR_CURR_SIMPLIFIED_P): This rtx is fully simplified 91 for the insn code currently being processed (see optimize_attrs). 92 `return_val' (ATTR_PERMANENT_P): This rtx is permanent and unique 93 (see attr_rtx). */ 94 95 #define ATTR_IND_SIMPLIFIED_P(RTX) (RTX_FLAG((RTX), unchanging)) 96 #define ATTR_CURR_SIMPLIFIED_P(RTX) (RTX_FLAG((RTX), in_struct)) 97 #define ATTR_PERMANENT_P(RTX) (RTX_FLAG((RTX), return_val)) 98 99 #if 0 100 #define strcmp_check(S1, S2) ((S1) == (S2) \ 101 ? 0 \ 102 : (gcc_assert (strcmp ((S1), (S2))), 1)) 103 #else 104 #define strcmp_check(S1, S2) ((S1) != (S2)) 105 #endif 106 107 #include "bconfig.h" 108 #include "system.h" 109 #include "coretypes.h" 110 #include "tm.h" 111 #include "rtl.h" 112 #include "gensupport.h" 113 #include "obstack.h" 114 #include "errors.h" 115 116 /* Flags for make_internal_attr's `special' parameter. */ 117 #define ATTR_NONE 0 118 #define ATTR_SPECIAL (1 << 0) 119 120 static struct obstack obstack1, obstack2; 121 static struct obstack *hash_obstack = &obstack1; 122 static struct obstack *temp_obstack = &obstack2; 123 124 /* enough space to reserve for printing out ints */ 125 #define MAX_DIGITS (HOST_BITS_PER_INT * 3 / 10 + 3) 126 127 /* Define structures used to record attributes and values. */ 128 129 /* As each DEFINE_INSN, DEFINE_PEEPHOLE, or DEFINE_ASM_ATTRIBUTES is 130 encountered, we store all the relevant information into a 131 `struct insn_def'. This is done to allow attribute definitions to occur 132 anywhere in the file. */ 133 134 struct insn_def 135 { 136 struct insn_def *next; /* Next insn in chain. */ 137 rtx def; /* The DEFINE_... */ 138 int insn_code; /* Instruction number. */ 139 int insn_index; /* Expression number in file, for errors. */ 140 int lineno; /* Line number. */ 141 int num_alternatives; /* Number of alternatives. */ 142 int vec_idx; /* Index of attribute vector in `def'. */ 143 }; 144 145 /* Once everything has been read in, we store in each attribute value a list 146 of insn codes that have that value. Here is the structure used for the 147 list. */ 148 149 struct insn_ent 150 { 151 struct insn_ent *next; /* Next in chain. */ 152 struct insn_def *def; /* Instruction definition. */ 153 }; 154 155 /* Each value of an attribute (either constant or computed) is assigned a 156 structure which is used as the listhead of the insns that have that 157 value. */ 158 159 struct attr_value 160 { 161 rtx value; /* Value of attribute. */ 162 struct attr_value *next; /* Next attribute value in chain. */ 163 struct insn_ent *first_insn; /* First insn with this value. */ 164 int num_insns; /* Number of insns with this value. */ 165 int has_asm_insn; /* True if this value used for `asm' insns */ 166 }; 167 168 /* Structure for each attribute. */ 169 170 struct attr_desc 171 { 172 char *name; /* Name of attribute. */ 173 struct attr_desc *next; /* Next attribute. */ 174 struct attr_value *first_value; /* First value of this attribute. */ 175 struct attr_value *default_val; /* Default value for this attribute. */ 176 int lineno : 24; /* Line number. */ 177 unsigned is_numeric : 1; /* Values of this attribute are numeric. */ 178 unsigned is_const : 1; /* Attribute value constant for each run. */ 179 unsigned is_special : 1; /* Don't call `write_attr_set'. */ 180 }; 181 182 /* Structure for each DEFINE_DELAY. */ 183 184 struct delay_desc 185 { 186 rtx def; /* DEFINE_DELAY expression. */ 187 struct delay_desc *next; /* Next DEFINE_DELAY. */ 188 int num; /* Number of DEFINE_DELAY, starting at 1. */ 189 int lineno; /* Line number. */ 190 }; 191 192 struct attr_value_list 193 { 194 struct attr_value *av; 195 struct insn_ent *ie; 196 struct attr_desc *attr; 197 struct attr_value_list *next; 198 }; 199 200 /* Listheads of above structures. */ 201 202 /* This one is indexed by the first character of the attribute name. */ 203 #define MAX_ATTRS_INDEX 256 204 static struct attr_desc *attrs[MAX_ATTRS_INDEX]; 205 static struct insn_def *defs; 206 static struct delay_desc *delays; 207 struct attr_value_list **insn_code_values; 208 209 /* Other variables. */ 210 211 static int insn_code_number; 212 static int insn_index_number; 213 static int got_define_asm_attributes; 214 static int must_extract; 215 static int must_constrain; 216 static int address_used; 217 static int length_used; 218 static int num_delays; 219 static int have_annul_true, have_annul_false; 220 static int num_insn_ents; 221 222 /* Stores, for each insn code, the number of constraint alternatives. */ 223 224 static int *insn_n_alternatives; 225 226 /* Stores, for each insn code, a bitmap that has bits on for each possible 227 alternative. */ 228 229 static int *insn_alternatives; 230 231 /* Used to simplify expressions. */ 232 233 static rtx true_rtx, false_rtx; 234 235 /* Used to reduce calls to `strcmp' */ 236 237 static const char *alternative_name; 238 static const char *length_str; 239 static const char *delay_type_str; 240 static const char *delay_1_0_str; 241 static const char *num_delay_slots_str; 242 243 /* Simplify an expression. Only call the routine if there is something to 244 simplify. */ 245 #define SIMPLIFY_TEST_EXP(EXP,INSN_CODE,INSN_INDEX) \ 246 (ATTR_IND_SIMPLIFIED_P (EXP) || ATTR_CURR_SIMPLIFIED_P (EXP) ? (EXP) \ 247 : simplify_test_exp (EXP, INSN_CODE, INSN_INDEX)) 248 249 #define DEF_ATTR_STRING(S) (attr_string ((S), strlen (S))) 250 251 /* Forward declarations of functions used before their definitions, only. */ 252 static char *attr_string (const char *, int); 253 static char *attr_printf (unsigned int, const char *, ...) 254 ATTRIBUTE_PRINTF_2; 255 static rtx make_numeric_value (int); 256 static struct attr_desc *find_attr (const char **, int); 257 static rtx mk_attr_alt (int); 258 static char *next_comma_elt (const char **); 259 static rtx insert_right_side (enum rtx_code, rtx, rtx, int, int); 260 static rtx copy_boolean (rtx); 261 static int compares_alternatives_p (rtx); 262 static void make_internal_attr (const char *, rtx, int); 263 static void insert_insn_ent (struct attr_value *, struct insn_ent *); 264 static void walk_attr_value (rtx); 265 static int max_attr_value (rtx, int*); 266 static int min_attr_value (rtx, int*); 267 static int or_attr_value (rtx, int*); 268 static rtx simplify_test_exp (rtx, int, int); 269 static rtx simplify_test_exp_in_temp (rtx, int, int); 270 static rtx copy_rtx_unchanging (rtx); 271 static bool attr_alt_subset_p (rtx, rtx); 272 static bool attr_alt_subset_of_compl_p (rtx, rtx); 273 static void clear_struct_flag (rtx); 274 static void write_attr_valueq (struct attr_desc *, const char *); 275 static struct attr_value *find_most_used (struct attr_desc *); 276 static void write_attr_set (struct attr_desc *, int, rtx, 277 const char *, const char *, rtx, 278 int, int); 279 static void write_attr_case (struct attr_desc *, struct attr_value *, 280 int, const char *, const char *, int, rtx); 281 static void write_attr_value (struct attr_desc *, rtx); 282 static void write_upcase (const char *); 283 static void write_indent (int); 284 static rtx identity_fn (rtx); 285 static rtx zero_fn (rtx); 286 static rtx one_fn (rtx); 287 static rtx max_fn (rtx); 288 static rtx min_fn (rtx); 289 290 #define oballoc(T) XOBNEW (hash_obstack, T) 291 #define oballocvec(T, N) XOBNEWVEC (hash_obstack, T, (N)) 292 293 /* Hash table for sharing RTL and strings. */ 294 295 /* Each hash table slot is a bucket containing a chain of these structures. 296 Strings are given negative hash codes; RTL expressions are given positive 297 hash codes. */ 298 299 struct attr_hash 300 { 301 struct attr_hash *next; /* Next structure in the bucket. */ 302 int hashcode; /* Hash code of this rtx or string. */ 303 union 304 { 305 char *str; /* The string (negative hash codes) */ 306 rtx rtl; /* or the RTL recorded here. */ 307 } u; 308 }; 309 310 /* Now here is the hash table. When recording an RTL, it is added to 311 the slot whose index is the hash code mod the table size. Note 312 that the hash table is used for several kinds of RTL (see attr_rtx) 313 and for strings. While all these live in the same table, they are 314 completely independent, and the hash code is computed differently 315 for each. */ 316 317 #define RTL_HASH_SIZE 4093 318 static struct attr_hash *attr_hash_table[RTL_HASH_SIZE]; 319 320 /* Here is how primitive or already-shared RTL's hash 321 codes are made. */ 322 #define RTL_HASH(RTL) ((intptr_t) (RTL) & 0777777) 323 324 /* Add an entry to the hash table for RTL with hash code HASHCODE. */ 325 326 static void 327 attr_hash_add_rtx (int hashcode, rtx rtl) 328 { 329 struct attr_hash *h; 330 331 h = XOBNEW (hash_obstack, struct attr_hash); 332 h->hashcode = hashcode; 333 h->u.rtl = rtl; 334 h->next = attr_hash_table[hashcode % RTL_HASH_SIZE]; 335 attr_hash_table[hashcode % RTL_HASH_SIZE] = h; 336 } 337 338 /* Add an entry to the hash table for STRING with hash code HASHCODE. */ 339 340 static void 341 attr_hash_add_string (int hashcode, char *str) 342 { 343 struct attr_hash *h; 344 345 h = XOBNEW (hash_obstack, struct attr_hash); 346 h->hashcode = -hashcode; 347 h->u.str = str; 348 h->next = attr_hash_table[hashcode % RTL_HASH_SIZE]; 349 attr_hash_table[hashcode % RTL_HASH_SIZE] = h; 350 } 351 352 /* Generate an RTL expression, but avoid duplicates. 353 Set the ATTR_PERMANENT_P flag for these permanent objects. 354 355 In some cases we cannot uniquify; then we return an ordinary 356 impermanent rtx with ATTR_PERMANENT_P clear. 357 358 Args are as follows: 359 360 rtx attr_rtx (code, [element1, ..., elementn]) */ 361 362 static rtx 363 attr_rtx_1 (enum rtx_code code, va_list p) 364 { 365 rtx rt_val = NULL_RTX;/* RTX to return to caller... */ 366 int hashcode; 367 struct attr_hash *h; 368 struct obstack *old_obstack = rtl_obstack; 369 370 /* For each of several cases, search the hash table for an existing entry. 371 Use that entry if one is found; otherwise create a new RTL and add it 372 to the table. */ 373 374 if (GET_RTX_CLASS (code) == RTX_UNARY) 375 { 376 rtx arg0 = va_arg (p, rtx); 377 378 /* A permanent object cannot point to impermanent ones. */ 379 if (! ATTR_PERMANENT_P (arg0)) 380 { 381 rt_val = rtx_alloc (code); 382 XEXP (rt_val, 0) = arg0; 383 return rt_val; 384 } 385 386 hashcode = ((HOST_WIDE_INT) code + RTL_HASH (arg0)); 387 for (h = attr_hash_table[hashcode % RTL_HASH_SIZE]; h; h = h->next) 388 if (h->hashcode == hashcode 389 && GET_CODE (h->u.rtl) == code 390 && XEXP (h->u.rtl, 0) == arg0) 391 return h->u.rtl; 392 393 if (h == 0) 394 { 395 rtl_obstack = hash_obstack; 396 rt_val = rtx_alloc (code); 397 XEXP (rt_val, 0) = arg0; 398 } 399 } 400 else if (GET_RTX_CLASS (code) == RTX_BIN_ARITH 401 || GET_RTX_CLASS (code) == RTX_COMM_ARITH 402 || GET_RTX_CLASS (code) == RTX_COMPARE 403 || GET_RTX_CLASS (code) == RTX_COMM_COMPARE) 404 { 405 rtx arg0 = va_arg (p, rtx); 406 rtx arg1 = va_arg (p, rtx); 407 408 /* A permanent object cannot point to impermanent ones. */ 409 if (! ATTR_PERMANENT_P (arg0) || ! ATTR_PERMANENT_P (arg1)) 410 { 411 rt_val = rtx_alloc (code); 412 XEXP (rt_val, 0) = arg0; 413 XEXP (rt_val, 1) = arg1; 414 return rt_val; 415 } 416 417 hashcode = ((HOST_WIDE_INT) code + RTL_HASH (arg0) + RTL_HASH (arg1)); 418 for (h = attr_hash_table[hashcode % RTL_HASH_SIZE]; h; h = h->next) 419 if (h->hashcode == hashcode 420 && GET_CODE (h->u.rtl) == code 421 && XEXP (h->u.rtl, 0) == arg0 422 && XEXP (h->u.rtl, 1) == arg1) 423 return h->u.rtl; 424 425 if (h == 0) 426 { 427 rtl_obstack = hash_obstack; 428 rt_val = rtx_alloc (code); 429 XEXP (rt_val, 0) = arg0; 430 XEXP (rt_val, 1) = arg1; 431 } 432 } 433 else if (GET_RTX_LENGTH (code) == 1 434 && GET_RTX_FORMAT (code)[0] == 's') 435 { 436 char *arg0 = va_arg (p, char *); 437 438 arg0 = DEF_ATTR_STRING (arg0); 439 440 hashcode = ((HOST_WIDE_INT) code + RTL_HASH (arg0)); 441 for (h = attr_hash_table[hashcode % RTL_HASH_SIZE]; h; h = h->next) 442 if (h->hashcode == hashcode 443 && GET_CODE (h->u.rtl) == code 444 && XSTR (h->u.rtl, 0) == arg0) 445 return h->u.rtl; 446 447 if (h == 0) 448 { 449 rtl_obstack = hash_obstack; 450 rt_val = rtx_alloc (code); 451 XSTR (rt_val, 0) = arg0; 452 } 453 } 454 else if (GET_RTX_LENGTH (code) == 2 455 && GET_RTX_FORMAT (code)[0] == 's' 456 && GET_RTX_FORMAT (code)[1] == 's') 457 { 458 char *arg0 = va_arg (p, char *); 459 char *arg1 = va_arg (p, char *); 460 461 hashcode = ((HOST_WIDE_INT) code + RTL_HASH (arg0) + RTL_HASH (arg1)); 462 for (h = attr_hash_table[hashcode % RTL_HASH_SIZE]; h; h = h->next) 463 if (h->hashcode == hashcode 464 && GET_CODE (h->u.rtl) == code 465 && XSTR (h->u.rtl, 0) == arg0 466 && XSTR (h->u.rtl, 1) == arg1) 467 return h->u.rtl; 468 469 if (h == 0) 470 { 471 rtl_obstack = hash_obstack; 472 rt_val = rtx_alloc (code); 473 XSTR (rt_val, 0) = arg0; 474 XSTR (rt_val, 1) = arg1; 475 } 476 } 477 else if (code == CONST_INT) 478 { 479 HOST_WIDE_INT arg0 = va_arg (p, HOST_WIDE_INT); 480 if (arg0 == 0) 481 return false_rtx; 482 else if (arg0 == 1) 483 return true_rtx; 484 else 485 goto nohash; 486 } 487 else 488 { 489 int i; /* Array indices... */ 490 const char *fmt; /* Current rtx's format... */ 491 nohash: 492 rt_val = rtx_alloc (code); /* Allocate the storage space. */ 493 494 fmt = GET_RTX_FORMAT (code); /* Find the right format... */ 495 for (i = 0; i < GET_RTX_LENGTH (code); i++) 496 { 497 switch (*fmt++) 498 { 499 case '0': /* Unused field. */ 500 break; 501 502 case 'i': /* An integer? */ 503 XINT (rt_val, i) = va_arg (p, int); 504 break; 505 506 case 'w': /* A wide integer? */ 507 XWINT (rt_val, i) = va_arg (p, HOST_WIDE_INT); 508 break; 509 510 case 's': /* A string? */ 511 XSTR (rt_val, i) = va_arg (p, char *); 512 break; 513 514 case 'e': /* An expression? */ 515 case 'u': /* An insn? Same except when printing. */ 516 XEXP (rt_val, i) = va_arg (p, rtx); 517 break; 518 519 case 'E': /* An RTX vector? */ 520 XVEC (rt_val, i) = va_arg (p, rtvec); 521 break; 522 523 default: 524 gcc_unreachable (); 525 } 526 } 527 return rt_val; 528 } 529 530 rtl_obstack = old_obstack; 531 attr_hash_add_rtx (hashcode, rt_val); 532 ATTR_PERMANENT_P (rt_val) = 1; 533 return rt_val; 534 } 535 536 static rtx 537 attr_rtx (enum rtx_code code, ...) 538 { 539 rtx result; 540 va_list p; 541 542 va_start (p, code); 543 result = attr_rtx_1 (code, p); 544 va_end (p); 545 return result; 546 } 547 548 /* Create a new string printed with the printf line arguments into a space 549 of at most LEN bytes: 550 551 rtx attr_printf (len, format, [arg1, ..., argn]) */ 552 553 static char * 554 attr_printf (unsigned int len, const char *fmt, ...) 555 { 556 char str[256]; 557 va_list p; 558 559 va_start (p, fmt); 560 561 gcc_assert (len < sizeof str); /* Leave room for \0. */ 562 563 vsprintf (str, fmt, p); 564 va_end (p); 565 566 return DEF_ATTR_STRING (str); 567 } 568 569 static rtx 570 attr_eq (const char *name, const char *value) 571 { 572 return attr_rtx (EQ_ATTR, DEF_ATTR_STRING (name), DEF_ATTR_STRING (value)); 573 } 574 575 static const char * 576 attr_numeral (int n) 577 { 578 return XSTR (make_numeric_value (n), 0); 579 } 580 581 /* Return a permanent (possibly shared) copy of a string STR (not assumed 582 to be null terminated) with LEN bytes. */ 583 584 static char * 585 attr_string (const char *str, int len) 586 { 587 struct attr_hash *h; 588 int hashcode; 589 int i; 590 char *new_str; 591 592 /* Compute the hash code. */ 593 hashcode = (len + 1) * 613 + (unsigned) str[0]; 594 for (i = 1; i < len; i += 2) 595 hashcode = ((hashcode * 613) + (unsigned) str[i]); 596 if (hashcode < 0) 597 hashcode = -hashcode; 598 599 /* Search the table for the string. */ 600 for (h = attr_hash_table[hashcode % RTL_HASH_SIZE]; h; h = h->next) 601 if (h->hashcode == -hashcode && h->u.str[0] == str[0] 602 && !strncmp (h->u.str, str, len)) 603 return h->u.str; /* <-- return if found. */ 604 605 /* Not found; create a permanent copy and add it to the hash table. */ 606 new_str = XOBNEWVAR (hash_obstack, char, len + 1); 607 memcpy (new_str, str, len); 608 new_str[len] = '\0'; 609 attr_hash_add_string (hashcode, new_str); 610 611 return new_str; /* Return the new string. */ 612 } 613 614 /* Check two rtx's for equality of contents, 615 taking advantage of the fact that if both are hashed 616 then they can't be equal unless they are the same object. */ 617 618 static int 619 attr_equal_p (rtx x, rtx y) 620 { 621 return (x == y || (! (ATTR_PERMANENT_P (x) && ATTR_PERMANENT_P (y)) 622 && rtx_equal_p (x, y))); 623 } 624 625 /* Copy an attribute value expression, 626 descending to all depths, but not copying any 627 permanent hashed subexpressions. */ 628 629 static rtx 630 attr_copy_rtx (rtx orig) 631 { 632 rtx copy; 633 int i, j; 634 RTX_CODE code; 635 const char *format_ptr; 636 637 /* No need to copy a permanent object. */ 638 if (ATTR_PERMANENT_P (orig)) 639 return orig; 640 641 code = GET_CODE (orig); 642 643 switch (code) 644 { 645 case REG: 646 case CONST_INT: 647 case CONST_DOUBLE: 648 case CONST_VECTOR: 649 case SYMBOL_REF: 650 case CODE_LABEL: 651 case PC: 652 case CC0: 653 return orig; 654 655 default: 656 break; 657 } 658 659 copy = rtx_alloc (code); 660 PUT_MODE (copy, GET_MODE (orig)); 661 ATTR_IND_SIMPLIFIED_P (copy) = ATTR_IND_SIMPLIFIED_P (orig); 662 ATTR_CURR_SIMPLIFIED_P (copy) = ATTR_CURR_SIMPLIFIED_P (orig); 663 ATTR_PERMANENT_P (copy) = ATTR_PERMANENT_P (orig); 664 665 format_ptr = GET_RTX_FORMAT (GET_CODE (copy)); 666 667 for (i = 0; i < GET_RTX_LENGTH (GET_CODE (copy)); i++) 668 { 669 switch (*format_ptr++) 670 { 671 case 'e': 672 XEXP (copy, i) = XEXP (orig, i); 673 if (XEXP (orig, i) != NULL) 674 XEXP (copy, i) = attr_copy_rtx (XEXP (orig, i)); 675 break; 676 677 case 'E': 678 case 'V': 679 XVEC (copy, i) = XVEC (orig, i); 680 if (XVEC (orig, i) != NULL) 681 { 682 XVEC (copy, i) = rtvec_alloc (XVECLEN (orig, i)); 683 for (j = 0; j < XVECLEN (copy, i); j++) 684 XVECEXP (copy, i, j) = attr_copy_rtx (XVECEXP (orig, i, j)); 685 } 686 break; 687 688 case 'n': 689 case 'i': 690 XINT (copy, i) = XINT (orig, i); 691 break; 692 693 case 'w': 694 XWINT (copy, i) = XWINT (orig, i); 695 break; 696 697 case 's': 698 case 'S': 699 XSTR (copy, i) = XSTR (orig, i); 700 break; 701 702 default: 703 gcc_unreachable (); 704 } 705 } 706 return copy; 707 } 708 709 /* Given a test expression for an attribute, ensure it is validly formed. 710 IS_CONST indicates whether the expression is constant for each compiler 711 run (a constant expression may not test any particular insn). 712 713 Convert (eq_attr "att" "a1,a2") to (ior (eq_attr ... ) (eq_attrq ..)) 714 and (eq_attr "att" "!a1") to (not (eq_attr "att" "a1")). Do the latter 715 test first so that (eq_attr "att" "!a1,a2,a3") works as expected. 716 717 Update the string address in EQ_ATTR expression to be the same used 718 in the attribute (or `alternative_name') to speed up subsequent 719 `find_attr' calls and eliminate most `strcmp' calls. 720 721 Return the new expression, if any. */ 722 723 static rtx 724 check_attr_test (rtx exp, int is_const, int lineno) 725 { 726 struct attr_desc *attr; 727 struct attr_value *av; 728 const char *name_ptr, *p; 729 rtx orexp, newexp; 730 731 switch (GET_CODE (exp)) 732 { 733 case EQ_ATTR: 734 /* Handle negation test. */ 735 if (XSTR (exp, 1)[0] == '!') 736 return check_attr_test (attr_rtx (NOT, 737 attr_eq (XSTR (exp, 0), 738 &XSTR (exp, 1)[1])), 739 is_const, lineno); 740 741 else if (n_comma_elts (XSTR (exp, 1)) == 1) 742 { 743 attr = find_attr (&XSTR (exp, 0), 0); 744 if (attr == NULL) 745 { 746 if (! strcmp (XSTR (exp, 0), "alternative")) 747 return mk_attr_alt (1 << atoi (XSTR (exp, 1))); 748 else 749 fatal ("unknown attribute `%s' in EQ_ATTR", XSTR (exp, 0)); 750 } 751 752 if (is_const && ! attr->is_const) 753 fatal ("constant expression uses insn attribute `%s' in EQ_ATTR", 754 XSTR (exp, 0)); 755 756 /* Copy this just to make it permanent, 757 so expressions using it can be permanent too. */ 758 exp = attr_eq (XSTR (exp, 0), XSTR (exp, 1)); 759 760 /* It shouldn't be possible to simplify the value given to a 761 constant attribute, so don't expand this until it's time to 762 write the test expression. */ 763 if (attr->is_const) 764 ATTR_IND_SIMPLIFIED_P (exp) = 1; 765 766 if (attr->is_numeric) 767 { 768 for (p = XSTR (exp, 1); *p; p++) 769 if (! ISDIGIT (*p)) 770 fatal ("attribute `%s' takes only numeric values", 771 XSTR (exp, 0)); 772 } 773 else 774 { 775 for (av = attr->first_value; av; av = av->next) 776 if (GET_CODE (av->value) == CONST_STRING 777 && ! strcmp (XSTR (exp, 1), XSTR (av->value, 0))) 778 break; 779 780 if (av == NULL) 781 fatal ("unknown value `%s' for `%s' attribute", 782 XSTR (exp, 1), XSTR (exp, 0)); 783 } 784 } 785 else 786 { 787 if (! strcmp (XSTR (exp, 0), "alternative")) 788 { 789 int set = 0; 790 791 name_ptr = XSTR (exp, 1); 792 while ((p = next_comma_elt (&name_ptr)) != NULL) 793 set |= 1 << atoi (p); 794 795 return mk_attr_alt (set); 796 } 797 else 798 { 799 /* Make an IOR tree of the possible values. */ 800 orexp = false_rtx; 801 name_ptr = XSTR (exp, 1); 802 while ((p = next_comma_elt (&name_ptr)) != NULL) 803 { 804 newexp = attr_eq (XSTR (exp, 0), p); 805 orexp = insert_right_side (IOR, orexp, newexp, -2, -2); 806 } 807 808 return check_attr_test (orexp, is_const, lineno); 809 } 810 } 811 break; 812 813 case ATTR_FLAG: 814 break; 815 816 case CONST_INT: 817 /* Either TRUE or FALSE. */ 818 if (XWINT (exp, 0)) 819 return true_rtx; 820 else 821 return false_rtx; 822 823 case IOR: 824 case AND: 825 XEXP (exp, 0) = check_attr_test (XEXP (exp, 0), is_const, lineno); 826 XEXP (exp, 1) = check_attr_test (XEXP (exp, 1), is_const, lineno); 827 break; 828 829 case NOT: 830 XEXP (exp, 0) = check_attr_test (XEXP (exp, 0), is_const, lineno); 831 break; 832 833 case MATCH_OPERAND: 834 if (is_const) 835 fatal ("RTL operator \"%s\" not valid in constant attribute test", 836 GET_RTX_NAME (GET_CODE (exp))); 837 /* These cases can't be simplified. */ 838 ATTR_IND_SIMPLIFIED_P (exp) = 1; 839 break; 840 841 case LE: case LT: case GT: case GE: 842 case LEU: case LTU: case GTU: case GEU: 843 case NE: case EQ: 844 if (GET_CODE (XEXP (exp, 0)) == SYMBOL_REF 845 && GET_CODE (XEXP (exp, 1)) == SYMBOL_REF) 846 exp = attr_rtx (GET_CODE (exp), 847 attr_rtx (SYMBOL_REF, XSTR (XEXP (exp, 0), 0)), 848 attr_rtx (SYMBOL_REF, XSTR (XEXP (exp, 1), 0))); 849 /* These cases can't be simplified. */ 850 ATTR_IND_SIMPLIFIED_P (exp) = 1; 851 break; 852 853 case SYMBOL_REF: 854 if (is_const) 855 { 856 /* These cases are valid for constant attributes, but can't be 857 simplified. */ 858 exp = attr_rtx (SYMBOL_REF, XSTR (exp, 0)); 859 ATTR_IND_SIMPLIFIED_P (exp) = 1; 860 break; 861 } 862 default: 863 fatal ("RTL operator \"%s\" not valid in attribute test", 864 GET_RTX_NAME (GET_CODE (exp))); 865 } 866 867 return exp; 868 } 869 870 /* Given an expression, ensure that it is validly formed and that all named 871 attribute values are valid for the given attribute. Issue a fatal error 872 if not. If no attribute is specified, assume a numeric attribute. 873 874 Return a perhaps modified replacement expression for the value. */ 875 876 static rtx 877 check_attr_value (rtx exp, struct attr_desc *attr) 878 { 879 struct attr_value *av; 880 const char *p; 881 int i; 882 883 switch (GET_CODE (exp)) 884 { 885 case CONST_INT: 886 if (attr && ! attr->is_numeric) 887 { 888 message_with_line (attr->lineno, 889 "CONST_INT not valid for non-numeric attribute %s", 890 attr->name); 891 have_error = 1; 892 break; 893 } 894 895 if (INTVAL (exp) < 0) 896 { 897 message_with_line (attr->lineno, 898 "negative numeric value specified for attribute %s", 899 attr->name); 900 have_error = 1; 901 break; 902 } 903 break; 904 905 case CONST_STRING: 906 if (! strcmp (XSTR (exp, 0), "*")) 907 break; 908 909 if (attr == 0 || attr->is_numeric) 910 { 911 p = XSTR (exp, 0); 912 for (; *p; p++) 913 if (! ISDIGIT (*p)) 914 { 915 message_with_line (attr ? attr->lineno : 0, 916 "non-numeric value for numeric attribute %s", 917 attr ? attr->name : "internal"); 918 have_error = 1; 919 break; 920 } 921 break; 922 } 923 924 for (av = attr->first_value; av; av = av->next) 925 if (GET_CODE (av->value) == CONST_STRING 926 && ! strcmp (XSTR (av->value, 0), XSTR (exp, 0))) 927 break; 928 929 if (av == NULL) 930 { 931 message_with_line (attr->lineno, 932 "unknown value `%s' for `%s' attribute", 933 XSTR (exp, 0), attr ? attr->name : "internal"); 934 have_error = 1; 935 } 936 break; 937 938 case IF_THEN_ELSE: 939 XEXP (exp, 0) = check_attr_test (XEXP (exp, 0), 940 attr ? attr->is_const : 0, 941 attr ? attr->lineno : 0); 942 XEXP (exp, 1) = check_attr_value (XEXP (exp, 1), attr); 943 XEXP (exp, 2) = check_attr_value (XEXP (exp, 2), attr); 944 break; 945 946 case PLUS: 947 case MINUS: 948 case MULT: 949 case DIV: 950 case MOD: 951 if (attr && !attr->is_numeric) 952 { 953 message_with_line (attr->lineno, 954 "invalid operation `%s' for non-numeric attribute value", 955 GET_RTX_NAME (GET_CODE (exp))); 956 have_error = 1; 957 break; 958 } 959 /* Fall through. */ 960 961 case IOR: 962 case AND: 963 XEXP (exp, 0) = check_attr_value (XEXP (exp, 0), attr); 964 XEXP (exp, 1) = check_attr_value (XEXP (exp, 1), attr); 965 break; 966 967 case FFS: 968 case CLZ: 969 case CTZ: 970 case POPCOUNT: 971 case PARITY: 972 case BSWAP: 973 XEXP (exp, 0) = check_attr_value (XEXP (exp, 0), attr); 974 break; 975 976 case COND: 977 if (XVECLEN (exp, 0) % 2 != 0) 978 { 979 message_with_line (attr->lineno, 980 "first operand of COND must have even length"); 981 have_error = 1; 982 break; 983 } 984 985 for (i = 0; i < XVECLEN (exp, 0); i += 2) 986 { 987 XVECEXP (exp, 0, i) = check_attr_test (XVECEXP (exp, 0, i), 988 attr ? attr->is_const : 0, 989 attr ? attr->lineno : 0); 990 XVECEXP (exp, 0, i + 1) 991 = check_attr_value (XVECEXP (exp, 0, i + 1), attr); 992 } 993 994 XEXP (exp, 1) = check_attr_value (XEXP (exp, 1), attr); 995 break; 996 997 case ATTR: 998 { 999 struct attr_desc *attr2 = find_attr (&XSTR (exp, 0), 0); 1000 if (attr2 == NULL) 1001 { 1002 message_with_line (attr ? attr->lineno : 0, 1003 "unknown attribute `%s' in ATTR", 1004 XSTR (exp, 0)); 1005 have_error = 1; 1006 } 1007 else if (attr && attr->is_const && ! attr2->is_const) 1008 { 1009 message_with_line (attr->lineno, 1010 "non-constant attribute `%s' referenced from `%s'", 1011 XSTR (exp, 0), attr->name); 1012 have_error = 1; 1013 } 1014 else if (attr 1015 && attr->is_numeric != attr2->is_numeric) 1016 { 1017 message_with_line (attr->lineno, 1018 "numeric attribute mismatch calling `%s' from `%s'", 1019 XSTR (exp, 0), attr->name); 1020 have_error = 1; 1021 } 1022 } 1023 break; 1024 1025 case SYMBOL_REF: 1026 /* A constant SYMBOL_REF is valid as a constant attribute test and 1027 is expanded later by make_canonical into a COND. In a non-constant 1028 attribute test, it is left be. */ 1029 return attr_rtx (SYMBOL_REF, XSTR (exp, 0)); 1030 1031 default: 1032 message_with_line (attr ? attr->lineno : 0, 1033 "invalid operation `%s' for attribute value", 1034 GET_RTX_NAME (GET_CODE (exp))); 1035 have_error = 1; 1036 break; 1037 } 1038 1039 return exp; 1040 } 1041 1042 /* Given an SET_ATTR_ALTERNATIVE expression, convert to the canonical SET. 1043 It becomes a COND with each test being (eq_attr "alternative" "n") */ 1044 1045 static rtx 1046 convert_set_attr_alternative (rtx exp, struct insn_def *id) 1047 { 1048 int num_alt = id->num_alternatives; 1049 rtx condexp; 1050 int i; 1051 1052 if (XVECLEN (exp, 1) != num_alt) 1053 { 1054 message_with_line (id->lineno, 1055 "bad number of entries in SET_ATTR_ALTERNATIVE"); 1056 have_error = 1; 1057 return NULL_RTX; 1058 } 1059 1060 /* Make a COND with all tests but the last. Select the last value via the 1061 default. */ 1062 condexp = rtx_alloc (COND); 1063 XVEC (condexp, 0) = rtvec_alloc ((num_alt - 1) * 2); 1064 1065 for (i = 0; i < num_alt - 1; i++) 1066 { 1067 const char *p; 1068 p = attr_numeral (i); 1069 1070 XVECEXP (condexp, 0, 2 * i) = attr_eq (alternative_name, p); 1071 XVECEXP (condexp, 0, 2 * i + 1) = XVECEXP (exp, 1, i); 1072 } 1073 1074 XEXP (condexp, 1) = XVECEXP (exp, 1, i); 1075 1076 return attr_rtx (SET, attr_rtx (ATTR, XSTR (exp, 0)), condexp); 1077 } 1078 1079 /* Given a SET_ATTR, convert to the appropriate SET. If a comma-separated 1080 list of values is given, convert to SET_ATTR_ALTERNATIVE first. */ 1081 1082 static rtx 1083 convert_set_attr (rtx exp, struct insn_def *id) 1084 { 1085 rtx newexp; 1086 const char *name_ptr; 1087 char *p; 1088 int n; 1089 1090 /* See how many alternative specified. */ 1091 n = n_comma_elts (XSTR (exp, 1)); 1092 if (n == 1) 1093 return attr_rtx (SET, 1094 attr_rtx (ATTR, XSTR (exp, 0)), 1095 attr_rtx (CONST_STRING, XSTR (exp, 1))); 1096 1097 newexp = rtx_alloc (SET_ATTR_ALTERNATIVE); 1098 XSTR (newexp, 0) = XSTR (exp, 0); 1099 XVEC (newexp, 1) = rtvec_alloc (n); 1100 1101 /* Process each comma-separated name. */ 1102 name_ptr = XSTR (exp, 1); 1103 n = 0; 1104 while ((p = next_comma_elt (&name_ptr)) != NULL) 1105 XVECEXP (newexp, 1, n++) = attr_rtx (CONST_STRING, p); 1106 1107 return convert_set_attr_alternative (newexp, id); 1108 } 1109 1110 /* Scan all definitions, checking for validity. Also, convert any SET_ATTR 1111 and SET_ATTR_ALTERNATIVE expressions to the corresponding SET 1112 expressions. */ 1113 1114 static void 1115 check_defs (void) 1116 { 1117 struct insn_def *id; 1118 struct attr_desc *attr; 1119 int i; 1120 rtx value; 1121 1122 for (id = defs; id; id = id->next) 1123 { 1124 if (XVEC (id->def, id->vec_idx) == NULL) 1125 continue; 1126 1127 for (i = 0; i < XVECLEN (id->def, id->vec_idx); i++) 1128 { 1129 value = XVECEXP (id->def, id->vec_idx, i); 1130 switch (GET_CODE (value)) 1131 { 1132 case SET: 1133 if (GET_CODE (XEXP (value, 0)) != ATTR) 1134 { 1135 message_with_line (id->lineno, "bad attribute set"); 1136 have_error = 1; 1137 value = NULL_RTX; 1138 } 1139 break; 1140 1141 case SET_ATTR_ALTERNATIVE: 1142 value = convert_set_attr_alternative (value, id); 1143 break; 1144 1145 case SET_ATTR: 1146 value = convert_set_attr (value, id); 1147 break; 1148 1149 default: 1150 message_with_line (id->lineno, "invalid attribute code %s", 1151 GET_RTX_NAME (GET_CODE (value))); 1152 have_error = 1; 1153 value = NULL_RTX; 1154 } 1155 if (value == NULL_RTX) 1156 continue; 1157 1158 if ((attr = find_attr (&XSTR (XEXP (value, 0), 0), 0)) == NULL) 1159 { 1160 message_with_line (id->lineno, "unknown attribute %s", 1161 XSTR (XEXP (value, 0), 0)); 1162 have_error = 1; 1163 continue; 1164 } 1165 1166 XVECEXP (id->def, id->vec_idx, i) = value; 1167 XEXP (value, 1) = check_attr_value (XEXP (value, 1), attr); 1168 } 1169 } 1170 } 1171 1172 /* Given a valid expression for an attribute value, remove any IF_THEN_ELSE 1173 expressions by converting them into a COND. This removes cases from this 1174 program. Also, replace an attribute value of "*" with the default attribute 1175 value. */ 1176 1177 static rtx 1178 make_canonical (struct attr_desc *attr, rtx exp) 1179 { 1180 int i; 1181 rtx newexp; 1182 1183 switch (GET_CODE (exp)) 1184 { 1185 case CONST_INT: 1186 exp = make_numeric_value (INTVAL (exp)); 1187 break; 1188 1189 case CONST_STRING: 1190 if (! strcmp (XSTR (exp, 0), "*")) 1191 { 1192 if (attr == 0 || attr->default_val == 0) 1193 fatal ("(attr_value \"*\") used in invalid context"); 1194 exp = attr->default_val->value; 1195 } 1196 else 1197 XSTR (exp, 0) = DEF_ATTR_STRING (XSTR (exp, 0)); 1198 1199 break; 1200 1201 case SYMBOL_REF: 1202 if (!attr->is_const || ATTR_IND_SIMPLIFIED_P (exp)) 1203 break; 1204 /* The SYMBOL_REF is constant for a given run, so mark it as unchanging. 1205 This makes the COND something that won't be considered an arbitrary 1206 expression by walk_attr_value. */ 1207 ATTR_IND_SIMPLIFIED_P (exp) = 1; 1208 exp = check_attr_value (exp, attr); 1209 break; 1210 1211 case IF_THEN_ELSE: 1212 newexp = rtx_alloc (COND); 1213 XVEC (newexp, 0) = rtvec_alloc (2); 1214 XVECEXP (newexp, 0, 0) = XEXP (exp, 0); 1215 XVECEXP (newexp, 0, 1) = XEXP (exp, 1); 1216 1217 XEXP (newexp, 1) = XEXP (exp, 2); 1218 1219 exp = newexp; 1220 /* Fall through to COND case since this is now a COND. */ 1221 1222 case COND: 1223 { 1224 int allsame = 1; 1225 rtx defval; 1226 1227 /* First, check for degenerate COND. */ 1228 if (XVECLEN (exp, 0) == 0) 1229 return make_canonical (attr, XEXP (exp, 1)); 1230 defval = XEXP (exp, 1) = make_canonical (attr, XEXP (exp, 1)); 1231 1232 for (i = 0; i < XVECLEN (exp, 0); i += 2) 1233 { 1234 XVECEXP (exp, 0, i) = copy_boolean (XVECEXP (exp, 0, i)); 1235 XVECEXP (exp, 0, i + 1) 1236 = make_canonical (attr, XVECEXP (exp, 0, i + 1)); 1237 if (! rtx_equal_p (XVECEXP (exp, 0, i + 1), defval)) 1238 allsame = 0; 1239 } 1240 if (allsame) 1241 return defval; 1242 } 1243 break; 1244 1245 default: 1246 break; 1247 } 1248 1249 return exp; 1250 } 1251 1252 static rtx 1253 copy_boolean (rtx exp) 1254 { 1255 if (GET_CODE (exp) == AND || GET_CODE (exp) == IOR) 1256 return attr_rtx (GET_CODE (exp), copy_boolean (XEXP (exp, 0)), 1257 copy_boolean (XEXP (exp, 1))); 1258 if (GET_CODE (exp) == MATCH_OPERAND) 1259 { 1260 XSTR (exp, 1) = DEF_ATTR_STRING (XSTR (exp, 1)); 1261 XSTR (exp, 2) = DEF_ATTR_STRING (XSTR (exp, 2)); 1262 } 1263 else if (GET_CODE (exp) == EQ_ATTR) 1264 { 1265 XSTR (exp, 0) = DEF_ATTR_STRING (XSTR (exp, 0)); 1266 XSTR (exp, 1) = DEF_ATTR_STRING (XSTR (exp, 1)); 1267 } 1268 1269 return exp; 1270 } 1271 1272 /* Given a value and an attribute description, return a `struct attr_value *' 1273 that represents that value. This is either an existing structure, if the 1274 value has been previously encountered, or a newly-created structure. 1275 1276 `insn_code' is the code of an insn whose attribute has the specified 1277 value (-2 if not processing an insn). We ensure that all insns for 1278 a given value have the same number of alternatives if the value checks 1279 alternatives. */ 1280 1281 static struct attr_value * 1282 get_attr_value (rtx value, struct attr_desc *attr, int insn_code) 1283 { 1284 struct attr_value *av; 1285 int num_alt = 0; 1286 1287 value = make_canonical (attr, value); 1288 if (compares_alternatives_p (value)) 1289 { 1290 if (insn_code < 0 || insn_alternatives == NULL) 1291 fatal ("(eq_attr \"alternatives\" ...) used in non-insn context"); 1292 else 1293 num_alt = insn_alternatives[insn_code]; 1294 } 1295 1296 for (av = attr->first_value; av; av = av->next) 1297 if (rtx_equal_p (value, av->value) 1298 && (num_alt == 0 || av->first_insn == NULL 1299 || insn_alternatives[av->first_insn->def->insn_code])) 1300 return av; 1301 1302 av = oballoc (struct attr_value); 1303 av->value = value; 1304 av->next = attr->first_value; 1305 attr->first_value = av; 1306 av->first_insn = NULL; 1307 av->num_insns = 0; 1308 av->has_asm_insn = 0; 1309 1310 return av; 1311 } 1312 1313 /* After all DEFINE_DELAYs have been read in, create internal attributes 1314 to generate the required routines. 1315 1316 First, we compute the number of delay slots for each insn (as a COND of 1317 each of the test expressions in DEFINE_DELAYs). Then, if more than one 1318 delay type is specified, we compute a similar function giving the 1319 DEFINE_DELAY ordinal for each insn. 1320 1321 Finally, for each [DEFINE_DELAY, slot #] pair, we compute an attribute that 1322 tells whether a given insn can be in that delay slot. 1323 1324 Normal attribute filling and optimization expands these to contain the 1325 information needed to handle delay slots. */ 1326 1327 static void 1328 expand_delays (void) 1329 { 1330 struct delay_desc *delay; 1331 rtx condexp; 1332 rtx newexp; 1333 int i; 1334 char *p; 1335 1336 /* First, generate data for `num_delay_slots' function. */ 1337 1338 condexp = rtx_alloc (COND); 1339 XVEC (condexp, 0) = rtvec_alloc (num_delays * 2); 1340 XEXP (condexp, 1) = make_numeric_value (0); 1341 1342 for (i = 0, delay = delays; delay; i += 2, delay = delay->next) 1343 { 1344 XVECEXP (condexp, 0, i) = XEXP (delay->def, 0); 1345 XVECEXP (condexp, 0, i + 1) 1346 = make_numeric_value (XVECLEN (delay->def, 1) / 3); 1347 } 1348 1349 make_internal_attr (num_delay_slots_str, condexp, ATTR_NONE); 1350 1351 /* If more than one delay type, do the same for computing the delay type. */ 1352 if (num_delays > 1) 1353 { 1354 condexp = rtx_alloc (COND); 1355 XVEC (condexp, 0) = rtvec_alloc (num_delays * 2); 1356 XEXP (condexp, 1) = make_numeric_value (0); 1357 1358 for (i = 0, delay = delays; delay; i += 2, delay = delay->next) 1359 { 1360 XVECEXP (condexp, 0, i) = XEXP (delay->def, 0); 1361 XVECEXP (condexp, 0, i + 1) = make_numeric_value (delay->num); 1362 } 1363 1364 make_internal_attr (delay_type_str, condexp, ATTR_SPECIAL); 1365 } 1366 1367 /* For each delay possibility and delay slot, compute an eligibility 1368 attribute for non-annulled insns and for each type of annulled (annul 1369 if true and annul if false). */ 1370 for (delay = delays; delay; delay = delay->next) 1371 { 1372 for (i = 0; i < XVECLEN (delay->def, 1); i += 3) 1373 { 1374 condexp = XVECEXP (delay->def, 1, i); 1375 if (condexp == 0) 1376 condexp = false_rtx; 1377 newexp = attr_rtx (IF_THEN_ELSE, condexp, 1378 make_numeric_value (1), make_numeric_value (0)); 1379 1380 p = attr_printf (sizeof "*delay__" + MAX_DIGITS * 2, 1381 "*delay_%d_%d", delay->num, i / 3); 1382 make_internal_attr (p, newexp, ATTR_SPECIAL); 1383 1384 if (have_annul_true) 1385 { 1386 condexp = XVECEXP (delay->def, 1, i + 1); 1387 if (condexp == 0) condexp = false_rtx; 1388 newexp = attr_rtx (IF_THEN_ELSE, condexp, 1389 make_numeric_value (1), 1390 make_numeric_value (0)); 1391 p = attr_printf (sizeof "*annul_true__" + MAX_DIGITS * 2, 1392 "*annul_true_%d_%d", delay->num, i / 3); 1393 make_internal_attr (p, newexp, ATTR_SPECIAL); 1394 } 1395 1396 if (have_annul_false) 1397 { 1398 condexp = XVECEXP (delay->def, 1, i + 2); 1399 if (condexp == 0) condexp = false_rtx; 1400 newexp = attr_rtx (IF_THEN_ELSE, condexp, 1401 make_numeric_value (1), 1402 make_numeric_value (0)); 1403 p = attr_printf (sizeof "*annul_false__" + MAX_DIGITS * 2, 1404 "*annul_false_%d_%d", delay->num, i / 3); 1405 make_internal_attr (p, newexp, ATTR_SPECIAL); 1406 } 1407 } 1408 } 1409 } 1410 1411 /* Once all attributes and insns have been read and checked, we construct for 1412 each attribute value a list of all the insns that have that value for 1413 the attribute. */ 1414 1415 static void 1416 fill_attr (struct attr_desc *attr) 1417 { 1418 struct attr_value *av; 1419 struct insn_ent *ie; 1420 struct insn_def *id; 1421 int i; 1422 rtx value; 1423 1424 /* Don't fill constant attributes. The value is independent of 1425 any particular insn. */ 1426 if (attr->is_const) 1427 return; 1428 1429 for (id = defs; id; id = id->next) 1430 { 1431 /* If no value is specified for this insn for this attribute, use the 1432 default. */ 1433 value = NULL; 1434 if (XVEC (id->def, id->vec_idx)) 1435 for (i = 0; i < XVECLEN (id->def, id->vec_idx); i++) 1436 if (! strcmp_check (XSTR (XEXP (XVECEXP (id->def, id->vec_idx, i), 0), 0), 1437 attr->name)) 1438 value = XEXP (XVECEXP (id->def, id->vec_idx, i), 1); 1439 1440 if (value == NULL) 1441 av = attr->default_val; 1442 else 1443 av = get_attr_value (value, attr, id->insn_code); 1444 1445 ie = oballoc (struct insn_ent); 1446 ie->def = id; 1447 insert_insn_ent (av, ie); 1448 } 1449 } 1450 1451 /* Given an expression EXP, see if it is a COND or IF_THEN_ELSE that has a 1452 test that checks relative positions of insns (uses MATCH_DUP or PC). 1453 If so, replace it with what is obtained by passing the expression to 1454 ADDRESS_FN. If not but it is a COND or IF_THEN_ELSE, call this routine 1455 recursively on each value (including the default value). Otherwise, 1456 return the value returned by NO_ADDRESS_FN applied to EXP. */ 1457 1458 static rtx 1459 substitute_address (rtx exp, rtx (*no_address_fn) (rtx), 1460 rtx (*address_fn) (rtx)) 1461 { 1462 int i; 1463 rtx newexp; 1464 1465 if (GET_CODE (exp) == COND) 1466 { 1467 /* See if any tests use addresses. */ 1468 address_used = 0; 1469 for (i = 0; i < XVECLEN (exp, 0); i += 2) 1470 walk_attr_value (XVECEXP (exp, 0, i)); 1471 1472 if (address_used) 1473 return (*address_fn) (exp); 1474 1475 /* Make a new copy of this COND, replacing each element. */ 1476 newexp = rtx_alloc (COND); 1477 XVEC (newexp, 0) = rtvec_alloc (XVECLEN (exp, 0)); 1478 for (i = 0; i < XVECLEN (exp, 0); i += 2) 1479 { 1480 XVECEXP (newexp, 0, i) = XVECEXP (exp, 0, i); 1481 XVECEXP (newexp, 0, i + 1) 1482 = substitute_address (XVECEXP (exp, 0, i + 1), 1483 no_address_fn, address_fn); 1484 } 1485 1486 XEXP (newexp, 1) = substitute_address (XEXP (exp, 1), 1487 no_address_fn, address_fn); 1488 1489 return newexp; 1490 } 1491 1492 else if (GET_CODE (exp) == IF_THEN_ELSE) 1493 { 1494 address_used = 0; 1495 walk_attr_value (XEXP (exp, 0)); 1496 if (address_used) 1497 return (*address_fn) (exp); 1498 1499 return attr_rtx (IF_THEN_ELSE, 1500 substitute_address (XEXP (exp, 0), 1501 no_address_fn, address_fn), 1502 substitute_address (XEXP (exp, 1), 1503 no_address_fn, address_fn), 1504 substitute_address (XEXP (exp, 2), 1505 no_address_fn, address_fn)); 1506 } 1507 1508 return (*no_address_fn) (exp); 1509 } 1510 1511 /* Make new attributes from the `length' attribute. The following are made, 1512 each corresponding to a function called from `shorten_branches' or 1513 `get_attr_length': 1514 1515 *insn_default_length This is the length of the insn to be returned 1516 by `get_attr_length' before `shorten_branches' 1517 has been called. In each case where the length 1518 depends on relative addresses, the largest 1519 possible is used. This routine is also used 1520 to compute the initial size of the insn. 1521 1522 *insn_variable_length_p This returns 1 if the insn's length depends 1523 on relative addresses, zero otherwise. 1524 1525 *insn_current_length This is only called when it is known that the 1526 insn has a variable length and returns the 1527 current length, based on relative addresses. 1528 */ 1529 1530 static void 1531 make_length_attrs (void) 1532 { 1533 static const char *new_names[] = 1534 { 1535 "*insn_default_length", 1536 "*insn_min_length", 1537 "*insn_variable_length_p", 1538 "*insn_current_length" 1539 }; 1540 static rtx (*const no_address_fn[]) (rtx) 1541 = {identity_fn,identity_fn, zero_fn, zero_fn}; 1542 static rtx (*const address_fn[]) (rtx) 1543 = {max_fn, min_fn, one_fn, identity_fn}; 1544 size_t i; 1545 struct attr_desc *length_attr, *new_attr; 1546 struct attr_value *av, *new_av; 1547 struct insn_ent *ie, *new_ie; 1548 1549 /* See if length attribute is defined. If so, it must be numeric. Make 1550 it special so we don't output anything for it. */ 1551 length_attr = find_attr (&length_str, 0); 1552 if (length_attr == 0) 1553 return; 1554 1555 if (! length_attr->is_numeric) 1556 fatal ("length attribute must be numeric"); 1557 1558 length_attr->is_const = 0; 1559 length_attr->is_special = 1; 1560 1561 /* Make each new attribute, in turn. */ 1562 for (i = 0; i < ARRAY_SIZE (new_names); i++) 1563 { 1564 make_internal_attr (new_names[i], 1565 substitute_address (length_attr->default_val->value, 1566 no_address_fn[i], address_fn[i]), 1567 ATTR_NONE); 1568 new_attr = find_attr (&new_names[i], 0); 1569 for (av = length_attr->first_value; av; av = av->next) 1570 for (ie = av->first_insn; ie; ie = ie->next) 1571 { 1572 new_av = get_attr_value (substitute_address (av->value, 1573 no_address_fn[i], 1574 address_fn[i]), 1575 new_attr, ie->def->insn_code); 1576 new_ie = oballoc (struct insn_ent); 1577 new_ie->def = ie->def; 1578 insert_insn_ent (new_av, new_ie); 1579 } 1580 } 1581 } 1582 1583 /* Utility functions called from above routine. */ 1584 1585 static rtx 1586 identity_fn (rtx exp) 1587 { 1588 return exp; 1589 } 1590 1591 static rtx 1592 zero_fn (rtx exp ATTRIBUTE_UNUSED) 1593 { 1594 return make_numeric_value (0); 1595 } 1596 1597 static rtx 1598 one_fn (rtx exp ATTRIBUTE_UNUSED) 1599 { 1600 return make_numeric_value (1); 1601 } 1602 1603 static rtx 1604 max_fn (rtx exp) 1605 { 1606 int unknown; 1607 return make_numeric_value (max_attr_value (exp, &unknown)); 1608 } 1609 1610 static rtx 1611 min_fn (rtx exp) 1612 { 1613 int unknown; 1614 return make_numeric_value (min_attr_value (exp, &unknown)); 1615 } 1616 1617 static void 1618 write_length_unit_log (void) 1619 { 1620 struct attr_desc *length_attr = find_attr (&length_str, 0); 1621 struct attr_value *av; 1622 struct insn_ent *ie; 1623 unsigned int length_unit_log, length_or; 1624 int unknown = 0; 1625 1626 if (length_attr == 0) 1627 return; 1628 length_or = or_attr_value (length_attr->default_val->value, &unknown); 1629 for (av = length_attr->first_value; av; av = av->next) 1630 for (ie = av->first_insn; ie; ie = ie->next) 1631 length_or |= or_attr_value (av->value, &unknown); 1632 1633 if (unknown) 1634 length_unit_log = 0; 1635 else 1636 { 1637 length_or = ~length_or; 1638 for (length_unit_log = 0; length_or & 1; length_or >>= 1) 1639 length_unit_log++; 1640 } 1641 printf ("EXPORTED_CONST int length_unit_log = %u;\n", length_unit_log); 1642 } 1643 1644 /* Take a COND expression and see if any of the conditions in it can be 1645 simplified. If any are known true or known false for the particular insn 1646 code, the COND can be further simplified. 1647 1648 Also call ourselves on any COND operations that are values of this COND. 1649 1650 We do not modify EXP; rather, we make and return a new rtx. */ 1651 1652 static rtx 1653 simplify_cond (rtx exp, int insn_code, int insn_index) 1654 { 1655 int i, j; 1656 /* We store the desired contents here, 1657 then build a new expression if they don't match EXP. */ 1658 rtx defval = XEXP (exp, 1); 1659 rtx new_defval = XEXP (exp, 1); 1660 int len = XVECLEN (exp, 0); 1661 rtx *tests = XNEWVEC (rtx, len); 1662 int allsame = 1; 1663 rtx ret; 1664 1665 /* This lets us free all storage allocated below, if appropriate. */ 1666 obstack_finish (rtl_obstack); 1667 1668 memcpy (tests, XVEC (exp, 0)->elem, len * sizeof (rtx)); 1669 1670 /* See if default value needs simplification. */ 1671 if (GET_CODE (defval) == COND) 1672 new_defval = simplify_cond (defval, insn_code, insn_index); 1673 1674 /* Simplify the subexpressions, and see what tests we can get rid of. */ 1675 1676 for (i = 0; i < len; i += 2) 1677 { 1678 rtx newtest, newval; 1679 1680 /* Simplify this test. */ 1681 newtest = simplify_test_exp_in_temp (tests[i], insn_code, insn_index); 1682 tests[i] = newtest; 1683 1684 newval = tests[i + 1]; 1685 /* See if this value may need simplification. */ 1686 if (GET_CODE (newval) == COND) 1687 newval = simplify_cond (newval, insn_code, insn_index); 1688 1689 /* Look for ways to delete or combine this test. */ 1690 if (newtest == true_rtx) 1691 { 1692 /* If test is true, make this value the default 1693 and discard this + any following tests. */ 1694 len = i; 1695 defval = tests[i + 1]; 1696 new_defval = newval; 1697 } 1698 1699 else if (newtest == false_rtx) 1700 { 1701 /* If test is false, discard it and its value. */ 1702 for (j = i; j < len - 2; j++) 1703 tests[j] = tests[j + 2]; 1704 i -= 2; 1705 len -= 2; 1706 } 1707 1708 else if (i > 0 && attr_equal_p (newval, tests[i - 1])) 1709 { 1710 /* If this value and the value for the prev test are the same, 1711 merge the tests. */ 1712 1713 tests[i - 2] 1714 = insert_right_side (IOR, tests[i - 2], newtest, 1715 insn_code, insn_index); 1716 1717 /* Delete this test/value. */ 1718 for (j = i; j < len - 2; j++) 1719 tests[j] = tests[j + 2]; 1720 len -= 2; 1721 i -= 2; 1722 } 1723 1724 else 1725 tests[i + 1] = newval; 1726 } 1727 1728 /* If the last test in a COND has the same value 1729 as the default value, that test isn't needed. */ 1730 1731 while (len > 0 && attr_equal_p (tests[len - 1], new_defval)) 1732 len -= 2; 1733 1734 /* See if we changed anything. */ 1735 if (len != XVECLEN (exp, 0) || new_defval != XEXP (exp, 1)) 1736 allsame = 0; 1737 else 1738 for (i = 0; i < len; i++) 1739 if (! attr_equal_p (tests[i], XVECEXP (exp, 0, i))) 1740 { 1741 allsame = 0; 1742 break; 1743 } 1744 1745 if (len == 0) 1746 { 1747 if (GET_CODE (defval) == COND) 1748 ret = simplify_cond (defval, insn_code, insn_index); 1749 else 1750 ret = defval; 1751 } 1752 else if (allsame) 1753 ret = exp; 1754 else 1755 { 1756 rtx newexp = rtx_alloc (COND); 1757 1758 XVEC (newexp, 0) = rtvec_alloc (len); 1759 memcpy (XVEC (newexp, 0)->elem, tests, len * sizeof (rtx)); 1760 XEXP (newexp, 1) = new_defval; 1761 ret = newexp; 1762 } 1763 free (tests); 1764 return ret; 1765 } 1766 1767 /* Remove an insn entry from an attribute value. */ 1768 1769 static void 1770 remove_insn_ent (struct attr_value *av, struct insn_ent *ie) 1771 { 1772 struct insn_ent *previe; 1773 1774 if (av->first_insn == ie) 1775 av->first_insn = ie->next; 1776 else 1777 { 1778 for (previe = av->first_insn; previe->next != ie; previe = previe->next) 1779 ; 1780 previe->next = ie->next; 1781 } 1782 1783 av->num_insns--; 1784 if (ie->def->insn_code == -1) 1785 av->has_asm_insn = 0; 1786 1787 num_insn_ents--; 1788 } 1789 1790 /* Insert an insn entry in an attribute value list. */ 1791 1792 static void 1793 insert_insn_ent (struct attr_value *av, struct insn_ent *ie) 1794 { 1795 ie->next = av->first_insn; 1796 av->first_insn = ie; 1797 av->num_insns++; 1798 if (ie->def->insn_code == -1) 1799 av->has_asm_insn = 1; 1800 1801 num_insn_ents++; 1802 } 1803 1804 /* This is a utility routine to take an expression that is a tree of either 1805 AND or IOR expressions and insert a new term. The new term will be 1806 inserted at the right side of the first node whose code does not match 1807 the root. A new node will be created with the root's code. Its left 1808 side will be the old right side and its right side will be the new 1809 term. 1810 1811 If the `term' is itself a tree, all its leaves will be inserted. */ 1812 1813 static rtx 1814 insert_right_side (enum rtx_code code, rtx exp, rtx term, int insn_code, int insn_index) 1815 { 1816 rtx newexp; 1817 1818 /* Avoid consing in some special cases. */ 1819 if (code == AND && term == true_rtx) 1820 return exp; 1821 if (code == AND && term == false_rtx) 1822 return false_rtx; 1823 if (code == AND && exp == true_rtx) 1824 return term; 1825 if (code == AND && exp == false_rtx) 1826 return false_rtx; 1827 if (code == IOR && term == true_rtx) 1828 return true_rtx; 1829 if (code == IOR && term == false_rtx) 1830 return exp; 1831 if (code == IOR && exp == true_rtx) 1832 return true_rtx; 1833 if (code == IOR && exp == false_rtx) 1834 return term; 1835 if (attr_equal_p (exp, term)) 1836 return exp; 1837 1838 if (GET_CODE (term) == code) 1839 { 1840 exp = insert_right_side (code, exp, XEXP (term, 0), 1841 insn_code, insn_index); 1842 exp = insert_right_side (code, exp, XEXP (term, 1), 1843 insn_code, insn_index); 1844 1845 return exp; 1846 } 1847 1848 if (GET_CODE (exp) == code) 1849 { 1850 rtx new_rtx = insert_right_side (code, XEXP (exp, 1), 1851 term, insn_code, insn_index); 1852 if (new_rtx != XEXP (exp, 1)) 1853 /* Make a copy of this expression and call recursively. */ 1854 newexp = attr_rtx (code, XEXP (exp, 0), new_rtx); 1855 else 1856 newexp = exp; 1857 } 1858 else 1859 { 1860 /* Insert the new term. */ 1861 newexp = attr_rtx (code, exp, term); 1862 } 1863 1864 return simplify_test_exp_in_temp (newexp, insn_code, insn_index); 1865 } 1866 1867 /* If we have an expression which AND's a bunch of 1868 (not (eq_attrq "alternative" "n")) 1869 terms, we may have covered all or all but one of the possible alternatives. 1870 If so, we can optimize. Similarly for IOR's of EQ_ATTR. 1871 1872 This routine is passed an expression and either AND or IOR. It returns a 1873 bitmask indicating which alternatives are mentioned within EXP. */ 1874 1875 static int 1876 compute_alternative_mask (rtx exp, enum rtx_code code) 1877 { 1878 const char *string; 1879 if (GET_CODE (exp) == code) 1880 return compute_alternative_mask (XEXP (exp, 0), code) 1881 | compute_alternative_mask (XEXP (exp, 1), code); 1882 1883 else if (code == AND && GET_CODE (exp) == NOT 1884 && GET_CODE (XEXP (exp, 0)) == EQ_ATTR 1885 && XSTR (XEXP (exp, 0), 0) == alternative_name) 1886 string = XSTR (XEXP (exp, 0), 1); 1887 1888 else if (code == IOR && GET_CODE (exp) == EQ_ATTR 1889 && XSTR (exp, 0) == alternative_name) 1890 string = XSTR (exp, 1); 1891 1892 else if (GET_CODE (exp) == EQ_ATTR_ALT) 1893 { 1894 if (code == AND && XINT (exp, 1)) 1895 return XINT (exp, 0); 1896 1897 if (code == IOR && !XINT (exp, 1)) 1898 return XINT (exp, 0); 1899 1900 return 0; 1901 } 1902 else 1903 return 0; 1904 1905 if (string[1] == 0) 1906 return 1 << (string[0] - '0'); 1907 return 1 << atoi (string); 1908 } 1909 1910 /* Given I, a single-bit mask, return RTX to compare the `alternative' 1911 attribute with the value represented by that bit. */ 1912 1913 static rtx 1914 make_alternative_compare (int mask) 1915 { 1916 return mk_attr_alt (mask); 1917 } 1918 1919 /* If we are processing an (eq_attr "attr" "value") test, we find the value 1920 of "attr" for this insn code. From that value, we can compute a test 1921 showing when the EQ_ATTR will be true. This routine performs that 1922 computation. If a test condition involves an address, we leave the EQ_ATTR 1923 intact because addresses are only valid for the `length' attribute. 1924 1925 EXP is the EQ_ATTR expression and VALUE is the value of that attribute 1926 for the insn corresponding to INSN_CODE and INSN_INDEX. */ 1927 1928 static rtx 1929 evaluate_eq_attr (rtx exp, rtx value, int insn_code, int insn_index) 1930 { 1931 rtx orexp, andexp; 1932 rtx right; 1933 rtx newexp; 1934 int i; 1935 1936 switch (GET_CODE (value)) 1937 { 1938 case CONST_STRING: 1939 if (! strcmp_check (XSTR (value, 0), XSTR (exp, 1))) 1940 newexp = true_rtx; 1941 else 1942 newexp = false_rtx; 1943 break; 1944 1945 case SYMBOL_REF: 1946 { 1947 char *p; 1948 char string[256]; 1949 1950 gcc_assert (GET_CODE (exp) == EQ_ATTR); 1951 gcc_assert (strlen (XSTR (exp, 0)) + strlen (XSTR (exp, 1)) + 2 1952 <= 256); 1953 1954 strcpy (string, XSTR (exp, 0)); 1955 strcat (string, "_"); 1956 strcat (string, XSTR (exp, 1)); 1957 for (p = string; *p; p++) 1958 *p = TOUPPER (*p); 1959 1960 newexp = attr_rtx (EQ, value, 1961 attr_rtx (SYMBOL_REF, 1962 DEF_ATTR_STRING (string))); 1963 break; 1964 } 1965 1966 case COND: 1967 /* We construct an IOR of all the cases for which the 1968 requested attribute value is present. Since we start with 1969 FALSE, if it is not present, FALSE will be returned. 1970 1971 Each case is the AND of the NOT's of the previous conditions with the 1972 current condition; in the default case the current condition is TRUE. 1973 1974 For each possible COND value, call ourselves recursively. 1975 1976 The extra TRUE and FALSE expressions will be eliminated by another 1977 call to the simplification routine. */ 1978 1979 orexp = false_rtx; 1980 andexp = true_rtx; 1981 1982 for (i = 0; i < XVECLEN (value, 0); i += 2) 1983 { 1984 rtx this_cond = simplify_test_exp_in_temp (XVECEXP (value, 0, i), 1985 insn_code, insn_index); 1986 1987 right = insert_right_side (AND, andexp, this_cond, 1988 insn_code, insn_index); 1989 right = insert_right_side (AND, right, 1990 evaluate_eq_attr (exp, 1991 XVECEXP (value, 0, 1992 i + 1), 1993 insn_code, insn_index), 1994 insn_code, insn_index); 1995 orexp = insert_right_side (IOR, orexp, right, 1996 insn_code, insn_index); 1997 1998 /* Add this condition into the AND expression. */ 1999 newexp = attr_rtx (NOT, this_cond); 2000 andexp = insert_right_side (AND, andexp, newexp, 2001 insn_code, insn_index); 2002 } 2003 2004 /* Handle the default case. */ 2005 right = insert_right_side (AND, andexp, 2006 evaluate_eq_attr (exp, XEXP (value, 1), 2007 insn_code, insn_index), 2008 insn_code, insn_index); 2009 newexp = insert_right_side (IOR, orexp, right, insn_code, insn_index); 2010 break; 2011 2012 default: 2013 gcc_unreachable (); 2014 } 2015 2016 /* If uses an address, must return original expression. But set the 2017 ATTR_IND_SIMPLIFIED_P bit so we don't try to simplify it again. */ 2018 2019 address_used = 0; 2020 walk_attr_value (newexp); 2021 2022 if (address_used) 2023 { 2024 if (! ATTR_IND_SIMPLIFIED_P (exp)) 2025 return copy_rtx_unchanging (exp); 2026 return exp; 2027 } 2028 else 2029 return newexp; 2030 } 2031 2032 /* This routine is called when an AND of a term with a tree of AND's is 2033 encountered. If the term or its complement is present in the tree, it 2034 can be replaced with TRUE or FALSE, respectively. 2035 2036 Note that (eq_attr "att" "v1") and (eq_attr "att" "v2") cannot both 2037 be true and hence are complementary. 2038 2039 There is one special case: If we see 2040 (and (not (eq_attr "att" "v1")) 2041 (eq_attr "att" "v2")) 2042 this can be replaced by (eq_attr "att" "v2"). To do this we need to 2043 replace the term, not anything in the AND tree. So we pass a pointer to 2044 the term. */ 2045 2046 static rtx 2047 simplify_and_tree (rtx exp, rtx *pterm, int insn_code, int insn_index) 2048 { 2049 rtx left, right; 2050 rtx newexp; 2051 rtx temp; 2052 int left_eliminates_term, right_eliminates_term; 2053 2054 if (GET_CODE (exp) == AND) 2055 { 2056 left = simplify_and_tree (XEXP (exp, 0), pterm, insn_code, insn_index); 2057 right = simplify_and_tree (XEXP (exp, 1), pterm, insn_code, insn_index); 2058 if (left != XEXP (exp, 0) || right != XEXP (exp, 1)) 2059 { 2060 newexp = attr_rtx (AND, left, right); 2061 2062 exp = simplify_test_exp_in_temp (newexp, insn_code, insn_index); 2063 } 2064 } 2065 2066 else if (GET_CODE (exp) == IOR) 2067 { 2068 /* For the IOR case, we do the same as above, except that we can 2069 only eliminate `term' if both sides of the IOR would do so. */ 2070 temp = *pterm; 2071 left = simplify_and_tree (XEXP (exp, 0), &temp, insn_code, insn_index); 2072 left_eliminates_term = (temp == true_rtx); 2073 2074 temp = *pterm; 2075 right = simplify_and_tree (XEXP (exp, 1), &temp, insn_code, insn_index); 2076 right_eliminates_term = (temp == true_rtx); 2077 2078 if (left_eliminates_term && right_eliminates_term) 2079 *pterm = true_rtx; 2080 2081 if (left != XEXP (exp, 0) || right != XEXP (exp, 1)) 2082 { 2083 newexp = attr_rtx (IOR, left, right); 2084 2085 exp = simplify_test_exp_in_temp (newexp, insn_code, insn_index); 2086 } 2087 } 2088 2089 /* Check for simplifications. Do some extra checking here since this 2090 routine is called so many times. */ 2091 2092 if (exp == *pterm) 2093 return true_rtx; 2094 2095 else if (GET_CODE (exp) == NOT && XEXP (exp, 0) == *pterm) 2096 return false_rtx; 2097 2098 else if (GET_CODE (*pterm) == NOT && exp == XEXP (*pterm, 0)) 2099 return false_rtx; 2100 2101 else if (GET_CODE (exp) == EQ_ATTR_ALT && GET_CODE (*pterm) == EQ_ATTR_ALT) 2102 { 2103 if (attr_alt_subset_p (*pterm, exp)) 2104 return true_rtx; 2105 2106 if (attr_alt_subset_of_compl_p (*pterm, exp)) 2107 return false_rtx; 2108 2109 if (attr_alt_subset_p (exp, *pterm)) 2110 *pterm = true_rtx; 2111 2112 return exp; 2113 } 2114 2115 else if (GET_CODE (exp) == EQ_ATTR && GET_CODE (*pterm) == EQ_ATTR) 2116 { 2117 if (XSTR (exp, 0) != XSTR (*pterm, 0)) 2118 return exp; 2119 2120 if (! strcmp_check (XSTR (exp, 1), XSTR (*pterm, 1))) 2121 return true_rtx; 2122 else 2123 return false_rtx; 2124 } 2125 2126 else if (GET_CODE (*pterm) == EQ_ATTR && GET_CODE (exp) == NOT 2127 && GET_CODE (XEXP (exp, 0)) == EQ_ATTR) 2128 { 2129 if (XSTR (*pterm, 0) != XSTR (XEXP (exp, 0), 0)) 2130 return exp; 2131 2132 if (! strcmp_check (XSTR (*pterm, 1), XSTR (XEXP (exp, 0), 1))) 2133 return false_rtx; 2134 else 2135 return true_rtx; 2136 } 2137 2138 else if (GET_CODE (exp) == EQ_ATTR && GET_CODE (*pterm) == NOT 2139 && GET_CODE (XEXP (*pterm, 0)) == EQ_ATTR) 2140 { 2141 if (XSTR (exp, 0) != XSTR (XEXP (*pterm, 0), 0)) 2142 return exp; 2143 2144 if (! strcmp_check (XSTR (exp, 1), XSTR (XEXP (*pterm, 0), 1))) 2145 return false_rtx; 2146 else 2147 *pterm = true_rtx; 2148 } 2149 2150 else if (GET_CODE (exp) == NOT && GET_CODE (*pterm) == NOT) 2151 { 2152 if (attr_equal_p (XEXP (exp, 0), XEXP (*pterm, 0))) 2153 return true_rtx; 2154 } 2155 2156 else if (GET_CODE (exp) == NOT) 2157 { 2158 if (attr_equal_p (XEXP (exp, 0), *pterm)) 2159 return false_rtx; 2160 } 2161 2162 else if (GET_CODE (*pterm) == NOT) 2163 { 2164 if (attr_equal_p (XEXP (*pterm, 0), exp)) 2165 return false_rtx; 2166 } 2167 2168 else if (attr_equal_p (exp, *pterm)) 2169 return true_rtx; 2170 2171 return exp; 2172 } 2173 2174 /* Similar to `simplify_and_tree', but for IOR trees. */ 2175 2176 static rtx 2177 simplify_or_tree (rtx exp, rtx *pterm, int insn_code, int insn_index) 2178 { 2179 rtx left, right; 2180 rtx newexp; 2181 rtx temp; 2182 int left_eliminates_term, right_eliminates_term; 2183 2184 if (GET_CODE (exp) == IOR) 2185 { 2186 left = simplify_or_tree (XEXP (exp, 0), pterm, insn_code, insn_index); 2187 right = simplify_or_tree (XEXP (exp, 1), pterm, insn_code, insn_index); 2188 if (left != XEXP (exp, 0) || right != XEXP (exp, 1)) 2189 { 2190 newexp = attr_rtx (GET_CODE (exp), left, right); 2191 2192 exp = simplify_test_exp_in_temp (newexp, insn_code, insn_index); 2193 } 2194 } 2195 2196 else if (GET_CODE (exp) == AND) 2197 { 2198 /* For the AND case, we do the same as above, except that we can 2199 only eliminate `term' if both sides of the AND would do so. */ 2200 temp = *pterm; 2201 left = simplify_or_tree (XEXP (exp, 0), &temp, insn_code, insn_index); 2202 left_eliminates_term = (temp == false_rtx); 2203 2204 temp = *pterm; 2205 right = simplify_or_tree (XEXP (exp, 1), &temp, insn_code, insn_index); 2206 right_eliminates_term = (temp == false_rtx); 2207 2208 if (left_eliminates_term && right_eliminates_term) 2209 *pterm = false_rtx; 2210 2211 if (left != XEXP (exp, 0) || right != XEXP (exp, 1)) 2212 { 2213 newexp = attr_rtx (GET_CODE (exp), left, right); 2214 2215 exp = simplify_test_exp_in_temp (newexp, insn_code, insn_index); 2216 } 2217 } 2218 2219 if (attr_equal_p (exp, *pterm)) 2220 return false_rtx; 2221 2222 else if (GET_CODE (exp) == NOT && attr_equal_p (XEXP (exp, 0), *pterm)) 2223 return true_rtx; 2224 2225 else if (GET_CODE (*pterm) == NOT && attr_equal_p (XEXP (*pterm, 0), exp)) 2226 return true_rtx; 2227 2228 else if (GET_CODE (*pterm) == EQ_ATTR && GET_CODE (exp) == NOT 2229 && GET_CODE (XEXP (exp, 0)) == EQ_ATTR 2230 && XSTR (*pterm, 0) == XSTR (XEXP (exp, 0), 0)) 2231 *pterm = false_rtx; 2232 2233 else if (GET_CODE (exp) == EQ_ATTR && GET_CODE (*pterm) == NOT 2234 && GET_CODE (XEXP (*pterm, 0)) == EQ_ATTR 2235 && XSTR (exp, 0) == XSTR (XEXP (*pterm, 0), 0)) 2236 return false_rtx; 2237 2238 return exp; 2239 } 2240 2241 /* Compute approximate cost of the expression. Used to decide whether 2242 expression is cheap enough for inline. */ 2243 static int 2244 attr_rtx_cost (rtx x) 2245 { 2246 int cost = 0; 2247 enum rtx_code code; 2248 if (!x) 2249 return 0; 2250 code = GET_CODE (x); 2251 switch (code) 2252 { 2253 case MATCH_OPERAND: 2254 if (XSTR (x, 1)[0]) 2255 return 10; 2256 else 2257 return 0; 2258 2259 case EQ_ATTR_ALT: 2260 return 0; 2261 2262 case EQ_ATTR: 2263 /* Alternatives don't result into function call. */ 2264 if (!strcmp_check (XSTR (x, 0), alternative_name)) 2265 return 0; 2266 else 2267 return 5; 2268 default: 2269 { 2270 int i, j; 2271 const char *fmt = GET_RTX_FORMAT (code); 2272 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--) 2273 { 2274 switch (fmt[i]) 2275 { 2276 case 'V': 2277 case 'E': 2278 for (j = 0; j < XVECLEN (x, i); j++) 2279 cost += attr_rtx_cost (XVECEXP (x, i, j)); 2280 break; 2281 case 'e': 2282 cost += attr_rtx_cost (XEXP (x, i)); 2283 break; 2284 } 2285 } 2286 } 2287 break; 2288 } 2289 return cost; 2290 } 2291 2292 /* Simplify test expression and use temporary obstack in order to avoid 2293 memory bloat. Use ATTR_IND_SIMPLIFIED to avoid unnecessary simplifications 2294 and avoid unnecessary copying if possible. */ 2295 2296 static rtx 2297 simplify_test_exp_in_temp (rtx exp, int insn_code, int insn_index) 2298 { 2299 rtx x; 2300 struct obstack *old; 2301 if (ATTR_IND_SIMPLIFIED_P (exp)) 2302 return exp; 2303 old = rtl_obstack; 2304 rtl_obstack = temp_obstack; 2305 x = simplify_test_exp (exp, insn_code, insn_index); 2306 rtl_obstack = old; 2307 if (x == exp || rtl_obstack == temp_obstack) 2308 return x; 2309 return attr_copy_rtx (x); 2310 } 2311 2312 /* Returns true if S1 is a subset of S2. */ 2313 2314 static bool 2315 attr_alt_subset_p (rtx s1, rtx s2) 2316 { 2317 switch ((XINT (s1, 1) << 1) | XINT (s2, 1)) 2318 { 2319 case (0 << 1) | 0: 2320 return !(XINT (s1, 0) &~ XINT (s2, 0)); 2321 2322 case (0 << 1) | 1: 2323 return !(XINT (s1, 0) & XINT (s2, 0)); 2324 2325 case (1 << 1) | 0: 2326 return false; 2327 2328 case (1 << 1) | 1: 2329 return !(XINT (s2, 0) &~ XINT (s1, 0)); 2330 2331 default: 2332 gcc_unreachable (); 2333 } 2334 } 2335 2336 /* Returns true if S1 is a subset of complement of S2. */ 2337 2338 static bool 2339 attr_alt_subset_of_compl_p (rtx s1, rtx s2) 2340 { 2341 switch ((XINT (s1, 1) << 1) | XINT (s2, 1)) 2342 { 2343 case (0 << 1) | 0: 2344 return !(XINT (s1, 0) & XINT (s2, 0)); 2345 2346 case (0 << 1) | 1: 2347 return !(XINT (s1, 0) & ~XINT (s2, 0)); 2348 2349 case (1 << 1) | 0: 2350 return !(XINT (s2, 0) &~ XINT (s1, 0)); 2351 2352 case (1 << 1) | 1: 2353 return false; 2354 2355 default: 2356 gcc_unreachable (); 2357 } 2358 } 2359 2360 /* Return EQ_ATTR_ALT expression representing intersection of S1 and S2. */ 2361 2362 static rtx 2363 attr_alt_intersection (rtx s1, rtx s2) 2364 { 2365 rtx result = rtx_alloc (EQ_ATTR_ALT); 2366 2367 switch ((XINT (s1, 1) << 1) | XINT (s2, 1)) 2368 { 2369 case (0 << 1) | 0: 2370 XINT (result, 0) = XINT (s1, 0) & XINT (s2, 0); 2371 break; 2372 case (0 << 1) | 1: 2373 XINT (result, 0) = XINT (s1, 0) & ~XINT (s2, 0); 2374 break; 2375 case (1 << 1) | 0: 2376 XINT (result, 0) = XINT (s2, 0) & ~XINT (s1, 0); 2377 break; 2378 case (1 << 1) | 1: 2379 XINT (result, 0) = XINT (s1, 0) | XINT (s2, 0); 2380 break; 2381 default: 2382 gcc_unreachable (); 2383 } 2384 XINT (result, 1) = XINT (s1, 1) & XINT (s2, 1); 2385 2386 return result; 2387 } 2388 2389 /* Return EQ_ATTR_ALT expression representing union of S1 and S2. */ 2390 2391 static rtx 2392 attr_alt_union (rtx s1, rtx s2) 2393 { 2394 rtx result = rtx_alloc (EQ_ATTR_ALT); 2395 2396 switch ((XINT (s1, 1) << 1) | XINT (s2, 1)) 2397 { 2398 case (0 << 1) | 0: 2399 XINT (result, 0) = XINT (s1, 0) | XINT (s2, 0); 2400 break; 2401 case (0 << 1) | 1: 2402 XINT (result, 0) = XINT (s2, 0) & ~XINT (s1, 0); 2403 break; 2404 case (1 << 1) | 0: 2405 XINT (result, 0) = XINT (s1, 0) & ~XINT (s2, 0); 2406 break; 2407 case (1 << 1) | 1: 2408 XINT (result, 0) = XINT (s1, 0) & XINT (s2, 0); 2409 break; 2410 default: 2411 gcc_unreachable (); 2412 } 2413 2414 XINT (result, 1) = XINT (s1, 1) | XINT (s2, 1); 2415 return result; 2416 } 2417 2418 /* Return EQ_ATTR_ALT expression representing complement of S. */ 2419 2420 static rtx 2421 attr_alt_complement (rtx s) 2422 { 2423 rtx result = rtx_alloc (EQ_ATTR_ALT); 2424 2425 XINT (result, 0) = XINT (s, 0); 2426 XINT (result, 1) = 1 - XINT (s, 1); 2427 2428 return result; 2429 } 2430 2431 /* Return EQ_ATTR_ALT expression representing set containing elements set 2432 in E. */ 2433 2434 static rtx 2435 mk_attr_alt (int e) 2436 { 2437 rtx result = rtx_alloc (EQ_ATTR_ALT); 2438 2439 XINT (result, 0) = e; 2440 XINT (result, 1) = 0; 2441 2442 return result; 2443 } 2444 2445 /* Given an expression, see if it can be simplified for a particular insn 2446 code based on the values of other attributes being tested. This can 2447 eliminate nested get_attr_... calls. 2448 2449 Note that if an endless recursion is specified in the patterns, the 2450 optimization will loop. However, it will do so in precisely the cases where 2451 an infinite recursion loop could occur during compilation. It's better that 2452 it occurs here! */ 2453 2454 static rtx 2455 simplify_test_exp (rtx exp, int insn_code, int insn_index) 2456 { 2457 rtx left, right; 2458 struct attr_desc *attr; 2459 struct attr_value *av; 2460 struct insn_ent *ie; 2461 struct attr_value_list *iv; 2462 int i; 2463 rtx newexp = exp; 2464 bool left_alt, right_alt; 2465 2466 /* Don't re-simplify something we already simplified. */ 2467 if (ATTR_IND_SIMPLIFIED_P (exp) || ATTR_CURR_SIMPLIFIED_P (exp)) 2468 return exp; 2469 2470 switch (GET_CODE (exp)) 2471 { 2472 case AND: 2473 left = SIMPLIFY_TEST_EXP (XEXP (exp, 0), insn_code, insn_index); 2474 if (left == false_rtx) 2475 return false_rtx; 2476 right = SIMPLIFY_TEST_EXP (XEXP (exp, 1), insn_code, insn_index); 2477 if (right == false_rtx) 2478 return false_rtx; 2479 2480 if (GET_CODE (left) == EQ_ATTR_ALT 2481 && GET_CODE (right) == EQ_ATTR_ALT) 2482 { 2483 exp = attr_alt_intersection (left, right); 2484 return simplify_test_exp (exp, insn_code, insn_index); 2485 } 2486 2487 /* If either side is an IOR and we have (eq_attr "alternative" ..") 2488 present on both sides, apply the distributive law since this will 2489 yield simplifications. */ 2490 if ((GET_CODE (left) == IOR || GET_CODE (right) == IOR) 2491 && compute_alternative_mask (left, IOR) 2492 && compute_alternative_mask (right, IOR)) 2493 { 2494 if (GET_CODE (left) == IOR) 2495 { 2496 rtx tem = left; 2497 left = right; 2498 right = tem; 2499 } 2500 2501 newexp = attr_rtx (IOR, 2502 attr_rtx (AND, left, XEXP (right, 0)), 2503 attr_rtx (AND, left, XEXP (right, 1))); 2504 2505 return SIMPLIFY_TEST_EXP (newexp, insn_code, insn_index); 2506 } 2507 2508 /* Try with the term on both sides. */ 2509 right = simplify_and_tree (right, &left, insn_code, insn_index); 2510 if (left == XEXP (exp, 0) && right == XEXP (exp, 1)) 2511 left = simplify_and_tree (left, &right, insn_code, insn_index); 2512 2513 if (left == false_rtx || right == false_rtx) 2514 return false_rtx; 2515 else if (left == true_rtx) 2516 { 2517 return right; 2518 } 2519 else if (right == true_rtx) 2520 { 2521 return left; 2522 } 2523 /* See if all or all but one of the insn's alternatives are specified 2524 in this tree. Optimize if so. */ 2525 2526 if (GET_CODE (left) == NOT) 2527 left_alt = (GET_CODE (XEXP (left, 0)) == EQ_ATTR 2528 && XSTR (XEXP (left, 0), 0) == alternative_name); 2529 else 2530 left_alt = (GET_CODE (left) == EQ_ATTR_ALT 2531 && XINT (left, 1)); 2532 2533 if (GET_CODE (right) == NOT) 2534 right_alt = (GET_CODE (XEXP (right, 0)) == EQ_ATTR 2535 && XSTR (XEXP (right, 0), 0) == alternative_name); 2536 else 2537 right_alt = (GET_CODE (right) == EQ_ATTR_ALT 2538 && XINT (right, 1)); 2539 2540 if (insn_code >= 0 2541 && (GET_CODE (left) == AND 2542 || left_alt 2543 || GET_CODE (right) == AND 2544 || right_alt)) 2545 { 2546 i = compute_alternative_mask (exp, AND); 2547 if (i & ~insn_alternatives[insn_code]) 2548 fatal ("invalid alternative specified for pattern number %d", 2549 insn_index); 2550 2551 /* If all alternatives are excluded, this is false. */ 2552 i ^= insn_alternatives[insn_code]; 2553 if (i == 0) 2554 return false_rtx; 2555 else if ((i & (i - 1)) == 0 && insn_alternatives[insn_code] > 1) 2556 { 2557 /* If just one excluded, AND a comparison with that one to the 2558 front of the tree. The others will be eliminated by 2559 optimization. We do not want to do this if the insn has one 2560 alternative and we have tested none of them! */ 2561 left = make_alternative_compare (i); 2562 right = simplify_and_tree (exp, &left, insn_code, insn_index); 2563 newexp = attr_rtx (AND, left, right); 2564 2565 return SIMPLIFY_TEST_EXP (newexp, insn_code, insn_index); 2566 } 2567 } 2568 2569 if (left != XEXP (exp, 0) || right != XEXP (exp, 1)) 2570 { 2571 newexp = attr_rtx (AND, left, right); 2572 return SIMPLIFY_TEST_EXP (newexp, insn_code, insn_index); 2573 } 2574 break; 2575 2576 case IOR: 2577 left = SIMPLIFY_TEST_EXP (XEXP (exp, 0), insn_code, insn_index); 2578 if (left == true_rtx) 2579 return true_rtx; 2580 right = SIMPLIFY_TEST_EXP (XEXP (exp, 1), insn_code, insn_index); 2581 if (right == true_rtx) 2582 return true_rtx; 2583 2584 if (GET_CODE (left) == EQ_ATTR_ALT 2585 && GET_CODE (right) == EQ_ATTR_ALT) 2586 { 2587 exp = attr_alt_union (left, right); 2588 return simplify_test_exp (exp, insn_code, insn_index); 2589 } 2590 2591 right = simplify_or_tree (right, &left, insn_code, insn_index); 2592 if (left == XEXP (exp, 0) && right == XEXP (exp, 1)) 2593 left = simplify_or_tree (left, &right, insn_code, insn_index); 2594 2595 if (right == true_rtx || left == true_rtx) 2596 return true_rtx; 2597 else if (left == false_rtx) 2598 { 2599 return right; 2600 } 2601 else if (right == false_rtx) 2602 { 2603 return left; 2604 } 2605 2606 /* Test for simple cases where the distributive law is useful. I.e., 2607 convert (ior (and (x) (y)) 2608 (and (x) (z))) 2609 to (and (x) 2610 (ior (y) (z))) 2611 */ 2612 2613 else if (GET_CODE (left) == AND && GET_CODE (right) == AND 2614 && attr_equal_p (XEXP (left, 0), XEXP (right, 0))) 2615 { 2616 newexp = attr_rtx (IOR, XEXP (left, 1), XEXP (right, 1)); 2617 2618 left = XEXP (left, 0); 2619 right = newexp; 2620 newexp = attr_rtx (AND, left, right); 2621 return SIMPLIFY_TEST_EXP (newexp, insn_code, insn_index); 2622 } 2623 2624 /* See if all or all but one of the insn's alternatives are specified 2625 in this tree. Optimize if so. */ 2626 2627 else if (insn_code >= 0 2628 && (GET_CODE (left) == IOR 2629 || (GET_CODE (left) == EQ_ATTR_ALT 2630 && !XINT (left, 1)) 2631 || (GET_CODE (left) == EQ_ATTR 2632 && XSTR (left, 0) == alternative_name) 2633 || GET_CODE (right) == IOR 2634 || (GET_CODE (right) == EQ_ATTR_ALT 2635 && !XINT (right, 1)) 2636 || (GET_CODE (right) == EQ_ATTR 2637 && XSTR (right, 0) == alternative_name))) 2638 { 2639 i = compute_alternative_mask (exp, IOR); 2640 if (i & ~insn_alternatives[insn_code]) 2641 fatal ("invalid alternative specified for pattern number %d", 2642 insn_index); 2643 2644 /* If all alternatives are included, this is true. */ 2645 i ^= insn_alternatives[insn_code]; 2646 if (i == 0) 2647 return true_rtx; 2648 else if ((i & (i - 1)) == 0 && insn_alternatives[insn_code] > 1) 2649 { 2650 /* If just one excluded, IOR a comparison with that one to the 2651 front of the tree. The others will be eliminated by 2652 optimization. We do not want to do this if the insn has one 2653 alternative and we have tested none of them! */ 2654 left = make_alternative_compare (i); 2655 right = simplify_and_tree (exp, &left, insn_code, insn_index); 2656 newexp = attr_rtx (IOR, attr_rtx (NOT, left), right); 2657 2658 return SIMPLIFY_TEST_EXP (newexp, insn_code, insn_index); 2659 } 2660 } 2661 2662 if (left != XEXP (exp, 0) || right != XEXP (exp, 1)) 2663 { 2664 newexp = attr_rtx (IOR, left, right); 2665 return SIMPLIFY_TEST_EXP (newexp, insn_code, insn_index); 2666 } 2667 break; 2668 2669 case NOT: 2670 if (GET_CODE (XEXP (exp, 0)) == NOT) 2671 { 2672 left = SIMPLIFY_TEST_EXP (XEXP (XEXP (exp, 0), 0), 2673 insn_code, insn_index); 2674 return left; 2675 } 2676 2677 left = SIMPLIFY_TEST_EXP (XEXP (exp, 0), insn_code, insn_index); 2678 if (GET_CODE (left) == NOT) 2679 return XEXP (left, 0); 2680 2681 if (left == false_rtx) 2682 return true_rtx; 2683 if (left == true_rtx) 2684 return false_rtx; 2685 2686 if (GET_CODE (left) == EQ_ATTR_ALT) 2687 { 2688 exp = attr_alt_complement (left); 2689 return simplify_test_exp (exp, insn_code, insn_index); 2690 } 2691 2692 /* Try to apply De`Morgan's laws. */ 2693 if (GET_CODE (left) == IOR) 2694 { 2695 newexp = attr_rtx (AND, 2696 attr_rtx (NOT, XEXP (left, 0)), 2697 attr_rtx (NOT, XEXP (left, 1))); 2698 2699 newexp = SIMPLIFY_TEST_EXP (newexp, insn_code, insn_index); 2700 } 2701 else if (GET_CODE (left) == AND) 2702 { 2703 newexp = attr_rtx (IOR, 2704 attr_rtx (NOT, XEXP (left, 0)), 2705 attr_rtx (NOT, XEXP (left, 1))); 2706 2707 newexp = SIMPLIFY_TEST_EXP (newexp, insn_code, insn_index); 2708 } 2709 else if (left != XEXP (exp, 0)) 2710 { 2711 newexp = attr_rtx (NOT, left); 2712 } 2713 break; 2714 2715 case EQ_ATTR_ALT: 2716 if (!XINT (exp, 0)) 2717 return XINT (exp, 1) ? true_rtx : false_rtx; 2718 break; 2719 2720 case EQ_ATTR: 2721 if (XSTR (exp, 0) == alternative_name) 2722 { 2723 newexp = mk_attr_alt (1 << atoi (XSTR (exp, 1))); 2724 break; 2725 } 2726 2727 /* Look at the value for this insn code in the specified attribute. 2728 We normally can replace this comparison with the condition that 2729 would give this insn the values being tested for. */ 2730 if (insn_code >= 0 2731 && (attr = find_attr (&XSTR (exp, 0), 0)) != NULL) 2732 { 2733 rtx x; 2734 2735 av = NULL; 2736 if (insn_code_values) 2737 { 2738 for (iv = insn_code_values[insn_code]; iv; iv = iv->next) 2739 if (iv->attr == attr) 2740 { 2741 av = iv->av; 2742 break; 2743 } 2744 } 2745 else 2746 { 2747 for (av = attr->first_value; av; av = av->next) 2748 for (ie = av->first_insn; ie; ie = ie->next) 2749 if (ie->def->insn_code == insn_code) 2750 goto got_av; 2751 } 2752 2753 if (av) 2754 { 2755 got_av: 2756 x = evaluate_eq_attr (exp, av->value, insn_code, insn_index); 2757 x = SIMPLIFY_TEST_EXP (x, insn_code, insn_index); 2758 if (attr_rtx_cost(x) < 20) 2759 return x; 2760 } 2761 } 2762 break; 2763 2764 default: 2765 break; 2766 } 2767 2768 /* We have already simplified this expression. Simplifying it again 2769 won't buy anything unless we weren't given a valid insn code 2770 to process (i.e., we are canonicalizing something.). */ 2771 if (insn_code != -2 2772 && ! ATTR_IND_SIMPLIFIED_P (newexp)) 2773 return copy_rtx_unchanging (newexp); 2774 2775 return newexp; 2776 } 2777 2778 /* Optimize the attribute lists by seeing if we can determine conditional 2779 values from the known values of other attributes. This will save subroutine 2780 calls during the compilation. */ 2781 2782 static void 2783 optimize_attrs (void) 2784 { 2785 struct attr_desc *attr; 2786 struct attr_value *av; 2787 struct insn_ent *ie; 2788 rtx newexp; 2789 int i; 2790 struct attr_value_list *ivbuf; 2791 struct attr_value_list *iv; 2792 2793 /* For each insn code, make a list of all the insn_ent's for it, 2794 for all values for all attributes. */ 2795 2796 if (num_insn_ents == 0) 2797 return; 2798 2799 /* Make 2 extra elements, for "code" values -2 and -1. */ 2800 insn_code_values = XCNEWVEC (struct attr_value_list *, insn_code_number + 2); 2801 2802 /* Offset the table address so we can index by -2 or -1. */ 2803 insn_code_values += 2; 2804 2805 iv = ivbuf = XNEWVEC (struct attr_value_list, num_insn_ents); 2806 2807 for (i = 0; i < MAX_ATTRS_INDEX; i++) 2808 for (attr = attrs[i]; attr; attr = attr->next) 2809 for (av = attr->first_value; av; av = av->next) 2810 for (ie = av->first_insn; ie; ie = ie->next) 2811 { 2812 iv->attr = attr; 2813 iv->av = av; 2814 iv->ie = ie; 2815 iv->next = insn_code_values[ie->def->insn_code]; 2816 insn_code_values[ie->def->insn_code] = iv; 2817 iv++; 2818 } 2819 2820 /* Sanity check on num_insn_ents. */ 2821 gcc_assert (iv == ivbuf + num_insn_ents); 2822 2823 /* Process one insn code at a time. */ 2824 for (i = -2; i < insn_code_number; i++) 2825 { 2826 /* Clear the ATTR_CURR_SIMPLIFIED_P flag everywhere relevant. 2827 We use it to mean "already simplified for this insn". */ 2828 for (iv = insn_code_values[i]; iv; iv = iv->next) 2829 clear_struct_flag (iv->av->value); 2830 2831 for (iv = insn_code_values[i]; iv; iv = iv->next) 2832 { 2833 struct obstack *old = rtl_obstack; 2834 2835 attr = iv->attr; 2836 av = iv->av; 2837 ie = iv->ie; 2838 if (GET_CODE (av->value) != COND) 2839 continue; 2840 2841 rtl_obstack = temp_obstack; 2842 newexp = av->value; 2843 while (GET_CODE (newexp) == COND) 2844 { 2845 rtx newexp2 = simplify_cond (newexp, ie->def->insn_code, 2846 ie->def->insn_index); 2847 if (newexp2 == newexp) 2848 break; 2849 newexp = newexp2; 2850 } 2851 2852 rtl_obstack = old; 2853 if (newexp != av->value) 2854 { 2855 newexp = attr_copy_rtx (newexp); 2856 remove_insn_ent (av, ie); 2857 av = get_attr_value (newexp, attr, ie->def->insn_code); 2858 iv->av = av; 2859 insert_insn_ent (av, ie); 2860 } 2861 } 2862 } 2863 2864 free (ivbuf); 2865 free (insn_code_values - 2); 2866 insn_code_values = NULL; 2867 } 2868 2869 /* Clear the ATTR_CURR_SIMPLIFIED_P flag in EXP and its subexpressions. */ 2870 2871 static void 2872 clear_struct_flag (rtx x) 2873 { 2874 int i; 2875 int j; 2876 enum rtx_code code; 2877 const char *fmt; 2878 2879 ATTR_CURR_SIMPLIFIED_P (x) = 0; 2880 if (ATTR_IND_SIMPLIFIED_P (x)) 2881 return; 2882 2883 code = GET_CODE (x); 2884 2885 switch (code) 2886 { 2887 case REG: 2888 case CONST_INT: 2889 case CONST_DOUBLE: 2890 case CONST_VECTOR: 2891 case SYMBOL_REF: 2892 case CODE_LABEL: 2893 case PC: 2894 case CC0: 2895 case EQ_ATTR: 2896 case ATTR_FLAG: 2897 return; 2898 2899 default: 2900 break; 2901 } 2902 2903 /* Compare the elements. If any pair of corresponding elements 2904 fail to match, return 0 for the whole things. */ 2905 2906 fmt = GET_RTX_FORMAT (code); 2907 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--) 2908 { 2909 switch (fmt[i]) 2910 { 2911 case 'V': 2912 case 'E': 2913 for (j = 0; j < XVECLEN (x, i); j++) 2914 clear_struct_flag (XVECEXP (x, i, j)); 2915 break; 2916 2917 case 'e': 2918 clear_struct_flag (XEXP (x, i)); 2919 break; 2920 } 2921 } 2922 } 2923 2924 /* Create table entries for DEFINE_ATTR. */ 2925 2926 static void 2927 gen_attr (rtx exp, int lineno) 2928 { 2929 struct attr_desc *attr; 2930 struct attr_value *av; 2931 const char *name_ptr; 2932 char *p; 2933 2934 /* Make a new attribute structure. Check for duplicate by looking at 2935 attr->default_val, since it is initialized by this routine. */ 2936 attr = find_attr (&XSTR (exp, 0), 1); 2937 if (attr->default_val) 2938 { 2939 message_with_line (lineno, "duplicate definition for attribute %s", 2940 attr->name); 2941 message_with_line (attr->lineno, "previous definition"); 2942 have_error = 1; 2943 return; 2944 } 2945 attr->lineno = lineno; 2946 2947 if (*XSTR (exp, 1) == '\0') 2948 attr->is_numeric = 1; 2949 else 2950 { 2951 name_ptr = XSTR (exp, 1); 2952 while ((p = next_comma_elt (&name_ptr)) != NULL) 2953 { 2954 av = oballoc (struct attr_value); 2955 av->value = attr_rtx (CONST_STRING, p); 2956 av->next = attr->first_value; 2957 attr->first_value = av; 2958 av->first_insn = NULL; 2959 av->num_insns = 0; 2960 av->has_asm_insn = 0; 2961 } 2962 } 2963 2964 if (GET_CODE (XEXP (exp, 2)) == CONST) 2965 { 2966 attr->is_const = 1; 2967 if (attr->is_numeric) 2968 { 2969 message_with_line (lineno, 2970 "constant attributes may not take numeric values"); 2971 have_error = 1; 2972 } 2973 2974 /* Get rid of the CONST node. It is allowed only at top-level. */ 2975 XEXP (exp, 2) = XEXP (XEXP (exp, 2), 0); 2976 } 2977 2978 if (! strcmp_check (attr->name, length_str) && ! attr->is_numeric) 2979 { 2980 message_with_line (lineno, 2981 "`length' attribute must take numeric values"); 2982 have_error = 1; 2983 } 2984 2985 /* Set up the default value. */ 2986 XEXP (exp, 2) = check_attr_value (XEXP (exp, 2), attr); 2987 attr->default_val = get_attr_value (XEXP (exp, 2), attr, -2); 2988 } 2989 2990 /* Given a pattern for DEFINE_PEEPHOLE or DEFINE_INSN, return the number of 2991 alternatives in the constraints. Assume all MATCH_OPERANDs have the same 2992 number of alternatives as this should be checked elsewhere. */ 2993 2994 static int 2995 count_alternatives (rtx exp) 2996 { 2997 int i, j, n; 2998 const char *fmt; 2999 3000 if (GET_CODE (exp) == MATCH_OPERAND) 3001 return n_comma_elts (XSTR (exp, 2)); 3002 3003 for (i = 0, fmt = GET_RTX_FORMAT (GET_CODE (exp)); 3004 i < GET_RTX_LENGTH (GET_CODE (exp)); i++) 3005 switch (*fmt++) 3006 { 3007 case 'e': 3008 case 'u': 3009 n = count_alternatives (XEXP (exp, i)); 3010 if (n) 3011 return n; 3012 break; 3013 3014 case 'E': 3015 case 'V': 3016 if (XVEC (exp, i) != NULL) 3017 for (j = 0; j < XVECLEN (exp, i); j++) 3018 { 3019 n = count_alternatives (XVECEXP (exp, i, j)); 3020 if (n) 3021 return n; 3022 } 3023 } 3024 3025 return 0; 3026 } 3027 3028 /* Returns nonzero if the given expression contains an EQ_ATTR with the 3029 `alternative' attribute. */ 3030 3031 static int 3032 compares_alternatives_p (rtx exp) 3033 { 3034 int i, j; 3035 const char *fmt; 3036 3037 if (GET_CODE (exp) == EQ_ATTR && XSTR (exp, 0) == alternative_name) 3038 return 1; 3039 3040 for (i = 0, fmt = GET_RTX_FORMAT (GET_CODE (exp)); 3041 i < GET_RTX_LENGTH (GET_CODE (exp)); i++) 3042 switch (*fmt++) 3043 { 3044 case 'e': 3045 case 'u': 3046 if (compares_alternatives_p (XEXP (exp, i))) 3047 return 1; 3048 break; 3049 3050 case 'E': 3051 for (j = 0; j < XVECLEN (exp, i); j++) 3052 if (compares_alternatives_p (XVECEXP (exp, i, j))) 3053 return 1; 3054 break; 3055 } 3056 3057 return 0; 3058 } 3059 3060 /* Process DEFINE_PEEPHOLE, DEFINE_INSN, and DEFINE_ASM_ATTRIBUTES. */ 3061 3062 static void 3063 gen_insn (rtx exp, int lineno) 3064 { 3065 struct insn_def *id; 3066 3067 id = oballoc (struct insn_def); 3068 id->next = defs; 3069 defs = id; 3070 id->def = exp; 3071 id->lineno = lineno; 3072 3073 switch (GET_CODE (exp)) 3074 { 3075 case DEFINE_INSN: 3076 id->insn_code = insn_code_number; 3077 id->insn_index = insn_index_number; 3078 id->num_alternatives = count_alternatives (exp); 3079 if (id->num_alternatives == 0) 3080 id->num_alternatives = 1; 3081 id->vec_idx = 4; 3082 break; 3083 3084 case DEFINE_PEEPHOLE: 3085 id->insn_code = insn_code_number; 3086 id->insn_index = insn_index_number; 3087 id->num_alternatives = count_alternatives (exp); 3088 if (id->num_alternatives == 0) 3089 id->num_alternatives = 1; 3090 id->vec_idx = 3; 3091 break; 3092 3093 case DEFINE_ASM_ATTRIBUTES: 3094 id->insn_code = -1; 3095 id->insn_index = -1; 3096 id->num_alternatives = 1; 3097 id->vec_idx = 0; 3098 got_define_asm_attributes = 1; 3099 break; 3100 3101 default: 3102 gcc_unreachable (); 3103 } 3104 } 3105 3106 /* Process a DEFINE_DELAY. Validate the vector length, check if annul 3107 true or annul false is specified, and make a `struct delay_desc'. */ 3108 3109 static void 3110 gen_delay (rtx def, int lineno) 3111 { 3112 struct delay_desc *delay; 3113 int i; 3114 3115 if (XVECLEN (def, 1) % 3 != 0) 3116 { 3117 message_with_line (lineno, 3118 "number of elements in DEFINE_DELAY must be multiple of three"); 3119 have_error = 1; 3120 return; 3121 } 3122 3123 for (i = 0; i < XVECLEN (def, 1); i += 3) 3124 { 3125 if (XVECEXP (def, 1, i + 1)) 3126 have_annul_true = 1; 3127 if (XVECEXP (def, 1, i + 2)) 3128 have_annul_false = 1; 3129 } 3130 3131 delay = oballoc (struct delay_desc); 3132 delay->def = def; 3133 delay->num = ++num_delays; 3134 delay->next = delays; 3135 delay->lineno = lineno; 3136 delays = delay; 3137 } 3138 3139 /* Given a piece of RTX, print a C expression to test its truth value. 3140 We use AND and IOR both for logical and bit-wise operations, so 3141 interpret them as logical unless they are inside a comparison expression. 3142 The first bit of FLAGS will be nonzero in that case. 3143 3144 Set the second bit of FLAGS to make references to attribute values use 3145 a cached local variable instead of calling a function. */ 3146 3147 static void 3148 write_test_expr (rtx exp, int flags) 3149 { 3150 int comparison_operator = 0; 3151 RTX_CODE code; 3152 struct attr_desc *attr; 3153 3154 /* In order not to worry about operator precedence, surround our part of 3155 the expression with parentheses. */ 3156 3157 printf ("("); 3158 code = GET_CODE (exp); 3159 switch (code) 3160 { 3161 /* Binary operators. */ 3162 case GEU: case GTU: 3163 case LEU: case LTU: 3164 printf ("(unsigned) "); 3165 /* Fall through. */ 3166 3167 case EQ: case NE: 3168 case GE: case GT: 3169 case LE: case LT: 3170 comparison_operator = 1; 3171 3172 case PLUS: case MINUS: case MULT: case DIV: case MOD: 3173 case AND: case IOR: case XOR: 3174 case ASHIFT: case LSHIFTRT: case ASHIFTRT: 3175 write_test_expr (XEXP (exp, 0), flags | comparison_operator); 3176 switch (code) 3177 { 3178 case EQ: 3179 printf (" == "); 3180 break; 3181 case NE: 3182 printf (" != "); 3183 break; 3184 case GE: 3185 printf (" >= "); 3186 break; 3187 case GT: 3188 printf (" > "); 3189 break; 3190 case GEU: 3191 printf (" >= (unsigned) "); 3192 break; 3193 case GTU: 3194 printf (" > (unsigned) "); 3195 break; 3196 case LE: 3197 printf (" <= "); 3198 break; 3199 case LT: 3200 printf (" < "); 3201 break; 3202 case LEU: 3203 printf (" <= (unsigned) "); 3204 break; 3205 case LTU: 3206 printf (" < (unsigned) "); 3207 break; 3208 case PLUS: 3209 printf (" + "); 3210 break; 3211 case MINUS: 3212 printf (" - "); 3213 break; 3214 case MULT: 3215 printf (" * "); 3216 break; 3217 case DIV: 3218 printf (" / "); 3219 break; 3220 case MOD: 3221 printf (" %% "); 3222 break; 3223 case AND: 3224 if (flags & 1) 3225 printf (" & "); 3226 else 3227 printf (" && "); 3228 break; 3229 case IOR: 3230 if (flags & 1) 3231 printf (" | "); 3232 else 3233 printf (" || "); 3234 break; 3235 case XOR: 3236 printf (" ^ "); 3237 break; 3238 case ASHIFT: 3239 printf (" << "); 3240 break; 3241 case LSHIFTRT: 3242 case ASHIFTRT: 3243 printf (" >> "); 3244 break; 3245 default: 3246 gcc_unreachable (); 3247 } 3248 3249 write_test_expr (XEXP (exp, 1), flags | comparison_operator); 3250 break; 3251 3252 case NOT: 3253 /* Special-case (not (eq_attrq "alternative" "x")) */ 3254 if (! (flags & 1) && GET_CODE (XEXP (exp, 0)) == EQ_ATTR 3255 && XSTR (XEXP (exp, 0), 0) == alternative_name) 3256 { 3257 printf ("which_alternative != %s", XSTR (XEXP (exp, 0), 1)); 3258 break; 3259 } 3260 3261 /* Otherwise, fall through to normal unary operator. */ 3262 3263 /* Unary operators. */ 3264 case ABS: case NEG: 3265 switch (code) 3266 { 3267 case NOT: 3268 if (flags & 1) 3269 printf ("~ "); 3270 else 3271 printf ("! "); 3272 break; 3273 case ABS: 3274 printf ("abs "); 3275 break; 3276 case NEG: 3277 printf ("-"); 3278 break; 3279 default: 3280 gcc_unreachable (); 3281 } 3282 3283 write_test_expr (XEXP (exp, 0), flags); 3284 break; 3285 3286 case EQ_ATTR_ALT: 3287 { 3288 int set = XINT (exp, 0), bit = 0; 3289 3290 if (flags & 1) 3291 fatal ("EQ_ATTR_ALT not valid inside comparison"); 3292 3293 if (!set) 3294 fatal ("Empty EQ_ATTR_ALT should be optimized out"); 3295 3296 if (!(set & (set - 1))) 3297 { 3298 if (!(set & 0xffff)) 3299 { 3300 bit += 16; 3301 set >>= 16; 3302 } 3303 if (!(set & 0xff)) 3304 { 3305 bit += 8; 3306 set >>= 8; 3307 } 3308 if (!(set & 0xf)) 3309 { 3310 bit += 4; 3311 set >>= 4; 3312 } 3313 if (!(set & 0x3)) 3314 { 3315 bit += 2; 3316 set >>= 2; 3317 } 3318 if (!(set & 1)) 3319 bit++; 3320 3321 printf ("which_alternative %s= %d", 3322 XINT (exp, 1) ? "!" : "=", bit); 3323 } 3324 else 3325 { 3326 printf ("%s((1 << which_alternative) & 0x%x)", 3327 XINT (exp, 1) ? "!" : "", set); 3328 } 3329 } 3330 break; 3331 3332 /* Comparison test of an attribute with a value. Most of these will 3333 have been removed by optimization. Handle "alternative" 3334 specially and give error if EQ_ATTR present inside a comparison. */ 3335 case EQ_ATTR: 3336 if (flags & 1) 3337 fatal ("EQ_ATTR not valid inside comparison"); 3338 3339 if (XSTR (exp, 0) == alternative_name) 3340 { 3341 printf ("which_alternative == %s", XSTR (exp, 1)); 3342 break; 3343 } 3344 3345 attr = find_attr (&XSTR (exp, 0), 0); 3346 gcc_assert (attr); 3347 3348 /* Now is the time to expand the value of a constant attribute. */ 3349 if (attr->is_const) 3350 { 3351 write_test_expr (evaluate_eq_attr (exp, attr->default_val->value, 3352 -2, -2), 3353 flags); 3354 } 3355 else 3356 { 3357 if (flags & 2) 3358 printf ("attr_%s", attr->name); 3359 else 3360 printf ("get_attr_%s (insn)", attr->name); 3361 printf (" == "); 3362 write_attr_valueq (attr, XSTR (exp, 1)); 3363 } 3364 break; 3365 3366 /* Comparison test of flags for define_delays. */ 3367 case ATTR_FLAG: 3368 if (flags & 1) 3369 fatal ("ATTR_FLAG not valid inside comparison"); 3370 printf ("(flags & ATTR_FLAG_%s) != 0", XSTR (exp, 0)); 3371 break; 3372 3373 /* See if an operand matches a predicate. */ 3374 case MATCH_OPERAND: 3375 /* If only a mode is given, just ensure the mode matches the operand. 3376 If neither a mode nor predicate is given, error. */ 3377 if (XSTR (exp, 1) == NULL || *XSTR (exp, 1) == '\0') 3378 { 3379 if (GET_MODE (exp) == VOIDmode) 3380 fatal ("null MATCH_OPERAND specified as test"); 3381 else 3382 printf ("GET_MODE (operands[%d]) == %smode", 3383 XINT (exp, 0), GET_MODE_NAME (GET_MODE (exp))); 3384 } 3385 else 3386 printf ("%s (operands[%d], %smode)", 3387 XSTR (exp, 1), XINT (exp, 0), GET_MODE_NAME (GET_MODE (exp))); 3388 break; 3389 3390 /* Constant integer. */ 3391 case CONST_INT: 3392 printf (HOST_WIDE_INT_PRINT_DEC, XWINT (exp, 0)); 3393 break; 3394 3395 /* A random C expression. */ 3396 case SYMBOL_REF: 3397 print_c_condition (XSTR (exp, 0)); 3398 break; 3399 3400 /* The address of the branch target. */ 3401 case MATCH_DUP: 3402 printf ("INSN_ADDRESSES_SET_P () ? INSN_ADDRESSES (INSN_UID (GET_CODE (operands[%d]) == LABEL_REF ? XEXP (operands[%d], 0) : operands[%d])) : 0", 3403 XINT (exp, 0), XINT (exp, 0), XINT (exp, 0)); 3404 break; 3405 3406 case PC: 3407 /* The address of the current insn. We implement this actually as the 3408 address of the current insn for backward branches, but the last 3409 address of the next insn for forward branches, and both with 3410 adjustments that account for the worst-case possible stretching of 3411 intervening alignments between this insn and its destination. */ 3412 printf ("insn_current_reference_address (insn)"); 3413 break; 3414 3415 case CONST_STRING: 3416 printf ("%s", XSTR (exp, 0)); 3417 break; 3418 3419 case IF_THEN_ELSE: 3420 write_test_expr (XEXP (exp, 0), flags & 2); 3421 printf (" ? "); 3422 write_test_expr (XEXP (exp, 1), flags | 1); 3423 printf (" : "); 3424 write_test_expr (XEXP (exp, 2), flags | 1); 3425 break; 3426 3427 default: 3428 fatal ("bad RTX code `%s' in attribute calculation\n", 3429 GET_RTX_NAME (code)); 3430 } 3431 3432 printf (")"); 3433 } 3434 3435 /* Given an attribute value, return the maximum CONST_STRING argument 3436 encountered. Set *UNKNOWNP and return INT_MAX if the value is unknown. */ 3437 3438 static int 3439 max_attr_value (rtx exp, int *unknownp) 3440 { 3441 int current_max; 3442 int i, n; 3443 3444 switch (GET_CODE (exp)) 3445 { 3446 case CONST_STRING: 3447 current_max = atoi (XSTR (exp, 0)); 3448 break; 3449 3450 case COND: 3451 current_max = max_attr_value (XEXP (exp, 1), unknownp); 3452 for (i = 0; i < XVECLEN (exp, 0); i += 2) 3453 { 3454 n = max_attr_value (XVECEXP (exp, 0, i + 1), unknownp); 3455 if (n > current_max) 3456 current_max = n; 3457 } 3458 break; 3459 3460 case IF_THEN_ELSE: 3461 current_max = max_attr_value (XEXP (exp, 1), unknownp); 3462 n = max_attr_value (XEXP (exp, 2), unknownp); 3463 if (n > current_max) 3464 current_max = n; 3465 break; 3466 3467 default: 3468 *unknownp = 1; 3469 current_max = INT_MAX; 3470 break; 3471 } 3472 3473 return current_max; 3474 } 3475 3476 /* Given an attribute value, return the minimum CONST_STRING argument 3477 encountered. Set *UNKNOWNP and return 0 if the value is unknown. */ 3478 3479 static int 3480 min_attr_value (rtx exp, int *unknownp) 3481 { 3482 int current_min; 3483 int i, n; 3484 3485 switch (GET_CODE (exp)) 3486 { 3487 case CONST_STRING: 3488 current_min = atoi (XSTR (exp, 0)); 3489 break; 3490 3491 case COND: 3492 current_min = min_attr_value (XEXP (exp, 1), unknownp); 3493 for (i = 0; i < XVECLEN (exp, 0); i += 2) 3494 { 3495 n = min_attr_value (XVECEXP (exp, 0, i + 1), unknownp); 3496 if (n < current_min) 3497 current_min = n; 3498 } 3499 break; 3500 3501 case IF_THEN_ELSE: 3502 current_min = min_attr_value (XEXP (exp, 1), unknownp); 3503 n = min_attr_value (XEXP (exp, 2), unknownp); 3504 if (n < current_min) 3505 current_min = n; 3506 break; 3507 3508 default: 3509 *unknownp = 1; 3510 current_min = INT_MAX; 3511 break; 3512 } 3513 3514 return current_min; 3515 } 3516 3517 /* Given an attribute value, return the result of ORing together all 3518 CONST_STRING arguments encountered. Set *UNKNOWNP and return -1 3519 if the numeric value is not known. */ 3520 3521 static int 3522 or_attr_value (rtx exp, int *unknownp) 3523 { 3524 int current_or; 3525 int i; 3526 3527 switch (GET_CODE (exp)) 3528 { 3529 case CONST_STRING: 3530 current_or = atoi (XSTR (exp, 0)); 3531 break; 3532 3533 case COND: 3534 current_or = or_attr_value (XEXP (exp, 1), unknownp); 3535 for (i = 0; i < XVECLEN (exp, 0); i += 2) 3536 current_or |= or_attr_value (XVECEXP (exp, 0, i + 1), unknownp); 3537 break; 3538 3539 case IF_THEN_ELSE: 3540 current_or = or_attr_value (XEXP (exp, 1), unknownp); 3541 current_or |= or_attr_value (XEXP (exp, 2), unknownp); 3542 break; 3543 3544 default: 3545 *unknownp = 1; 3546 current_or = -1; 3547 break; 3548 } 3549 3550 return current_or; 3551 } 3552 3553 /* Scan an attribute value, possibly a conditional, and record what actions 3554 will be required to do any conditional tests in it. 3555 3556 Specifically, set 3557 `must_extract' if we need to extract the insn operands 3558 `must_constrain' if we must compute `which_alternative' 3559 `address_used' if an address expression was used 3560 `length_used' if an (eq_attr "length" ...) was used 3561 */ 3562 3563 static void 3564 walk_attr_value (rtx exp) 3565 { 3566 int i, j; 3567 const char *fmt; 3568 RTX_CODE code; 3569 3570 if (exp == NULL) 3571 return; 3572 3573 code = GET_CODE (exp); 3574 switch (code) 3575 { 3576 case SYMBOL_REF: 3577 if (! ATTR_IND_SIMPLIFIED_P (exp)) 3578 /* Since this is an arbitrary expression, it can look at anything. 3579 However, constant expressions do not depend on any particular 3580 insn. */ 3581 must_extract = must_constrain = 1; 3582 return; 3583 3584 case MATCH_OPERAND: 3585 must_extract = 1; 3586 return; 3587 3588 case EQ_ATTR_ALT: 3589 must_extract = must_constrain = 1; 3590 break; 3591 3592 case EQ_ATTR: 3593 if (XSTR (exp, 0) == alternative_name) 3594 must_extract = must_constrain = 1; 3595 else if (strcmp_check (XSTR (exp, 0), length_str) == 0) 3596 length_used = 1; 3597 return; 3598 3599 case MATCH_DUP: 3600 must_extract = 1; 3601 address_used = 1; 3602 return; 3603 3604 case PC: 3605 address_used = 1; 3606 return; 3607 3608 case ATTR_FLAG: 3609 return; 3610 3611 default: 3612 break; 3613 } 3614 3615 for (i = 0, fmt = GET_RTX_FORMAT (code); i < GET_RTX_LENGTH (code); i++) 3616 switch (*fmt++) 3617 { 3618 case 'e': 3619 case 'u': 3620 walk_attr_value (XEXP (exp, i)); 3621 break; 3622 3623 case 'E': 3624 if (XVEC (exp, i) != NULL) 3625 for (j = 0; j < XVECLEN (exp, i); j++) 3626 walk_attr_value (XVECEXP (exp, i, j)); 3627 break; 3628 } 3629 } 3630 3631 /* Write out a function to obtain the attribute for a given INSN. */ 3632 3633 static void 3634 write_attr_get (struct attr_desc *attr) 3635 { 3636 struct attr_value *av, *common_av; 3637 3638 /* Find the most used attribute value. Handle that as the `default' of the 3639 switch we will generate. */ 3640 common_av = find_most_used (attr); 3641 3642 /* Write out start of function, then all values with explicit `case' lines, 3643 then a `default', then the value with the most uses. */ 3644 if (!attr->is_numeric) 3645 printf ("enum attr_%s\n", attr->name); 3646 else 3647 printf ("int\n"); 3648 3649 /* If the attribute name starts with a star, the remainder is the name of 3650 the subroutine to use, instead of `get_attr_...'. */ 3651 if (attr->name[0] == '*') 3652 printf ("%s (rtx insn ATTRIBUTE_UNUSED)\n", &attr->name[1]); 3653 else if (attr->is_const == 0) 3654 printf ("get_attr_%s (rtx insn ATTRIBUTE_UNUSED)\n", attr->name); 3655 else 3656 { 3657 printf ("get_attr_%s (void)\n", attr->name); 3658 printf ("{\n"); 3659 3660 for (av = attr->first_value; av; av = av->next) 3661 if (av->num_insns == 1) 3662 write_attr_set (attr, 2, av->value, "return", ";", 3663 true_rtx, av->first_insn->def->insn_code, 3664 av->first_insn->def->insn_index); 3665 else if (av->num_insns != 0) 3666 write_attr_set (attr, 2, av->value, "return", ";", 3667 true_rtx, -2, 0); 3668 3669 printf ("}\n\n"); 3670 return; 3671 } 3672 3673 printf ("{\n"); 3674 printf (" switch (recog_memoized (insn))\n"); 3675 printf (" {\n"); 3676 3677 for (av = attr->first_value; av; av = av->next) 3678 if (av != common_av) 3679 write_attr_case (attr, av, 1, "return", ";", 4, true_rtx); 3680 3681 write_attr_case (attr, common_av, 0, "return", ";", 4, true_rtx); 3682 printf (" }\n}\n\n"); 3683 } 3684 3685 /* Given an AND tree of known true terms (because we are inside an `if' with 3686 that as the condition or are in an `else' clause) and an expression, 3687 replace any known true terms with TRUE. Use `simplify_and_tree' to do 3688 the bulk of the work. */ 3689 3690 static rtx 3691 eliminate_known_true (rtx known_true, rtx exp, int insn_code, int insn_index) 3692 { 3693 rtx term; 3694 3695 known_true = SIMPLIFY_TEST_EXP (known_true, insn_code, insn_index); 3696 3697 if (GET_CODE (known_true) == AND) 3698 { 3699 exp = eliminate_known_true (XEXP (known_true, 0), exp, 3700 insn_code, insn_index); 3701 exp = eliminate_known_true (XEXP (known_true, 1), exp, 3702 insn_code, insn_index); 3703 } 3704 else 3705 { 3706 term = known_true; 3707 exp = simplify_and_tree (exp, &term, insn_code, insn_index); 3708 } 3709 3710 return exp; 3711 } 3712 3713 /* Write out a series of tests and assignment statements to perform tests and 3714 sets of an attribute value. We are passed an indentation amount and prefix 3715 and suffix strings to write around each attribute value (e.g., "return" 3716 and ";"). */ 3717 3718 static void 3719 write_attr_set (struct attr_desc *attr, int indent, rtx value, 3720 const char *prefix, const char *suffix, rtx known_true, 3721 int insn_code, int insn_index) 3722 { 3723 if (GET_CODE (value) == COND) 3724 { 3725 /* Assume the default value will be the default of the COND unless we 3726 find an always true expression. */ 3727 rtx default_val = XEXP (value, 1); 3728 rtx our_known_true = known_true; 3729 rtx newexp; 3730 int first_if = 1; 3731 int i; 3732 3733 for (i = 0; i < XVECLEN (value, 0); i += 2) 3734 { 3735 rtx testexp; 3736 rtx inner_true; 3737 3738 testexp = eliminate_known_true (our_known_true, 3739 XVECEXP (value, 0, i), 3740 insn_code, insn_index); 3741 newexp = attr_rtx (NOT, testexp); 3742 newexp = insert_right_side (AND, our_known_true, newexp, 3743 insn_code, insn_index); 3744 3745 /* If the test expression is always true or if the next `known_true' 3746 expression is always false, this is the last case, so break 3747 out and let this value be the `else' case. */ 3748 if (testexp == true_rtx || newexp == false_rtx) 3749 { 3750 default_val = XVECEXP (value, 0, i + 1); 3751 break; 3752 } 3753 3754 /* Compute the expression to pass to our recursive call as being 3755 known true. */ 3756 inner_true = insert_right_side (AND, our_known_true, 3757 testexp, insn_code, insn_index); 3758 3759 /* If this is always false, skip it. */ 3760 if (inner_true == false_rtx) 3761 continue; 3762 3763 write_indent (indent); 3764 printf ("%sif ", first_if ? "" : "else "); 3765 first_if = 0; 3766 write_test_expr (testexp, 0); 3767 printf ("\n"); 3768 write_indent (indent + 2); 3769 printf ("{\n"); 3770 3771 write_attr_set (attr, indent + 4, 3772 XVECEXP (value, 0, i + 1), prefix, suffix, 3773 inner_true, insn_code, insn_index); 3774 write_indent (indent + 2); 3775 printf ("}\n"); 3776 our_known_true = newexp; 3777 } 3778 3779 if (! first_if) 3780 { 3781 write_indent (indent); 3782 printf ("else\n"); 3783 write_indent (indent + 2); 3784 printf ("{\n"); 3785 } 3786 3787 write_attr_set (attr, first_if ? indent : indent + 4, default_val, 3788 prefix, suffix, our_known_true, insn_code, insn_index); 3789 3790 if (! first_if) 3791 { 3792 write_indent (indent + 2); 3793 printf ("}\n"); 3794 } 3795 } 3796 else 3797 { 3798 write_indent (indent); 3799 printf ("%s ", prefix); 3800 write_attr_value (attr, value); 3801 printf ("%s\n", suffix); 3802 } 3803 } 3804 3805 /* Write a series of case statements for every instruction in list IE. 3806 INDENT is the amount of indentation to write before each case. */ 3807 3808 static void 3809 write_insn_cases (struct insn_ent *ie, int indent) 3810 { 3811 for (; ie != 0; ie = ie->next) 3812 if (ie->def->insn_code != -1) 3813 { 3814 write_indent (indent); 3815 if (GET_CODE (ie->def->def) == DEFINE_PEEPHOLE) 3816 printf ("case %d: /* define_peephole, line %d */\n", 3817 ie->def->insn_code, ie->def->lineno); 3818 else 3819 printf ("case %d: /* %s */\n", 3820 ie->def->insn_code, XSTR (ie->def->def, 0)); 3821 } 3822 } 3823 3824 /* Write out the computation for one attribute value. */ 3825 3826 static void 3827 write_attr_case (struct attr_desc *attr, struct attr_value *av, 3828 int write_case_lines, const char *prefix, const char *suffix, 3829 int indent, rtx known_true) 3830 { 3831 if (av->num_insns == 0) 3832 return; 3833 3834 if (av->has_asm_insn) 3835 { 3836 write_indent (indent); 3837 printf ("case -1:\n"); 3838 write_indent (indent + 2); 3839 printf ("if (GET_CODE (PATTERN (insn)) != ASM_INPUT\n"); 3840 write_indent (indent + 2); 3841 printf (" && asm_noperands (PATTERN (insn)) < 0)\n"); 3842 write_indent (indent + 2); 3843 printf (" fatal_insn_not_found (insn);\n"); 3844 } 3845 3846 if (write_case_lines) 3847 write_insn_cases (av->first_insn, indent); 3848 else 3849 { 3850 write_indent (indent); 3851 printf ("default:\n"); 3852 } 3853 3854 /* See what we have to do to output this value. */ 3855 must_extract = must_constrain = address_used = 0; 3856 walk_attr_value (av->value); 3857 3858 if (must_constrain) 3859 { 3860 write_indent (indent + 2); 3861 printf ("extract_constrain_insn_cached (insn);\n"); 3862 } 3863 else if (must_extract) 3864 { 3865 write_indent (indent + 2); 3866 printf ("extract_insn_cached (insn);\n"); 3867 } 3868 3869 if (av->num_insns == 1) 3870 write_attr_set (attr, indent + 2, av->value, prefix, suffix, 3871 known_true, av->first_insn->def->insn_code, 3872 av->first_insn->def->insn_index); 3873 else 3874 write_attr_set (attr, indent + 2, av->value, prefix, suffix, 3875 known_true, -2, 0); 3876 3877 if (strncmp (prefix, "return", 6)) 3878 { 3879 write_indent (indent + 2); 3880 printf ("break;\n"); 3881 } 3882 printf ("\n"); 3883 } 3884 3885 /* Utilities to write in various forms. */ 3886 3887 static void 3888 write_attr_valueq (struct attr_desc *attr, const char *s) 3889 { 3890 if (attr->is_numeric) 3891 { 3892 int num = atoi (s); 3893 3894 printf ("%d", num); 3895 3896 if (num > 9 || num < 0) 3897 printf (" /* 0x%x */", num); 3898 } 3899 else 3900 { 3901 write_upcase (attr->name); 3902 printf ("_"); 3903 write_upcase (s); 3904 } 3905 } 3906 3907 static void 3908 write_attr_value (struct attr_desc *attr, rtx value) 3909 { 3910 int op; 3911 3912 switch (GET_CODE (value)) 3913 { 3914 case CONST_STRING: 3915 write_attr_valueq (attr, XSTR (value, 0)); 3916 break; 3917 3918 case CONST_INT: 3919 printf (HOST_WIDE_INT_PRINT_DEC, INTVAL (value)); 3920 break; 3921 3922 case SYMBOL_REF: 3923 print_c_condition (XSTR (value, 0)); 3924 break; 3925 3926 case ATTR: 3927 { 3928 struct attr_desc *attr2 = find_attr (&XSTR (value, 0), 0); 3929 printf ("get_attr_%s (%s)", attr2->name, 3930 (attr2->is_const ? "" : "insn")); 3931 } 3932 break; 3933 3934 case PLUS: 3935 op = '+'; 3936 goto do_operator; 3937 case MINUS: 3938 op = '-'; 3939 goto do_operator; 3940 case MULT: 3941 op = '*'; 3942 goto do_operator; 3943 case DIV: 3944 op = '/'; 3945 goto do_operator; 3946 case MOD: 3947 op = '%'; 3948 goto do_operator; 3949 3950 do_operator: 3951 write_attr_value (attr, XEXP (value, 0)); 3952 putchar (' '); 3953 putchar (op); 3954 putchar (' '); 3955 write_attr_value (attr, XEXP (value, 1)); 3956 break; 3957 3958 default: 3959 gcc_unreachable (); 3960 } 3961 } 3962 3963 static void 3964 write_upcase (const char *str) 3965 { 3966 while (*str) 3967 { 3968 /* The argument of TOUPPER should not have side effects. */ 3969 putchar (TOUPPER(*str)); 3970 str++; 3971 } 3972 } 3973 3974 static void 3975 write_indent (int indent) 3976 { 3977 for (; indent > 8; indent -= 8) 3978 printf ("\t"); 3979 3980 for (; indent; indent--) 3981 printf (" "); 3982 } 3983 3984 /* Write a subroutine that is given an insn that requires a delay slot, a 3985 delay slot ordinal, and a candidate insn. It returns nonzero if the 3986 candidate can be placed in the specified delay slot of the insn. 3987 3988 We can write as many as three subroutines. `eligible_for_delay' 3989 handles normal delay slots, `eligible_for_annul_true' indicates that 3990 the specified insn can be annulled if the branch is true, and likewise 3991 for `eligible_for_annul_false'. 3992 3993 KIND is a string distinguishing these three cases ("delay", "annul_true", 3994 or "annul_false"). */ 3995 3996 static void 3997 write_eligible_delay (const char *kind) 3998 { 3999 struct delay_desc *delay; 4000 int max_slots; 4001 char str[50]; 4002 const char *pstr; 4003 struct attr_desc *attr; 4004 struct attr_value *av, *common_av; 4005 int i; 4006 4007 /* Compute the maximum number of delay slots required. We use the delay 4008 ordinal times this number plus one, plus the slot number as an index into 4009 the appropriate predicate to test. */ 4010 4011 for (delay = delays, max_slots = 0; delay; delay = delay->next) 4012 if (XVECLEN (delay->def, 1) / 3 > max_slots) 4013 max_slots = XVECLEN (delay->def, 1) / 3; 4014 4015 /* Write function prelude. */ 4016 4017 printf ("int\n"); 4018 printf ("eligible_for_%s (rtx delay_insn ATTRIBUTE_UNUSED, int slot, rtx candidate_insn, int flags ATTRIBUTE_UNUSED)\n", 4019 kind); 4020 printf ("{\n"); 4021 printf (" rtx insn;\n"); 4022 printf ("\n"); 4023 printf (" gcc_assert (slot < %d);\n", max_slots); 4024 printf ("\n"); 4025 /* Allow dbr_schedule to pass labels, etc. This can happen if try_split 4026 converts a compound instruction into a loop. */ 4027 printf (" if (!INSN_P (candidate_insn))\n"); 4028 printf (" return 0;\n"); 4029 printf ("\n"); 4030 4031 /* If more than one delay type, find out which type the delay insn is. */ 4032 4033 if (num_delays > 1) 4034 { 4035 attr = find_attr (&delay_type_str, 0); 4036 gcc_assert (attr); 4037 common_av = find_most_used (attr); 4038 4039 printf (" insn = delay_insn;\n"); 4040 printf (" switch (recog_memoized (insn))\n"); 4041 printf (" {\n"); 4042 4043 sprintf (str, " * %d;\n break;", max_slots); 4044 for (av = attr->first_value; av; av = av->next) 4045 if (av != common_av) 4046 write_attr_case (attr, av, 1, "slot +=", str, 4, true_rtx); 4047 4048 write_attr_case (attr, common_av, 0, "slot +=", str, 4, true_rtx); 4049 printf (" }\n\n"); 4050 4051 /* Ensure matched. Otherwise, shouldn't have been called. */ 4052 printf (" gcc_assert (slot >= %d);\n\n", max_slots); 4053 } 4054 4055 /* If just one type of delay slot, write simple switch. */ 4056 if (num_delays == 1 && max_slots == 1) 4057 { 4058 printf (" insn = candidate_insn;\n"); 4059 printf (" switch (recog_memoized (insn))\n"); 4060 printf (" {\n"); 4061 4062 attr = find_attr (&delay_1_0_str, 0); 4063 gcc_assert (attr); 4064 common_av = find_most_used (attr); 4065 4066 for (av = attr->first_value; av; av = av->next) 4067 if (av != common_av) 4068 write_attr_case (attr, av, 1, "return", ";", 4, true_rtx); 4069 4070 write_attr_case (attr, common_av, 0, "return", ";", 4, true_rtx); 4071 printf (" }\n"); 4072 } 4073 4074 else 4075 { 4076 /* Write a nested CASE. The first indicates which condition we need to 4077 test, and the inner CASE tests the condition. */ 4078 printf (" insn = candidate_insn;\n"); 4079 printf (" switch (slot)\n"); 4080 printf (" {\n"); 4081 4082 for (delay = delays; delay; delay = delay->next) 4083 for (i = 0; i < XVECLEN (delay->def, 1); i += 3) 4084 { 4085 printf (" case %d:\n", 4086 (i / 3) + (num_delays == 1 ? 0 : delay->num * max_slots)); 4087 printf (" switch (recog_memoized (insn))\n"); 4088 printf ("\t{\n"); 4089 4090 sprintf (str, "*%s_%d_%d", kind, delay->num, i / 3); 4091 pstr = str; 4092 attr = find_attr (&pstr, 0); 4093 gcc_assert (attr); 4094 common_av = find_most_used (attr); 4095 4096 for (av = attr->first_value; av; av = av->next) 4097 if (av != common_av) 4098 write_attr_case (attr, av, 1, "return", ";", 8, true_rtx); 4099 4100 write_attr_case (attr, common_av, 0, "return", ";", 8, true_rtx); 4101 printf (" }\n"); 4102 } 4103 4104 printf (" default:\n"); 4105 printf (" gcc_unreachable ();\n"); 4106 printf (" }\n"); 4107 } 4108 4109 printf ("}\n\n"); 4110 } 4111 4112 /* This page contains miscellaneous utility routines. */ 4113 4114 /* Given a pointer to a (char *), return a malloc'ed string containing the 4115 next comma-separated element. Advance the pointer to after the string 4116 scanned, or the end-of-string. Return NULL if at end of string. */ 4117 4118 static char * 4119 next_comma_elt (const char **pstr) 4120 { 4121 const char *start; 4122 4123 start = scan_comma_elt (pstr); 4124 4125 if (start == NULL) 4126 return NULL; 4127 4128 return attr_string (start, *pstr - start); 4129 } 4130 4131 /* Return a `struct attr_desc' pointer for a given named attribute. If CREATE 4132 is nonzero, build a new attribute, if one does not exist. *NAME_P is 4133 replaced by a pointer to a canonical copy of the string. */ 4134 4135 static struct attr_desc * 4136 find_attr (const char **name_p, int create) 4137 { 4138 struct attr_desc *attr; 4139 int index; 4140 const char *name = *name_p; 4141 4142 /* Before we resort to using `strcmp', see if the string address matches 4143 anywhere. In most cases, it should have been canonicalized to do so. */ 4144 if (name == alternative_name) 4145 return NULL; 4146 4147 index = name[0] & (MAX_ATTRS_INDEX - 1); 4148 for (attr = attrs[index]; attr; attr = attr->next) 4149 if (name == attr->name) 4150 return attr; 4151 4152 /* Otherwise, do it the slow way. */ 4153 for (attr = attrs[index]; attr; attr = attr->next) 4154 if (name[0] == attr->name[0] && ! strcmp (name, attr->name)) 4155 { 4156 *name_p = attr->name; 4157 return attr; 4158 } 4159 4160 if (! create) 4161 return NULL; 4162 4163 attr = oballoc (struct attr_desc); 4164 attr->name = DEF_ATTR_STRING (name); 4165 attr->first_value = attr->default_val = NULL; 4166 attr->is_numeric = attr->is_const = attr->is_special = 0; 4167 attr->next = attrs[index]; 4168 attrs[index] = attr; 4169 4170 *name_p = attr->name; 4171 4172 return attr; 4173 } 4174 4175 /* Create internal attribute with the given default value. */ 4176 4177 static void 4178 make_internal_attr (const char *name, rtx value, int special) 4179 { 4180 struct attr_desc *attr; 4181 4182 attr = find_attr (&name, 1); 4183 gcc_assert (!attr->default_val); 4184 4185 attr->is_numeric = 1; 4186 attr->is_const = 0; 4187 attr->is_special = (special & ATTR_SPECIAL) != 0; 4188 attr->default_val = get_attr_value (value, attr, -2); 4189 } 4190 4191 /* Find the most used value of an attribute. */ 4192 4193 static struct attr_value * 4194 find_most_used (struct attr_desc *attr) 4195 { 4196 struct attr_value *av; 4197 struct attr_value *most_used; 4198 int nuses; 4199 4200 most_used = NULL; 4201 nuses = -1; 4202 4203 for (av = attr->first_value; av; av = av->next) 4204 if (av->num_insns > nuses) 4205 nuses = av->num_insns, most_used = av; 4206 4207 return most_used; 4208 } 4209 4210 /* Return (attr_value "n") */ 4211 4212 static rtx 4213 make_numeric_value (int n) 4214 { 4215 static rtx int_values[20]; 4216 rtx exp; 4217 char *p; 4218 4219 gcc_assert (n >= 0); 4220 4221 if (n < 20 && int_values[n]) 4222 return int_values[n]; 4223 4224 p = attr_printf (MAX_DIGITS, "%d", n); 4225 exp = attr_rtx (CONST_STRING, p); 4226 4227 if (n < 20) 4228 int_values[n] = exp; 4229 4230 return exp; 4231 } 4232 4233 static rtx 4234 copy_rtx_unchanging (rtx orig) 4235 { 4236 if (ATTR_IND_SIMPLIFIED_P (orig) || ATTR_CURR_SIMPLIFIED_P (orig)) 4237 return orig; 4238 4239 ATTR_CURR_SIMPLIFIED_P (orig) = 1; 4240 return orig; 4241 } 4242 4243 /* Determine if an insn has a constant number of delay slots, i.e., the 4244 number of delay slots is not a function of the length of the insn. */ 4245 4246 static void 4247 write_const_num_delay_slots (void) 4248 { 4249 struct attr_desc *attr = find_attr (&num_delay_slots_str, 0); 4250 struct attr_value *av; 4251 4252 if (attr) 4253 { 4254 printf ("int\nconst_num_delay_slots (rtx insn)\n"); 4255 printf ("{\n"); 4256 printf (" switch (recog_memoized (insn))\n"); 4257 printf (" {\n"); 4258 4259 for (av = attr->first_value; av; av = av->next) 4260 { 4261 length_used = 0; 4262 walk_attr_value (av->value); 4263 if (length_used) 4264 write_insn_cases (av->first_insn, 4); 4265 } 4266 4267 printf (" default:\n"); 4268 printf (" return 1;\n"); 4269 printf (" }\n}\n\n"); 4270 } 4271 } 4272 4273 /* Synthetic attributes used by insn-automata.c and the scheduler. 4274 These are primarily concerned with (define_insn_reservation) 4275 patterns. */ 4276 4277 struct insn_reserv 4278 { 4279 struct insn_reserv *next; 4280 4281 const char *name; 4282 int default_latency; 4283 rtx condexp; 4284 4285 /* Sequence number of this insn. */ 4286 int insn_num; 4287 4288 /* Whether a (define_bypass) construct names this insn in its 4289 output list. */ 4290 bool bypassed; 4291 }; 4292 4293 static struct insn_reserv *all_insn_reservs = 0; 4294 static struct insn_reserv **last_insn_reserv_p = &all_insn_reservs; 4295 static size_t n_insn_reservs; 4296 4297 /* Store information from a DEFINE_INSN_RESERVATION for future 4298 attribute generation. */ 4299 static void 4300 gen_insn_reserv (rtx def) 4301 { 4302 struct insn_reserv *decl = oballoc (struct insn_reserv); 4303 4304 decl->name = DEF_ATTR_STRING (XSTR (def, 0)); 4305 decl->default_latency = XINT (def, 1); 4306 decl->condexp = check_attr_test (XEXP (def, 2), 0, 0); 4307 decl->insn_num = n_insn_reservs; 4308 decl->bypassed = false; 4309 decl->next = 0; 4310 4311 *last_insn_reserv_p = decl; 4312 last_insn_reserv_p = &decl->next; 4313 n_insn_reservs++; 4314 } 4315 4316 /* Store information from a DEFINE_BYPASS for future attribute 4317 generation. The only thing we care about is the list of output 4318 insns, which will later be used to tag reservation structures with 4319 a 'bypassed' bit. */ 4320 4321 struct bypass_list 4322 { 4323 struct bypass_list *next; 4324 const char *insn; 4325 }; 4326 4327 static struct bypass_list *all_bypasses; 4328 static size_t n_bypasses; 4329 4330 static void 4331 gen_bypass_1 (const char *s, size_t len) 4332 { 4333 struct bypass_list *b; 4334 4335 if (len == 0) 4336 return; 4337 4338 s = attr_string (s, len); 4339 for (b = all_bypasses; b; b = b->next) 4340 if (s == b->insn) 4341 return; /* already got that one */ 4342 4343 b = oballoc (struct bypass_list); 4344 b->insn = s; 4345 b->next = all_bypasses; 4346 all_bypasses = b; 4347 n_bypasses++; 4348 } 4349 4350 static void 4351 gen_bypass (rtx def) 4352 { 4353 const char *p, *base; 4354 4355 for (p = base = XSTR (def, 1); *p; p++) 4356 if (*p == ',') 4357 { 4358 gen_bypass_1 (base, p - base); 4359 do 4360 p++; 4361 while (ISSPACE (*p)); 4362 base = p; 4363 } 4364 gen_bypass_1 (base, p - base); 4365 } 4366 4367 /* Find and mark all of the bypassed insns. */ 4368 static void 4369 process_bypasses (void) 4370 { 4371 struct bypass_list *b; 4372 struct insn_reserv *r; 4373 4374 /* The reservation list is likely to be much longer than the bypass 4375 list. */ 4376 for (r = all_insn_reservs; r; r = r->next) 4377 for (b = all_bypasses; b; b = b->next) 4378 if (r->name == b->insn) 4379 r->bypassed = true; 4380 } 4381 4382 /* Create all of the attributes that describe automaton properties. */ 4383 static void 4384 make_automaton_attrs (void) 4385 { 4386 int i; 4387 struct insn_reserv *decl; 4388 rtx code_exp, lats_exp, byps_exp; 4389 4390 if (n_insn_reservs == 0) 4391 return; 4392 4393 code_exp = rtx_alloc (COND); 4394 lats_exp = rtx_alloc (COND); 4395 4396 XVEC (code_exp, 0) = rtvec_alloc (n_insn_reservs * 2); 4397 XVEC (lats_exp, 0) = rtvec_alloc (n_insn_reservs * 2); 4398 4399 XEXP (code_exp, 1) = make_numeric_value (n_insn_reservs + 1); 4400 XEXP (lats_exp, 1) = make_numeric_value (0); 4401 4402 for (decl = all_insn_reservs, i = 0; 4403 decl; 4404 decl = decl->next, i += 2) 4405 { 4406 XVECEXP (code_exp, 0, i) = decl->condexp; 4407 XVECEXP (lats_exp, 0, i) = decl->condexp; 4408 4409 XVECEXP (code_exp, 0, i+1) = make_numeric_value (decl->insn_num); 4410 XVECEXP (lats_exp, 0, i+1) = make_numeric_value (decl->default_latency); 4411 } 4412 4413 if (n_bypasses == 0) 4414 byps_exp = make_numeric_value (0); 4415 else 4416 { 4417 process_bypasses (); 4418 4419 byps_exp = rtx_alloc (COND); 4420 XVEC (byps_exp, 0) = rtvec_alloc (n_bypasses * 2); 4421 XEXP (byps_exp, 1) = make_numeric_value (0); 4422 for (decl = all_insn_reservs, i = 0; 4423 decl; 4424 decl = decl->next) 4425 if (decl->bypassed) 4426 { 4427 XVECEXP (byps_exp, 0, i) = decl->condexp; 4428 XVECEXP (byps_exp, 0, i+1) = make_numeric_value (1); 4429 i += 2; 4430 } 4431 } 4432 4433 make_internal_attr ("*internal_dfa_insn_code", code_exp, ATTR_NONE); 4434 make_internal_attr ("*insn_default_latency", lats_exp, ATTR_NONE); 4435 make_internal_attr ("*bypass_p", byps_exp, ATTR_NONE); 4436 } 4437 4438 int 4439 main (int argc, char **argv) 4440 { 4441 rtx desc; 4442 struct attr_desc *attr; 4443 struct insn_def *id; 4444 rtx tem; 4445 int i; 4446 4447 progname = "genattrtab"; 4448 4449 if (init_md_reader_args (argc, argv) != SUCCESS_EXIT_CODE) 4450 return (FATAL_EXIT_CODE); 4451 4452 obstack_init (hash_obstack); 4453 obstack_init (temp_obstack); 4454 4455 /* Set up true and false rtx's */ 4456 true_rtx = rtx_alloc (CONST_INT); 4457 XWINT (true_rtx, 0) = 1; 4458 false_rtx = rtx_alloc (CONST_INT); 4459 XWINT (false_rtx, 0) = 0; 4460 ATTR_IND_SIMPLIFIED_P (true_rtx) = ATTR_IND_SIMPLIFIED_P (false_rtx) = 1; 4461 ATTR_PERMANENT_P (true_rtx) = ATTR_PERMANENT_P (false_rtx) = 1; 4462 4463 alternative_name = DEF_ATTR_STRING ("alternative"); 4464 length_str = DEF_ATTR_STRING ("length"); 4465 delay_type_str = DEF_ATTR_STRING ("*delay_type"); 4466 delay_1_0_str = DEF_ATTR_STRING ("*delay_1_0"); 4467 num_delay_slots_str = DEF_ATTR_STRING ("*num_delay_slots"); 4468 4469 printf ("/* Generated automatically by the program `genattrtab'\n\ 4470 from the machine description file `md'. */\n\n"); 4471 4472 /* Read the machine description. */ 4473 4474 while (1) 4475 { 4476 int lineno; 4477 4478 desc = read_md_rtx (&lineno, &insn_code_number); 4479 if (desc == NULL) 4480 break; 4481 4482 switch (GET_CODE (desc)) 4483 { 4484 case DEFINE_INSN: 4485 case DEFINE_PEEPHOLE: 4486 case DEFINE_ASM_ATTRIBUTES: 4487 gen_insn (desc, lineno); 4488 break; 4489 4490 case DEFINE_ATTR: 4491 gen_attr (desc, lineno); 4492 break; 4493 4494 case DEFINE_DELAY: 4495 gen_delay (desc, lineno); 4496 break; 4497 4498 case DEFINE_INSN_RESERVATION: 4499 gen_insn_reserv (desc); 4500 break; 4501 4502 case DEFINE_BYPASS: 4503 gen_bypass (desc); 4504 break; 4505 4506 default: 4507 break; 4508 } 4509 if (GET_CODE (desc) != DEFINE_ASM_ATTRIBUTES) 4510 insn_index_number++; 4511 } 4512 4513 if (have_error) 4514 return FATAL_EXIT_CODE; 4515 4516 insn_code_number++; 4517 4518 /* If we didn't have a DEFINE_ASM_ATTRIBUTES, make a null one. */ 4519 if (! got_define_asm_attributes) 4520 { 4521 tem = rtx_alloc (DEFINE_ASM_ATTRIBUTES); 4522 XVEC (tem, 0) = rtvec_alloc (0); 4523 gen_insn (tem, 0); 4524 } 4525 4526 /* Expand DEFINE_DELAY information into new attribute. */ 4527 if (num_delays) 4528 expand_delays (); 4529 4530 printf ("#include \"config.h\"\n"); 4531 printf ("#include \"system.h\"\n"); 4532 printf ("#include \"coretypes.h\"\n"); 4533 printf ("#include \"tm.h\"\n"); 4534 printf ("#include \"rtl.h\"\n"); 4535 printf ("#include \"insn-attr.h\"\n"); 4536 printf ("#include \"tm_p.h\"\n"); 4537 printf ("#include \"insn-config.h\"\n"); 4538 printf ("#include \"recog.h\"\n"); 4539 printf ("#include \"regs.h\"\n"); 4540 printf ("#include \"real.h\"\n"); 4541 printf ("#include \"output.h\"\n"); 4542 printf ("#include \"toplev.h\"\n"); 4543 printf ("#include \"flags.h\"\n"); 4544 printf ("#include \"function.h\"\n"); 4545 printf ("\n"); 4546 printf ("#define operands recog_data.operand\n\n"); 4547 4548 /* Make `insn_alternatives'. */ 4549 insn_alternatives = oballocvec (int, insn_code_number); 4550 for (id = defs; id; id = id->next) 4551 if (id->insn_code >= 0) 4552 insn_alternatives[id->insn_code] = (1 << id->num_alternatives) - 1; 4553 4554 /* Make `insn_n_alternatives'. */ 4555 insn_n_alternatives = oballocvec (int, insn_code_number); 4556 for (id = defs; id; id = id->next) 4557 if (id->insn_code >= 0) 4558 insn_n_alternatives[id->insn_code] = id->num_alternatives; 4559 4560 /* Construct extra attributes for automata. */ 4561 make_automaton_attrs (); 4562 4563 /* Prepare to write out attribute subroutines by checking everything stored 4564 away and building the attribute cases. */ 4565 4566 check_defs (); 4567 4568 for (i = 0; i < MAX_ATTRS_INDEX; i++) 4569 for (attr = attrs[i]; attr; attr = attr->next) 4570 attr->default_val->value 4571 = check_attr_value (attr->default_val->value, attr); 4572 4573 if (have_error) 4574 return FATAL_EXIT_CODE; 4575 4576 for (i = 0; i < MAX_ATTRS_INDEX; i++) 4577 for (attr = attrs[i]; attr; attr = attr->next) 4578 fill_attr (attr); 4579 4580 /* Construct extra attributes for `length'. */ 4581 make_length_attrs (); 4582 4583 /* Perform any possible optimizations to speed up compilation. */ 4584 optimize_attrs (); 4585 4586 /* Now write out all the `gen_attr_...' routines. Do these before the 4587 special routines so that they get defined before they are used. */ 4588 4589 for (i = 0; i < MAX_ATTRS_INDEX; i++) 4590 for (attr = attrs[i]; attr; attr = attr->next) 4591 { 4592 if (! attr->is_special && ! attr->is_const) 4593 write_attr_get (attr); 4594 } 4595 4596 /* Write out delay eligibility information, if DEFINE_DELAY present. 4597 (The function to compute the number of delay slots will be written 4598 below.) */ 4599 if (num_delays) 4600 { 4601 write_eligible_delay ("delay"); 4602 if (have_annul_true) 4603 write_eligible_delay ("annul_true"); 4604 if (have_annul_false) 4605 write_eligible_delay ("annul_false"); 4606 } 4607 4608 /* Write out constant delay slot info. */ 4609 write_const_num_delay_slots (); 4610 4611 write_length_unit_log (); 4612 4613 fflush (stdout); 4614 return (ferror (stdout) != 0 ? FATAL_EXIT_CODE : SUCCESS_EXIT_CODE); 4615 } 4616