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