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