![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to cse.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GCC 2.x] / gcc|
Return to cse.c CVS log | Up to [GCC 2.x] / gcc |
1.1 root 1: /* Common subexpression elimination for GNU compiler. 1.1.1.7 ! root 2: Copyright (C) 1987, 88, 89, 92, 93, 1994 Free Software Foundation, Inc. 1.1 root 3: 4: This file is part of GNU CC. 5: 6: GNU CC is free software; you can redistribute it and/or modify 7: it under the terms of the GNU General Public License as published by 8: the Free Software Foundation; either version 2, or (at your option) 9: any later version. 10: 11: GNU CC is distributed in the hope that it will be useful, 12: but WITHOUT ANY WARRANTY; without even the implied warranty of 13: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14: GNU General Public License for more details. 15: 16: You should have received a copy of the GNU General Public License 17: along with GNU CC; see the file COPYING. If not, write to 18: the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ 19: 20: 21: #include "config.h" 1.1.1.6 root 22: /* Must precede rtl.h for FFS. */ 23: #include <stdio.h> 24: 1.1 root 25: #include "rtl.h" 26: #include "regs.h" 27: #include "hard-reg-set.h" 28: #include "flags.h" 29: #include "real.h" 30: #include "insn-config.h" 31: #include "recog.h" 32: 33: #include <setjmp.h> 34: 35: /* The basic idea of common subexpression elimination is to go 36: through the code, keeping a record of expressions that would 37: have the same value at the current scan point, and replacing 38: expressions encountered with the cheapest equivalent expression. 39: 40: It is too complicated to keep track of the different possibilities 41: when control paths merge; so, at each label, we forget all that is 42: known and start fresh. This can be described as processing each 43: basic block separately. Note, however, that these are not quite 44: the same as the basic blocks found by a later pass and used for 45: data flow analysis and register packing. We do not need to start fresh 46: after a conditional jump instruction if there is no label there. 47: 48: We use two data structures to record the equivalent expressions: 49: a hash table for most expressions, and several vectors together 50: with "quantity numbers" to record equivalent (pseudo) registers. 51: 52: The use of the special data structure for registers is desirable 53: because it is faster. It is possible because registers references 54: contain a fairly small number, the register number, taken from 55: a contiguously allocated series, and two register references are 56: identical if they have the same number. General expressions 57: do not have any such thing, so the only way to retrieve the 58: information recorded on an expression other than a register 59: is to keep it in a hash table. 60: 61: Registers and "quantity numbers": 62: 63: At the start of each basic block, all of the (hardware and pseudo) 64: registers used in the function are given distinct quantity 65: numbers to indicate their contents. During scan, when the code 66: copies one register into another, we copy the quantity number. 67: When a register is loaded in any other way, we allocate a new 68: quantity number to describe the value generated by this operation. 69: `reg_qty' records what quantity a register is currently thought 70: of as containing. 71: 72: All real quantity numbers are greater than or equal to `max_reg'. 73: If register N has not been assigned a quantity, reg_qty[N] will equal N. 74: 75: Quantity numbers below `max_reg' do not exist and none of the `qty_...' 76: variables should be referenced with an index below `max_reg'. 77: 78: We also maintain a bidirectional chain of registers for each 79: quantity number. `qty_first_reg', `qty_last_reg', 80: `reg_next_eqv' and `reg_prev_eqv' hold these chains. 81: 82: The first register in a chain is the one whose lifespan is least local. 83: Among equals, it is the one that was seen first. 84: We replace any equivalent register with that one. 85: 86: If two registers have the same quantity number, it must be true that 87: REG expressions with `qty_mode' must be in the hash table for both 88: registers and must be in the same class. 89: 90: The converse is not true. Since hard registers may be referenced in 91: any mode, two REG expressions might be equivalent in the hash table 92: but not have the same quantity number if the quantity number of one 93: of the registers is not the same mode as those expressions. 94: 95: Constants and quantity numbers 96: 97: When a quantity has a known constant value, that value is stored 98: in the appropriate element of qty_const. This is in addition to 99: putting the constant in the hash table as is usual for non-regs. 100: 1.1.1.2 root 101: Whether a reg or a constant is preferred is determined by the configuration 1.1 root 102: macro CONST_COSTS and will often depend on the constant value. In any 103: event, expressions containing constants can be simplified, by fold_rtx. 104: 105: When a quantity has a known nearly constant value (such as an address 106: of a stack slot), that value is stored in the appropriate element 107: of qty_const. 108: 109: Integer constants don't have a machine mode. However, cse 110: determines the intended machine mode from the destination 111: of the instruction that moves the constant. The machine mode 112: is recorded in the hash table along with the actual RTL 113: constant expression so that different modes are kept separate. 114: 115: Other expressions: 116: 117: To record known equivalences among expressions in general 118: we use a hash table called `table'. It has a fixed number of buckets 119: that contain chains of `struct table_elt' elements for expressions. 120: These chains connect the elements whose expressions have the same 121: hash codes. 122: 123: Other chains through the same elements connect the elements which 124: currently have equivalent values. 125: 126: Register references in an expression are canonicalized before hashing 127: the expression. This is done using `reg_qty' and `qty_first_reg'. 128: The hash code of a register reference is computed using the quantity 129: number, not the register number. 130: 131: When the value of an expression changes, it is necessary to remove from the 132: hash table not just that expression but all expressions whose values 133: could be different as a result. 134: 135: 1. If the value changing is in memory, except in special cases 136: ANYTHING referring to memory could be changed. That is because 137: nobody knows where a pointer does not point. 138: The function `invalidate_memory' removes what is necessary. 139: 140: The special cases are when the address is constant or is 141: a constant plus a fixed register such as the frame pointer 142: or a static chain pointer. When such addresses are stored in, 143: we can tell exactly which other such addresses must be invalidated 144: due to overlap. `invalidate' does this. 145: All expressions that refer to non-constant 146: memory addresses are also invalidated. `invalidate_memory' does this. 147: 148: 2. If the value changing is a register, all expressions 149: containing references to that register, and only those, 150: must be removed. 151: 152: Because searching the entire hash table for expressions that contain 153: a register is very slow, we try to figure out when it isn't necessary. 154: Precisely, this is necessary only when expressions have been 155: entered in the hash table using this register, and then the value has 156: changed, and then another expression wants to be added to refer to 157: the register's new value. This sequence of circumstances is rare 158: within any one basic block. 159: 160: The vectors `reg_tick' and `reg_in_table' are used to detect this case. 161: reg_tick[i] is incremented whenever a value is stored in register i. 162: reg_in_table[i] holds -1 if no references to register i have been 163: entered in the table; otherwise, it contains the value reg_tick[i] had 164: when the references were entered. If we want to enter a reference 165: and reg_in_table[i] != reg_tick[i], we must scan and remove old references. 166: Until we want to enter a new entry, the mere fact that the two vectors 167: don't match makes the entries be ignored if anyone tries to match them. 168: 169: Registers themselves are entered in the hash table as well as in 170: the equivalent-register chains. However, the vectors `reg_tick' 171: and `reg_in_table' do not apply to expressions which are simple 172: register references. These expressions are removed from the table 173: immediately when they become invalid, and this can be done even if 174: we do not immediately search for all the expressions that refer to 175: the register. 176: 177: A CLOBBER rtx in an instruction invalidates its operand for further 178: reuse. A CLOBBER or SET rtx whose operand is a MEM:BLK 179: invalidates everything that resides in memory. 180: 181: Related expressions: 182: 183: Constant expressions that differ only by an additive integer 184: are called related. When a constant expression is put in 185: the table, the related expression with no constant term 186: is also entered. These are made to point at each other 187: so that it is possible to find out if there exists any 188: register equivalent to an expression related to a given expression. */ 189: 190: /* One plus largest register number used in this function. */ 191: 192: static int max_reg; 193: 194: /* Length of vectors indexed by quantity number. 195: We know in advance we will not need a quantity number this big. */ 196: 197: static int max_qty; 198: 199: /* Next quantity number to be allocated. 200: This is 1 + the largest number needed so far. */ 201: 202: static int next_qty; 203: 204: /* Indexed by quantity number, gives the first (or last) (pseudo) register 205: in the chain of registers that currently contain this quantity. */ 206: 207: static int *qty_first_reg; 208: static int *qty_last_reg; 209: 210: /* Index by quantity number, gives the mode of the quantity. */ 211: 212: static enum machine_mode *qty_mode; 213: 214: /* Indexed by quantity number, gives the rtx of the constant value of the 215: quantity, or zero if it does not have a known value. 216: A sum of the frame pointer (or arg pointer) plus a constant 217: can also be entered here. */ 218: 219: static rtx *qty_const; 220: 221: /* Indexed by qty number, gives the insn that stored the constant value 222: recorded in `qty_const'. */ 223: 224: static rtx *qty_const_insn; 225: 226: /* The next three variables are used to track when a comparison between a 227: quantity and some constant or register has been passed. In that case, we 228: know the results of the comparison in case we see it again. These variables 229: record a comparison that is known to be true. */ 230: 231: /* Indexed by qty number, gives the rtx code of a comparison with a known 232: result involving this quantity. If none, it is UNKNOWN. */ 233: static enum rtx_code *qty_comparison_code; 234: 235: /* Indexed by qty number, gives the constant being compared against in a 236: comparison of known result. If no such comparison, it is undefined. 237: If the comparison is not with a constant, it is zero. */ 238: 239: static rtx *qty_comparison_const; 240: 241: /* Indexed by qty number, gives the quantity being compared against in a 242: comparison of known result. If no such comparison, if it undefined. 243: If the comparison is not with a register, it is -1. */ 244: 245: static int *qty_comparison_qty; 246: 247: #ifdef HAVE_cc0 248: /* For machines that have a CC0, we do not record its value in the hash 249: table since its use is guaranteed to be the insn immediately following 250: its definition and any other insn is presumed to invalidate it. 251: 252: Instead, we store below the value last assigned to CC0. If it should 253: happen to be a constant, it is stored in preference to the actual 254: assigned value. In case it is a constant, we store the mode in which 255: the constant should be interpreted. */ 256: 257: static rtx prev_insn_cc0; 258: static enum machine_mode prev_insn_cc0_mode; 259: #endif 260: 261: /* Previous actual insn. 0 if at first insn of basic block. */ 262: 263: static rtx prev_insn; 264: 265: /* Insn being scanned. */ 266: 267: static rtx this_insn; 268: 269: /* Index by (pseudo) register number, gives the quantity number 270: of the register's current contents. */ 271: 272: static int *reg_qty; 273: 274: /* Index by (pseudo) register number, gives the number of the next (or 275: previous) (pseudo) register in the chain of registers sharing the same 276: value. 277: 278: Or -1 if this register is at the end of the chain. 279: 280: If reg_qty[N] == N, reg_next_eqv[N] is undefined. */ 281: 282: static int *reg_next_eqv; 283: static int *reg_prev_eqv; 284: 285: /* Index by (pseudo) register number, gives the number of times 286: that register has been altered in the current basic block. */ 287: 288: static int *reg_tick; 289: 290: /* Index by (pseudo) register number, gives the reg_tick value at which 291: rtx's containing this register are valid in the hash table. 292: If this does not equal the current reg_tick value, such expressions 293: existing in the hash table are invalid. 294: If this is -1, no expressions containing this register have been 295: entered in the table. */ 296: 297: static int *reg_in_table; 298: 299: /* A HARD_REG_SET containing all the hard registers for which there is 300: currently a REG expression in the hash table. Note the difference 301: from the above variables, which indicate if the REG is mentioned in some 302: expression in the table. */ 303: 304: static HARD_REG_SET hard_regs_in_table; 305: 306: /* A HARD_REG_SET containing all the hard registers that are invalidated 307: by a CALL_INSN. */ 308: 309: static HARD_REG_SET regs_invalidated_by_call; 310: 311: /* Two vectors of ints: 312: one containing max_reg -1's; the other max_reg + 500 (an approximation 313: for max_qty) elements where element i contains i. 314: These are used to initialize various other vectors fast. */ 315: 316: static int *all_minus_one; 317: static int *consec_ints; 318: 319: /* CUID of insn that starts the basic block currently being cse-processed. */ 320: 321: static int cse_basic_block_start; 322: 323: /* CUID of insn that ends the basic block currently being cse-processed. */ 324: 325: static int cse_basic_block_end; 326: 327: /* Vector mapping INSN_UIDs to cuids. 1.1.1.2 root 328: The cuids are like uids but increase monotonically always. 1.1 root 329: We use them to see whether a reg is used outside a given basic block. */ 330: 1.1.1.4 root 331: static int *uid_cuid; 332: 333: /* Highest UID in UID_CUID. */ 334: static int max_uid; 1.1 root 335: 336: /* Get the cuid of an insn. */ 337: 338: #define INSN_CUID(INSN) (uid_cuid[INSN_UID (INSN)]) 339: 340: /* Nonzero if cse has altered conditional jump insns 341: in such a way that jump optimization should be redone. */ 342: 343: static int cse_jumps_altered; 344: 345: /* canon_hash stores 1 in do_not_record 346: if it notices a reference to CC0, PC, or some other volatile 347: subexpression. */ 348: 349: static int do_not_record; 350: 1.1.1.7 ! root 351: #ifdef LOAD_EXTEND_OP ! 352: ! 353: /* Scratch rtl used when looking for load-extended copy of a MEM. */ ! 354: static rtx memory_extend_rtx; ! 355: #endif ! 356: 1.1 root 357: /* canon_hash stores 1 in hash_arg_in_memory 358: if it notices a reference to memory within the expression being hashed. */ 359: 360: static int hash_arg_in_memory; 361: 362: /* canon_hash stores 1 in hash_arg_in_struct 363: if it notices a reference to memory that's part of a structure. */ 364: 365: static int hash_arg_in_struct; 366: 367: /* The hash table contains buckets which are chains of `struct table_elt's, 368: each recording one expression's information. 369: That expression is in the `exp' field. 370: 371: Those elements with the same hash code are chained in both directions 372: through the `next_same_hash' and `prev_same_hash' fields. 373: 374: Each set of expressions with equivalent values 375: are on a two-way chain through the `next_same_value' 376: and `prev_same_value' fields, and all point with 377: the `first_same_value' field at the first element in 378: that chain. The chain is in order of increasing cost. 379: Each element's cost value is in its `cost' field. 380: 381: The `in_memory' field is nonzero for elements that 382: involve any reference to memory. These elements are removed 383: whenever a write is done to an unidentified location in memory. 384: To be safe, we assume that a memory address is unidentified unless 385: the address is either a symbol constant or a constant plus 386: the frame pointer or argument pointer. 387: 388: The `in_struct' field is nonzero for elements that 389: involve any reference to memory inside a structure or array. 390: 391: The `related_value' field is used to connect related expressions 392: (that differ by adding an integer). 393: The related expressions are chained in a circular fashion. 394: `related_value' is zero for expressions for which this 395: chain is not useful. 396: 397: The `cost' field stores the cost of this element's expression. 398: 399: The `is_const' flag is set if the element is a constant (including 400: a fixed address). 401: 402: The `flag' field is used as a temporary during some search routines. 403: 404: The `mode' field is usually the same as GET_MODE (`exp'), but 405: if `exp' is a CONST_INT and has no machine mode then the `mode' 406: field is the mode it was being used as. Each constant is 407: recorded separately for each mode it is used with. */ 408: 409: 410: struct table_elt 411: { 412: rtx exp; 413: struct table_elt *next_same_hash; 414: struct table_elt *prev_same_hash; 415: struct table_elt *next_same_value; 416: struct table_elt *prev_same_value; 417: struct table_elt *first_same_value; 418: struct table_elt *related_value; 419: int cost; 420: enum machine_mode mode; 421: char in_memory; 422: char in_struct; 423: char is_const; 424: char flag; 425: }; 426: 427: /* We don't want a lot of buckets, because we rarely have very many 428: things stored in the hash table, and a lot of buckets slows 429: down a lot of loops that happen frequently. */ 430: #define NBUCKETS 31 431: 432: /* Compute hash code of X in mode M. Special-case case where X is a pseudo 433: register (hard registers may require `do_not_record' to be set). */ 434: 435: #define HASH(X, M) \ 436: (GET_CODE (X) == REG && REGNO (X) >= FIRST_PSEUDO_REGISTER \ 1.1.1.7 ! root 437: ? (((unsigned) REG << 7) + (unsigned) reg_qty[REGNO (X)]) % NBUCKETS \ 1.1 root 438: : canon_hash (X, M) % NBUCKETS) 439: 440: /* Determine whether register number N is considered a fixed register for CSE. 441: It is desirable to replace other regs with fixed regs, to reduce need for 442: non-fixed hard regs. 443: A reg wins if it is either the frame pointer or designated as fixed, 444: but not if it is an overlapping register. */ 445: #ifdef OVERLAPPING_REGNO_P 446: #define FIXED_REGNO_P(N) \ 1.1.1.6 root 447: (((N) == FRAME_POINTER_REGNUM || (N) == HARD_FRAME_POINTER_REGNUM \ 1.1.1.7 ! root 448: || fixed_regs[N] || global_regs[N]) \ 1.1 root 449: && ! OVERLAPPING_REGNO_P ((N))) 450: #else 451: #define FIXED_REGNO_P(N) \ 1.1.1.6 root 452: ((N) == FRAME_POINTER_REGNUM || (N) == HARD_FRAME_POINTER_REGNUM \ 1.1.1.7 ! root 453: || fixed_regs[N] || global_regs[N]) 1.1 root 454: #endif 455: 456: /* Compute cost of X, as stored in the `cost' field of a table_elt. Fixed 1.1.1.5 root 457: hard registers and pointers into the frame are the cheapest with a cost 458: of 0. Next come pseudos with a cost of one and other hard registers with 459: a cost of 2. Aside from these special cases, call `rtx_cost'. */ 460: 1.1.1.7 ! root 461: #define CHEAP_REGNO(N) \ 1.1.1.6 root 462: ((N) == FRAME_POINTER_REGNUM || (N) == HARD_FRAME_POINTER_REGNUM \ 463: || (N) == STACK_POINTER_REGNUM || (N) == ARG_POINTER_REGNUM \ 464: || ((N) >= FIRST_VIRTUAL_REGISTER && (N) <= LAST_VIRTUAL_REGISTER) \ 465: || ((N) < FIRST_PSEUDO_REGISTER \ 1.1.1.5 root 466: && FIXED_REGNO_P (N) && REGNO_REG_CLASS (N) != NO_REGS)) 1.1 root 467: 1.1.1.7 ! root 468: /* A register is cheap if it is a user variable assigned to the register ! 469: or if its register number always corresponds to a cheap register. */ ! 470: ! 471: #define CHEAP_REG(N) \ ! 472: ((REG_USERVAR_P (N) && REGNO (N) < FIRST_PSEUDO_REGISTER) \ ! 473: || CHEAP_REGNO (REGNO (N))) ! 474: 1.1 root 475: #define COST(X) \ 476: (GET_CODE (X) == REG \ 1.1.1.7 ! root 477: ? (CHEAP_REG (X) ? 0 \ 1.1.1.5 root 478: : REGNO (X) >= FIRST_PSEUDO_REGISTER ? 1 \ 1.1 root 479: : 2) \ 1.1.1.3 root 480: : rtx_cost (X, SET) * 2) 1.1 root 481: 482: /* Determine if the quantity number for register X represents a valid index 483: into the `qty_...' variables. */ 484: 485: #define REGNO_QTY_VALID_P(N) (reg_qty[N] != (N)) 486: 487: static struct table_elt *table[NBUCKETS]; 488: 489: /* Chain of `struct table_elt's made so far for this function 490: but currently removed from the table. */ 491: 492: static struct table_elt *free_element_chain; 493: 494: /* Number of `struct table_elt' structures made so far for this function. */ 495: 496: static int n_elements_made; 497: 498: /* Maximum value `n_elements_made' has had so far in this compilation 499: for functions previously processed. */ 500: 501: static int max_elements_made; 502: 503: /* Surviving equivalence class when two equivalence classes are merged 504: by recording the effects of a jump in the last insn. Zero if the 505: last insn was not a conditional jump. */ 506: 507: static struct table_elt *last_jump_equiv_class; 508: 509: /* Set to the cost of a constant pool reference if one was found for a 510: symbolic constant. If this was found, it means we should try to 511: convert constants into constant pool entries if they don't fit in 512: the insn. */ 513: 514: static int constant_pool_entries_cost; 515: 516: /* Bits describing what kind of values in memory must be invalidated 517: for a particular instruction. If all three bits are zero, 518: no memory refs need to be invalidated. Each bit is more powerful 519: than the preceding ones, and if a bit is set then the preceding 520: bits are also set. 521: 522: Here is how the bits are set: 523: Pushing onto the stack invalidates only the stack pointer, 524: writing at a fixed address invalidates only variable addresses, 525: writing in a structure element at variable address 526: invalidates all but scalar variables, 527: and writing in anything else at variable address invalidates everything. */ 528: 529: struct write_data 530: { 531: int sp : 1; /* Invalidate stack pointer. */ 532: int var : 1; /* Invalidate variable addresses. */ 533: int nonscalar : 1; /* Invalidate all but scalar variables. */ 534: int all : 1; /* Invalidate all memory refs. */ 535: }; 536: 1.1.1.5 root 537: /* Define maximum length of a branch path. */ 538: 539: #define PATHLENGTH 10 540: 541: /* This data describes a block that will be processed by cse_basic_block. */ 542: 543: struct cse_basic_block_data { 544: /* Lowest CUID value of insns in block. */ 545: int low_cuid; 546: /* Highest CUID value of insns in block. */ 547: int high_cuid; 548: /* Total number of SETs in block. */ 549: int nsets; 550: /* Last insn in the block. */ 551: rtx last; 552: /* Size of current branch path, if any. */ 553: int path_size; 554: /* Current branch path, indicating which branches will be taken. */ 555: struct branch_path { 556: /* The branch insn. */ 557: rtx branch; 558: /* Whether it should be taken or not. AROUND is the same as taken 559: except that it is used when the destination label is not preceded 560: by a BARRIER. */ 561: enum taken {TAKEN, NOT_TAKEN, AROUND} status; 562: } path[PATHLENGTH]; 563: }; 564: 1.1 root 565: /* Nonzero if X has the form (PLUS frame-pointer integer). We check for 566: virtual regs here because the simplify_*_operation routines are called 567: by integrate.c, which is called before virtual register instantiation. */ 568: 569: #define FIXED_BASE_PLUS_P(X) \ 1.1.1.6 root 570: ((X) == frame_pointer_rtx || (X) == hard_frame_pointer_rtx \ 571: || (X) == arg_pointer_rtx \ 1.1 root 572: || (X) == virtual_stack_vars_rtx \ 573: || (X) == virtual_incoming_args_rtx \ 574: || (GET_CODE (X) == PLUS && GET_CODE (XEXP (X, 1)) == CONST_INT \ 575: && (XEXP (X, 0) == frame_pointer_rtx \ 1.1.1.6 root 576: || XEXP (X, 0) == hard_frame_pointer_rtx \ 1.1 root 577: || XEXP (X, 0) == arg_pointer_rtx \ 578: || XEXP (X, 0) == virtual_stack_vars_rtx \ 579: || XEXP (X, 0) == virtual_incoming_args_rtx))) 580: 1.1.1.3 root 581: /* Similar, but also allows reference to the stack pointer. 582: 583: This used to include FIXED_BASE_PLUS_P, however, we can't assume that 584: arg_pointer_rtx by itself is nonzero, because on at least one machine, 585: the i960, the arg pointer is zero when it is unused. */ 1.1 root 586: 587: #define NONZERO_BASE_PLUS_P(X) \ 1.1.1.6 root 588: ((X) == frame_pointer_rtx || (X) == hard_frame_pointer_rtx \ 1.1.1.3 root 589: || (X) == virtual_stack_vars_rtx \ 590: || (X) == virtual_incoming_args_rtx \ 591: || (GET_CODE (X) == PLUS && GET_CODE (XEXP (X, 1)) == CONST_INT \ 592: && (XEXP (X, 0) == frame_pointer_rtx \ 1.1.1.6 root 593: || XEXP (X, 0) == hard_frame_pointer_rtx \ 1.1.1.3 root 594: || XEXP (X, 0) == arg_pointer_rtx \ 595: || XEXP (X, 0) == virtual_stack_vars_rtx \ 596: || XEXP (X, 0) == virtual_incoming_args_rtx)) \ 1.1 root 597: || (X) == stack_pointer_rtx \ 598: || (X) == virtual_stack_dynamic_rtx \ 599: || (X) == virtual_outgoing_args_rtx \ 600: || (GET_CODE (X) == PLUS && GET_CODE (XEXP (X, 1)) == CONST_INT \ 601: && (XEXP (X, 0) == stack_pointer_rtx \ 602: || XEXP (X, 0) == virtual_stack_dynamic_rtx \ 603: || XEXP (X, 0) == virtual_outgoing_args_rtx))) 604: 1.1.1.5 root 605: static void new_basic_block PROTO((void)); 606: static void make_new_qty PROTO((int)); 607: static void make_regs_eqv PROTO((int, int)); 608: static void delete_reg_equiv PROTO((int)); 609: static int mention_regs PROTO((rtx)); 610: static int insert_regs PROTO((rtx, struct table_elt *, int)); 611: static void free_element PROTO((struct table_elt *)); 1.1.1.7 ! root 612: static void remove_from_table PROTO((struct table_elt *, unsigned)); 1.1.1.5 root 613: static struct table_elt *get_element PROTO((void)); 1.1.1.7 ! root 614: static struct table_elt *lookup PROTO((rtx, unsigned, enum machine_mode)), ! 615: *lookup_for_remove PROTO((rtx, unsigned, enum machine_mode)); 1.1.1.5 root 616: static rtx lookup_as_function PROTO((rtx, enum rtx_code)); 1.1.1.7 ! root 617: static struct table_elt *insert PROTO((rtx, struct table_elt *, unsigned, 1.1.1.5 root 618: enum machine_mode)); 619: static void merge_equiv_classes PROTO((struct table_elt *, 620: struct table_elt *)); 1.1.1.7 ! root 621: static void invalidate PROTO((rtx, enum machine_mode)); 1.1.1.5 root 622: static void remove_invalid_refs PROTO((int)); 623: static void rehash_using_reg PROTO((rtx)); 624: static void invalidate_memory PROTO((struct write_data *)); 625: static void invalidate_for_call PROTO((void)); 626: static rtx use_related_value PROTO((rtx, struct table_elt *)); 1.1.1.7 ! root 627: static unsigned canon_hash PROTO((rtx, enum machine_mode)); ! 628: static unsigned safe_hash PROTO((rtx, enum machine_mode)); 1.1.1.5 root 629: static int exp_equiv_p PROTO((rtx, rtx, int, int)); 630: static void set_nonvarying_address_components PROTO((rtx, int, rtx *, 631: HOST_WIDE_INT *, 632: HOST_WIDE_INT *)); 633: static int refers_to_p PROTO((rtx, rtx)); 634: static int refers_to_mem_p PROTO((rtx, rtx, HOST_WIDE_INT, 635: HOST_WIDE_INT)); 636: static int cse_rtx_addr_varies_p PROTO((rtx)); 637: static rtx canon_reg PROTO((rtx, rtx)); 638: static void find_best_addr PROTO((rtx, rtx *)); 639: static enum rtx_code find_comparison_args PROTO((enum rtx_code, rtx *, rtx *, 640: enum machine_mode *, 641: enum machine_mode *)); 642: static rtx cse_gen_binary PROTO((enum rtx_code, enum machine_mode, 643: rtx, rtx)); 644: static rtx simplify_plus_minus PROTO((enum rtx_code, enum machine_mode, 645: rtx, rtx)); 646: static rtx fold_rtx PROTO((rtx, rtx)); 647: static rtx equiv_constant PROTO((rtx)); 648: static void record_jump_equiv PROTO((rtx, int)); 649: static void record_jump_cond PROTO((enum rtx_code, enum machine_mode, 650: rtx, rtx, int)); 651: static void cse_insn PROTO((rtx, int)); 652: static void note_mem_written PROTO((rtx, struct write_data *)); 653: static void invalidate_from_clobbers PROTO((struct write_data *, rtx)); 654: static rtx cse_process_notes PROTO((rtx, rtx)); 655: static void cse_around_loop PROTO((rtx)); 656: static void invalidate_skipped_set PROTO((rtx, rtx)); 657: static void invalidate_skipped_block PROTO((rtx)); 658: static void cse_check_loop_start PROTO((rtx, rtx)); 659: static void cse_set_around_loop PROTO((rtx, rtx, rtx)); 660: static rtx cse_basic_block PROTO((rtx, rtx, struct branch_path *, int)); 1.1.1.7 ! root 661: static void count_reg_usage PROTO((rtx, int *, rtx, int)); ! 662: ! 663: extern int rtx_equal_function_value_matters; 1.1 root 664: 665: /* Return an estimate of the cost of computing rtx X. 666: One use is in cse, to decide which expression to keep in the hash table. 667: Another is in rtl generation, to pick the cheapest way to multiply. 668: Other uses like the latter are expected in the future. */ 669: 670: /* Return the right cost to give to an operation 671: to make the cost of the corresponding register-to-register instruction 672: N times that of a fast register-to-register instruction. */ 673: 674: #define COSTS_N_INSNS(N) ((N) * 4 - 2) 675: 676: int 1.1.1.3 root 677: rtx_cost (x, outer_code) 1.1 root 678: rtx x; 1.1.1.3 root 679: enum rtx_code outer_code; 1.1 root 680: { 681: register int i, j; 682: register enum rtx_code code; 683: register char *fmt; 684: register int total; 685: 686: if (x == 0) 687: return 0; 688: 689: /* Compute the default costs of certain things. 690: Note that RTX_COSTS can override the defaults. */ 691: 692: code = GET_CODE (x); 693: switch (code) 694: { 695: case MULT: 696: /* Count multiplication by 2**n as a shift, 697: because if we are considering it, we would output it as a shift. */ 698: if (GET_CODE (XEXP (x, 1)) == CONST_INT 699: && exact_log2 (INTVAL (XEXP (x, 1))) >= 0) 700: total = 2; 701: else 702: total = COSTS_N_INSNS (5); 703: break; 704: case DIV: 705: case UDIV: 706: case MOD: 707: case UMOD: 708: total = COSTS_N_INSNS (7); 709: break; 710: case USE: 711: /* Used in loop.c and combine.c as a marker. */ 712: total = 0; 713: break; 1.1.1.2 root 714: case ASM_OPERANDS: 715: /* We don't want these to be used in substitutions because 716: we have no way of validating the resulting insn. So assign 717: anything containing an ASM_OPERANDS a very high cost. */ 718: total = 1000; 719: break; 1.1 root 720: default: 721: total = 2; 722: } 723: 724: switch (code) 725: { 726: case REG: 1.1.1.7 ! root 727: return ! CHEAP_REG (x); 1.1.1.5 root 728: 1.1 root 729: case SUBREG: 1.1.1.3 root 730: /* If we can't tie these modes, make this expensive. The larger 731: the mode, the more expensive it is. */ 732: if (! MODES_TIEABLE_P (GET_MODE (x), GET_MODE (SUBREG_REG (x)))) 733: return COSTS_N_INSNS (2 734: + GET_MODE_SIZE (GET_MODE (x)) / UNITS_PER_WORD); 1.1 root 735: return 2; 736: #ifdef RTX_COSTS 1.1.1.3 root 737: RTX_COSTS (x, code, outer_code); 1.1 root 738: #endif 1.1.1.3 root 739: CONST_COSTS (x, code, outer_code); 1.1 root 740: } 741: 742: /* Sum the costs of the sub-rtx's, plus cost of this operation, 743: which is already in total. */ 744: 745: fmt = GET_RTX_FORMAT (code); 746: for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--) 747: if (fmt[i] == 'e') 1.1.1.3 root 748: total += rtx_cost (XEXP (x, i), code); 1.1 root 749: else if (fmt[i] == 'E') 750: for (j = 0; j < XVECLEN (x, i); j++) 1.1.1.3 root 751: total += rtx_cost (XVECEXP (x, i, j), code); 1.1 root 752: 753: return total; 754: } 755: 756: /* Clear the hash table and initialize each register with its own quantity, 757: for a new basic block. */ 758: 759: static void 760: new_basic_block () 761: { 762: register int i; 763: 764: next_qty = max_reg; 765: 1.1.1.7 ! root 766: bzero ((char *) reg_tick, max_reg * sizeof (int)); 1.1 root 767: 1.1.1.7 ! root 768: bcopy ((char *) all_minus_one, (char *) reg_in_table, ! 769: max_reg * sizeof (int)); ! 770: bcopy ((char *) consec_ints, (char *) reg_qty, max_reg * sizeof (int)); 1.1 root 771: CLEAR_HARD_REG_SET (hard_regs_in_table); 772: 773: /* The per-quantity values used to be initialized here, but it is 774: much faster to initialize each as it is made in `make_new_qty'. */ 775: 776: for (i = 0; i < NBUCKETS; i++) 777: { 778: register struct table_elt *this, *next; 779: for (this = table[i]; this; this = next) 780: { 781: next = this->next_same_hash; 782: free_element (this); 783: } 784: } 785: 1.1.1.7 ! root 786: bzero ((char *) table, sizeof table); 1.1 root 787: 788: prev_insn = 0; 789: 790: #ifdef HAVE_cc0 791: prev_insn_cc0 = 0; 792: #endif 793: } 794: 795: /* Say that register REG contains a quantity not in any register before 796: and initialize that quantity. */ 797: 798: static void 799: make_new_qty (reg) 800: register int reg; 801: { 802: register int q; 803: 804: if (next_qty >= max_qty) 805: abort (); 806: 807: q = reg_qty[reg] = next_qty++; 808: qty_first_reg[q] = reg; 809: qty_last_reg[q] = reg; 810: qty_const[q] = qty_const_insn[q] = 0; 811: qty_comparison_code[q] = UNKNOWN; 812: 813: reg_next_eqv[reg] = reg_prev_eqv[reg] = -1; 814: } 815: 816: /* Make reg NEW equivalent to reg OLD. 817: OLD is not changing; NEW is. */ 818: 819: static void 820: make_regs_eqv (new, old) 821: register int new, old; 822: { 823: register int lastr, firstr; 824: register int q = reg_qty[old]; 825: 826: /* Nothing should become eqv until it has a "non-invalid" qty number. */ 827: if (! REGNO_QTY_VALID_P (old)) 828: abort (); 829: 830: reg_qty[new] = q; 831: firstr = qty_first_reg[q]; 832: lastr = qty_last_reg[q]; 833: 834: /* Prefer fixed hard registers to anything. Prefer pseudo regs to other 835: hard regs. Among pseudos, if NEW will live longer than any other reg 836: of the same qty, and that is beyond the current basic block, 837: make it the new canonical replacement for this qty. */ 838: if (! (firstr < FIRST_PSEUDO_REGISTER && FIXED_REGNO_P (firstr)) 839: /* Certain fixed registers might be of the class NO_REGS. This means 840: that not only can they not be allocated by the compiler, but 1.1.1.3 root 841: they cannot be used in substitutions or canonicalizations 1.1 root 842: either. */ 843: && (new >= FIRST_PSEUDO_REGISTER || REGNO_REG_CLASS (new) != NO_REGS) 844: && ((new < FIRST_PSEUDO_REGISTER && FIXED_REGNO_P (new)) 845: || (new >= FIRST_PSEUDO_REGISTER 846: && (firstr < FIRST_PSEUDO_REGISTER 847: || ((uid_cuid[regno_last_uid[new]] > cse_basic_block_end 848: || (uid_cuid[regno_first_uid[new]] 849: < cse_basic_block_start)) 850: && (uid_cuid[regno_last_uid[new]] 851: > uid_cuid[regno_last_uid[firstr]])))))) 852: { 853: reg_prev_eqv[firstr] = new; 854: reg_next_eqv[new] = firstr; 855: reg_prev_eqv[new] = -1; 856: qty_first_reg[q] = new; 857: } 858: else 859: { 860: /* If NEW is a hard reg (known to be non-fixed), insert at end. 861: Otherwise, insert before any non-fixed hard regs that are at the 862: end. Registers of class NO_REGS cannot be used as an 863: equivalent for anything. */ 864: while (lastr < FIRST_PSEUDO_REGISTER && reg_prev_eqv[lastr] >= 0 865: && (REGNO_REG_CLASS (lastr) == NO_REGS || ! FIXED_REGNO_P (lastr)) 866: && new >= FIRST_PSEUDO_REGISTER) 867: lastr = reg_prev_eqv[lastr]; 868: reg_next_eqv[new] = reg_next_eqv[lastr]; 869: if (reg_next_eqv[lastr] >= 0) 870: reg_prev_eqv[reg_next_eqv[lastr]] = new; 871: else 872: qty_last_reg[q] = new; 873: reg_next_eqv[lastr] = new; 874: reg_prev_eqv[new] = lastr; 875: } 876: } 877: 878: /* Remove REG from its equivalence class. */ 879: 880: static void 881: delete_reg_equiv (reg) 882: register int reg; 883: { 884: register int q = reg_qty[reg]; 1.1.1.7 ! root 885: register int p, n; 1.1 root 886: 1.1.1.7 ! root 887: /* If invalid, do nothing. */ 1.1 root 888: if (q == reg) 889: return; 890: 1.1.1.7 ! root 891: p = reg_prev_eqv[reg]; ! 892: n = reg_next_eqv[reg]; ! 893: 1.1 root 894: if (n != -1) 895: reg_prev_eqv[n] = p; 896: else 897: qty_last_reg[q] = p; 898: if (p != -1) 899: reg_next_eqv[p] = n; 900: else 901: qty_first_reg[q] = n; 902: 903: reg_qty[reg] = reg; 904: } 905: 906: /* Remove any invalid expressions from the hash table 907: that refer to any of the registers contained in expression X. 908: 909: Make sure that newly inserted references to those registers 910: as subexpressions will be considered valid. 911: 912: mention_regs is not called when a register itself 913: is being stored in the table. 914: 915: Return 1 if we have done something that may have changed the hash code 916: of X. */ 917: 918: static int 919: mention_regs (x) 920: rtx x; 921: { 922: register enum rtx_code code; 923: register int i, j; 924: register char *fmt; 925: register int changed = 0; 926: 927: if (x == 0) 1.1.1.3 root 928: return 0; 1.1 root 929: 930: code = GET_CODE (x); 931: if (code == REG) 932: { 933: register int regno = REGNO (x); 934: register int endregno 935: = regno + (regno >= FIRST_PSEUDO_REGISTER ? 1 936: : HARD_REGNO_NREGS (regno, GET_MODE (x))); 937: int i; 938: 939: for (i = regno; i < endregno; i++) 940: { 941: if (reg_in_table[i] >= 0 && reg_in_table[i] != reg_tick[i]) 942: remove_invalid_refs (i); 943: 944: reg_in_table[i] = reg_tick[i]; 945: } 946: 947: return 0; 948: } 949: 950: /* If X is a comparison or a COMPARE and either operand is a register 951: that does not have a quantity, give it one. This is so that a later 952: call to record_jump_equiv won't cause X to be assigned a different 953: hash code and not found in the table after that call. 954: 955: It is not necessary to do this here, since rehash_using_reg can 956: fix up the table later, but doing this here eliminates the need to 957: call that expensive function in the most common case where the only 958: use of the register is in the comparison. */ 959: 960: if (code == COMPARE || GET_RTX_CLASS (code) == '<') 961: { 962: if (GET_CODE (XEXP (x, 0)) == REG 963: && ! REGNO_QTY_VALID_P (REGNO (XEXP (x, 0)))) 1.1.1.4 root 964: if (insert_regs (XEXP (x, 0), NULL_PTR, 0)) 1.1 root 965: { 966: rehash_using_reg (XEXP (x, 0)); 967: changed = 1; 968: } 969: 970: if (GET_CODE (XEXP (x, 1)) == REG 971: && ! REGNO_QTY_VALID_P (REGNO (XEXP (x, 1)))) 1.1.1.4 root 972: if (insert_regs (XEXP (x, 1), NULL_PTR, 0)) 1.1 root 973: { 974: rehash_using_reg (XEXP (x, 1)); 975: changed = 1; 976: } 977: } 978: 979: fmt = GET_RTX_FORMAT (code); 980: for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--) 981: if (fmt[i] == 'e') 982: changed |= mention_regs (XEXP (x, i)); 983: else if (fmt[i] == 'E') 984: for (j = 0; j < XVECLEN (x, i); j++) 985: changed |= mention_regs (XVECEXP (x, i, j)); 986: 987: return changed; 988: } 989: 990: /* Update the register quantities for inserting X into the hash table 991: with a value equivalent to CLASSP. 992: (If the class does not contain a REG, it is irrelevant.) 993: If MODIFIED is nonzero, X is a destination; it is being modified. 994: Note that delete_reg_equiv should be called on a register 995: before insert_regs is done on that register with MODIFIED != 0. 996: 997: Nonzero value means that elements of reg_qty have changed 998: so X's hash code may be different. */ 999: 1000: static int 1001: insert_regs (x, classp, modified) 1002: rtx x; 1003: struct table_elt *classp; 1004: int modified; 1005: { 1006: if (GET_CODE (x) == REG) 1007: { 1008: register int regno = REGNO (x); 1009: 1.1.1.5 root 1010: /* If REGNO is in the equivalence table already but is of the 1011: wrong mode for that equivalence, don't do anything here. */ 1012: 1013: if (REGNO_QTY_VALID_P (regno) 1014: && qty_mode[reg_qty[regno]] != GET_MODE (x)) 1015: return 0; 1016: 1017: if (modified || ! REGNO_QTY_VALID_P (regno)) 1.1 root 1018: { 1019: if (classp) 1020: for (classp = classp->first_same_value; 1021: classp != 0; 1022: classp = classp->next_same_value) 1023: if (GET_CODE (classp->exp) == REG 1024: && GET_MODE (classp->exp) == GET_MODE (x)) 1025: { 1026: make_regs_eqv (regno, REGNO (classp->exp)); 1027: return 1; 1028: } 1029: 1030: make_new_qty (regno); 1031: qty_mode[reg_qty[regno]] = GET_MODE (x); 1032: return 1; 1033: } 1.1.1.6 root 1034: 1035: return 0; 1.1 root 1036: } 1.1.1.4 root 1037: 1038: /* If X is a SUBREG, we will likely be inserting the inner register in the 1039: table. If that register doesn't have an assigned quantity number at 1040: this point but does later, the insertion that we will be doing now will 1041: not be accessible because its hash code will have changed. So assign 1042: a quantity number now. */ 1043: 1044: else if (GET_CODE (x) == SUBREG && GET_CODE (SUBREG_REG (x)) == REG 1045: && ! REGNO_QTY_VALID_P (REGNO (SUBREG_REG (x)))) 1046: { 1047: insert_regs (SUBREG_REG (x), NULL_PTR, 0); 1048: mention_regs (SUBREG_REG (x)); 1049: return 1; 1050: } 1.1 root 1051: else 1052: return mention_regs (x); 1053: } 1054: 1055: /* Look in or update the hash table. */ 1056: 1057: /* Put the element ELT on the list of free elements. */ 1058: 1059: static void 1060: free_element (elt) 1061: struct table_elt *elt; 1062: { 1063: elt->next_same_hash = free_element_chain; 1064: free_element_chain = elt; 1065: } 1066: 1067: /* Return an element that is free for use. */ 1068: 1069: static struct table_elt * 1070: get_element () 1071: { 1072: struct table_elt *elt = free_element_chain; 1073: if (elt) 1074: { 1075: free_element_chain = elt->next_same_hash; 1076: return elt; 1077: } 1078: n_elements_made++; 1079: return (struct table_elt *) oballoc (sizeof (struct table_elt)); 1080: } 1081: 1082: /* Remove table element ELT from use in the table. 1083: HASH is its hash code, made using the HASH macro. 1084: It's an argument because often that is known in advance 1085: and we save much time not recomputing it. */ 1086: 1087: static void 1088: remove_from_table (elt, hash) 1089: register struct table_elt *elt; 1.1.1.7 ! root 1090: unsigned hash; 1.1 root 1091: { 1092: if (elt == 0) 1093: return; 1094: 1095: /* Mark this element as removed. See cse_insn. */ 1096: elt->first_same_value = 0; 1097: 1098: /* Remove the table element from its equivalence class. */ 1099: 1100: { 1101: register struct table_elt *prev = elt->prev_same_value; 1102: register struct table_elt *next = elt->next_same_value; 1103: 1104: if (next) next->prev_same_value = prev; 1105: 1106: if (prev) 1107: prev->next_same_value = next; 1108: else 1109: { 1110: register struct table_elt *newfirst = next; 1111: while (next) 1112: { 1113: next->first_same_value = newfirst; 1114: next = next->next_same_value; 1115: } 1116: } 1117: } 1118: 1119: /* Remove the table element from its hash bucket. */ 1120: 1121: { 1122: register struct table_elt *prev = elt->prev_same_hash; 1123: register struct table_elt *next = elt->next_same_hash; 1124: 1125: if (next) next->prev_same_hash = prev; 1126: 1127: if (prev) 1128: prev->next_same_hash = next; 1129: else if (table[hash] == elt) 1130: table[hash] = next; 1131: else 1132: { 1133: /* This entry is not in the proper hash bucket. This can happen 1134: when two classes were merged by `merge_equiv_classes'. Search 1135: for the hash bucket that it heads. This happens only very 1136: rarely, so the cost is acceptable. */ 1137: for (hash = 0; hash < NBUCKETS; hash++) 1138: if (table[hash] == elt) 1139: table[hash] = next; 1140: } 1141: } 1142: 1143: /* Remove the table element from its related-value circular chain. */ 1144: 1145: if (elt->related_value != 0 && elt->related_value != elt) 1146: { 1147: register struct table_elt *p = elt->related_value; 1148: while (p->related_value != elt) 1149: p = p->related_value; 1150: p->related_value = elt->related_value; 1151: if (p->related_value == p) 1152: p->related_value = 0; 1153: } 1154: 1155: free_element (elt); 1156: } 1157: 1158: /* Look up X in the hash table and return its table element, 1159: or 0 if X is not in the table. 1160: 1161: MODE is the machine-mode of X, or if X is an integer constant 1162: with VOIDmode then MODE is the mode with which X will be used. 1163: 1164: Here we are satisfied to find an expression whose tree structure 1165: looks like X. */ 1166: 1167: static struct table_elt * 1168: lookup (x, hash, mode) 1169: rtx x; 1.1.1.7 ! root 1170: unsigned hash; 1.1 root 1171: enum machine_mode mode; 1172: { 1173: register struct table_elt *p; 1174: 1175: for (p = table[hash]; p; p = p->next_same_hash) 1176: if (mode == p->mode && ((x == p->exp && GET_CODE (x) == REG) 1177: || exp_equiv_p (x, p->exp, GET_CODE (x) != REG, 0))) 1178: return p; 1179: 1180: return 0; 1181: } 1182: 1183: /* Like `lookup' but don't care whether the table element uses invalid regs. 1184: Also ignore discrepancies in the machine mode of a register. */ 1185: 1186: static struct table_elt * 1187: lookup_for_remove (x, hash, mode) 1188: rtx x; 1.1.1.7 ! root 1189: unsigned hash; 1.1 root 1190: enum machine_mode mode; 1191: { 1192: register struct table_elt *p; 1193: 1194: if (GET_CODE (x) == REG) 1195: { 1196: int regno = REGNO (x); 1197: /* Don't check the machine mode when comparing registers; 1198: invalidating (REG:SI 0) also invalidates (REG:DF 0). */ 1199: for (p = table[hash]; p; p = p->next_same_hash) 1200: if (GET_CODE (p->exp) == REG 1201: && REGNO (p->exp) == regno) 1202: return p; 1203: } 1204: else 1205: { 1206: for (p = table[hash]; p; p = p->next_same_hash) 1207: if (mode == p->mode && (x == p->exp || exp_equiv_p (x, p->exp, 0, 0))) 1208: return p; 1209: } 1210: 1211: return 0; 1212: } 1213: 1214: /* Look for an expression equivalent to X and with code CODE. 1215: If one is found, return that expression. */ 1216: 1217: static rtx 1218: lookup_as_function (x, code) 1219: rtx x; 1220: enum rtx_code code; 1221: { 1222: register struct table_elt *p = lookup (x, safe_hash (x, VOIDmode) % NBUCKETS, 1223: GET_MODE (x)); 1224: if (p == 0) 1225: return 0; 1226: 1227: for (p = p->first_same_value; p; p = p->next_same_value) 1228: { 1229: if (GET_CODE (p->exp) == code 1230: /* Make sure this is a valid entry in the table. */ 1231: && exp_equiv_p (p->exp, p->exp, 1, 0)) 1232: return p->exp; 1233: } 1234: 1235: return 0; 1236: } 1237: 1238: /* Insert X in the hash table, assuming HASH is its hash code 1239: and CLASSP is an element of the class it should go in 1240: (or 0 if a new class should be made). 1241: It is inserted at the proper position to keep the class in 1242: the order cheapest first. 1243: 1244: MODE is the machine-mode of X, or if X is an integer constant 1245: with VOIDmode then MODE is the mode with which X will be used. 1246: 1247: For elements of equal cheapness, the most recent one 1248: goes in front, except that the first element in the list 1249: remains first unless a cheaper element is added. The order of 1250: pseudo-registers does not matter, as canon_reg will be called to 1.1.1.3 root 1251: find the cheapest when a register is retrieved from the table. 1.1 root 1252: 1253: The in_memory field in the hash table element is set to 0. 1254: The caller must set it nonzero if appropriate. 1255: 1256: You should call insert_regs (X, CLASSP, MODIFY) before calling here, 1257: and if insert_regs returns a nonzero value 1258: you must then recompute its hash code before calling here. 1259: 1260: If necessary, update table showing constant values of quantities. */ 1261: 1262: #define CHEAPER(X,Y) ((X)->cost < (Y)->cost) 1263: 1264: static struct table_elt * 1265: insert (x, classp, hash, mode) 1266: register rtx x; 1267: register struct table_elt *classp; 1.1.1.7 ! root 1268: unsigned hash; 1.1 root 1269: enum machine_mode mode; 1270: { 1271: register struct table_elt *elt; 1272: 1273: /* If X is a register and we haven't made a quantity for it, 1274: something is wrong. */ 1275: if (GET_CODE (x) == REG && ! REGNO_QTY_VALID_P (REGNO (x))) 1276: abort (); 1277: 1278: /* If X is a hard register, show it is being put in the table. */ 1279: if (GET_CODE (x) == REG && REGNO (x) < FIRST_PSEUDO_REGISTER) 1280: { 1281: int regno = REGNO (x); 1282: int endregno = regno + HARD_REGNO_NREGS (regno, GET_MODE (x)); 1283: int i; 1284: 1285: for (i = regno; i < endregno; i++) 1286: SET_HARD_REG_BIT (hard_regs_in_table, i); 1287: } 1288: 1289: 1290: /* Put an element for X into the right hash bucket. */ 1291: 1292: elt = get_element (); 1293: elt->exp = x; 1294: elt->cost = COST (x); 1295: elt->next_same_value = 0; 1296: elt->prev_same_value = 0; 1297: elt->next_same_hash = table[hash]; 1298: elt->prev_same_hash = 0; 1299: elt->related_value = 0; 1300: elt->in_memory = 0; 1301: elt->mode = mode; 1302: elt->is_const = (CONSTANT_P (x) 1303: /* GNU C++ takes advantage of this for `this' 1304: (and other const values). */ 1305: || (RTX_UNCHANGING_P (x) 1306: && GET_CODE (x) == REG 1307: && REGNO (x) >= FIRST_PSEUDO_REGISTER) 1308: || FIXED_BASE_PLUS_P (x)); 1309: 1310: if (table[hash]) 1311: table[hash]->prev_same_hash = elt; 1312: table[hash] = elt; 1313: 1314: /* Put it into the proper value-class. */ 1315: if (classp) 1316: { 1317: classp = classp->first_same_value; 1318: if (CHEAPER (elt, classp)) 1319: /* Insert at the head of the class */ 1320: { 1321: register struct table_elt *p; 1322: elt->next_same_value = classp; 1323: classp->prev_same_value = elt; 1324: elt->first_same_value = elt; 1325: 1326: for (p = classp; p; p = p->next_same_value) 1327: p->first_same_value = elt; 1328: } 1329: else 1330: { 1331: /* Insert not at head of the class. */ 1332: /* Put it after the last element cheaper than X. */ 1333: register struct table_elt *p, *next; 1334: for (p = classp; (next = p->next_same_value) && CHEAPER (next, elt); 1335: p = next); 1336: /* Put it after P and before NEXT. */ 1337: elt->next_same_value = next; 1338: if (next) 1339: next->prev_same_value = elt; 1340: elt->prev_same_value = p; 1341: p->next_same_value = elt; 1342: elt->first_same_value = classp; 1343: } 1344: } 1345: else 1346: elt->first_same_value = elt; 1347: 1348: /* If this is a constant being set equivalent to a register or a register 1349: being set equivalent to a constant, note the constant equivalence. 1350: 1351: If this is a constant, it cannot be equivalent to a different constant, 1352: and a constant is the only thing that can be cheaper than a register. So 1353: we know the register is the head of the class (before the constant was 1354: inserted). 1355: 1356: If this is a register that is not already known equivalent to a 1357: constant, we must check the entire class. 1358: 1359: If this is a register that is already known equivalent to an insn, 1360: update `qty_const_insn' to show that `this_insn' is the latest 1361: insn making that quantity equivalent to the constant. */ 1362: 1363: if (elt->is_const && classp && GET_CODE (classp->exp) == REG) 1364: { 1365: qty_const[reg_qty[REGNO (classp->exp)]] 1366: = gen_lowpart_if_possible (qty_mode[reg_qty[REGNO (classp->exp)]], x); 1367: qty_const_insn[reg_qty[REGNO (classp->exp)]] = this_insn; 1368: } 1369: 1370: else if (GET_CODE (x) == REG && classp && ! qty_const[reg_qty[REGNO (x)]]) 1371: { 1372: register struct table_elt *p; 1373: 1374: for (p = classp; p != 0; p = p->next_same_value) 1375: { 1376: if (p->is_const) 1377: { 1378: qty_const[reg_qty[REGNO (x)]] 1379: = gen_lowpart_if_possible (GET_MODE (x), p->exp); 1380: qty_const_insn[reg_qty[REGNO (x)]] = this_insn; 1381: break; 1382: } 1383: } 1384: } 1385: 1386: else if (GET_CODE (x) == REG && qty_const[reg_qty[REGNO (x)]] 1387: && GET_MODE (x) == qty_mode[reg_qty[REGNO (x)]]) 1388: qty_const_insn[reg_qty[REGNO (x)]] = this_insn; 1389: 1390: /* If this is a constant with symbolic value, 1391: and it has a term with an explicit integer value, 1392: link it up with related expressions. */ 1393: if (GET_CODE (x) == CONST) 1394: { 1395: rtx subexp = get_related_value (x); 1.1.1.7 ! root 1396: unsigned subhash; 1.1 root 1397: struct table_elt *subelt, *subelt_prev; 1398: 1399: if (subexp != 0) 1400: { 1401: /* Get the integer-free subexpression in the hash table. */ 1402: subhash = safe_hash (subexp, mode) % NBUCKETS; 1403: subelt = lookup (subexp, subhash, mode); 1404: if (subelt == 0) 1.1.1.4 root 1405: subelt = insert (subexp, NULL_PTR, subhash, mode); 1.1 root 1406: /* Initialize SUBELT's circular chain if it has none. */ 1407: if (subelt->related_value == 0) 1408: subelt->related_value = subelt; 1409: /* Find the element in the circular chain that precedes SUBELT. */ 1410: subelt_prev = subelt; 1411: while (subelt_prev->related_value != subelt) 1412: subelt_prev = subelt_prev->related_value; 1413: /* Put new ELT into SUBELT's circular chain just before SUBELT. 1414: This way the element that follows SUBELT is the oldest one. */ 1415: elt->related_value = subelt_prev->related_value; 1416: subelt_prev->related_value = elt; 1417: } 1418: } 1419: 1420: return elt; 1421: } 1422: 1423: /* Given two equivalence classes, CLASS1 and CLASS2, put all the entries from 1424: CLASS2 into CLASS1. This is done when we have reached an insn which makes 1425: the two classes equivalent. 1426: 1427: CLASS1 will be the surviving class; CLASS2 should not be used after this 1428: call. 1429: 1430: Any invalid entries in CLASS2 will not be copied. */ 1431: 1432: static void 1433: merge_equiv_classes (class1, class2) 1434: struct table_elt *class1, *class2; 1435: { 1436: struct table_elt *elt, *next, *new; 1437: 1438: /* Ensure we start with the head of the classes. */ 1439: class1 = class1->first_same_value; 1440: class2 = class2->first_same_value; 1441: 1442: /* If they were already equal, forget it. */ 1443: if (class1 == class2) 1444: return; 1445: 1446: for (elt = class2; elt; elt = next) 1447: { 1.1.1.7 ! root 1448: unsigned hash; 1.1 root 1449: rtx exp = elt->exp; 1450: enum machine_mode mode = elt->mode; 1451: 1452: next = elt->next_same_value; 1453: 1454: /* Remove old entry, make a new one in CLASS1's class. 1455: Don't do this for invalid entries as we cannot find their 1456: hash code (it also isn't necessary). */ 1457: if (GET_CODE (exp) == REG || exp_equiv_p (exp, exp, 1, 0)) 1458: { 1459: hash_arg_in_memory = 0; 1460: hash_arg_in_struct = 0; 1461: hash = HASH (exp, mode); 1462: 1463: if (GET_CODE (exp) == REG) 1464: delete_reg_equiv (REGNO (exp)); 1465: 1466: remove_from_table (elt, hash); 1467: 1468: if (insert_regs (exp, class1, 0)) 1.1.1.7 ! root 1469: { ! 1470: rehash_using_reg (exp); ! 1471: hash = HASH (exp, mode); ! 1472: } 1.1 root 1473: new = insert (exp, class1, hash, mode); 1474: new->in_memory = hash_arg_in_memory; 1475: new->in_struct = hash_arg_in_struct; 1476: } 1477: } 1478: } 1479: 1480: /* Remove from the hash table, or mark as invalid, 1481: all expressions whose values could be altered by storing in X. 1482: X is a register, a subreg, or a memory reference with nonvarying address 1483: (because, when a memory reference with a varying address is stored in, 1484: all memory references are removed by invalidate_memory 1485: so specific invalidation is superfluous). 1.1.1.7 ! root 1486: FULL_MODE, if not VOIDmode, indicates that this much should be invalidated ! 1487: instead of just the amount indicated by the mode of X. This is only used ! 1488: for bitfield stores into memory. 1.1 root 1489: 1490: A nonvarying address may be just a register or just 1491: a symbol reference, or it may be either of those plus 1492: a numeric offset. */ 1493: 1494: static void 1.1.1.7 ! root 1495: invalidate (x, full_mode) 1.1 root 1496: rtx x; 1.1.1.7 ! root 1497: enum machine_mode full_mode; 1.1 root 1498: { 1499: register int i; 1500: register struct table_elt *p; 1.1.1.5 root 1501: rtx base; 1502: HOST_WIDE_INT start, end; 1.1 root 1503: 1504: /* If X is a register, dependencies on its contents 1505: are recorded through the qty number mechanism. 1506: Just change the qty number of the register, 1507: mark it as invalid for expressions that refer to it, 1508: and remove it itself. */ 1509: 1510: if (GET_CODE (x) == REG) 1511: { 1512: register int regno = REGNO (x); 1.1.1.7 ! root 1513: register unsigned hash = HASH (x, GET_MODE (x)); 1.1 root 1514: 1515: /* Remove REGNO from any quantity list it might be on and indicate 1516: that it's value might have changed. If it is a pseudo, remove its 1517: entry from the hash table. 1518: 1519: For a hard register, we do the first two actions above for any 1520: additional hard registers corresponding to X. Then, if any of these 1521: registers are in the table, we must remove any REG entries that 1522: overlap these registers. */ 1523: 1524: delete_reg_equiv (regno); 1525: reg_tick[regno]++; 1526: 1527: if (regno >= FIRST_PSEUDO_REGISTER) 1528: remove_from_table (lookup_for_remove (x, hash, GET_MODE (x)), hash); 1529: else 1530: { 1.1.1.5 root 1531: HOST_WIDE_INT in_table 1532: = TEST_HARD_REG_BIT (hard_regs_in_table, regno); 1.1 root 1533: int endregno = regno + HARD_REGNO_NREGS (regno, GET_MODE (x)); 1534: int tregno, tendregno; 1535: register struct table_elt *p, *next; 1536: 1537: CLEAR_HARD_REG_BIT (hard_regs_in_table, regno); 1538: 1539: for (i = regno + 1; i < endregno; i++) 1540: { 1541: in_table |= TEST_HARD_REG_BIT (hard_regs_in_table, i); 1542: CLEAR_HARD_REG_BIT (hard_regs_in_table, i); 1543: delete_reg_equiv (i); 1544: reg_tick[i]++; 1545: } 1546: 1547: if (in_table) 1548: for (hash = 0; hash < NBUCKETS; hash++) 1549: for (p = table[hash]; p; p = next) 1550: { 1551: next = p->next_same_hash; 1552: 1553: if (GET_CODE (p->exp) != REG 1554: || REGNO (p->exp) >= FIRST_PSEUDO_REGISTER) 1555: continue; 1556: 1557: tregno = REGNO (p->exp); 1558: tendregno 1559: = tregno + HARD_REGNO_NREGS (tregno, GET_MODE (p->exp)); 1560: if (tendregno > regno && tregno < endregno) 1561: remove_from_table (p, hash); 1562: } 1563: } 1564: 1565: return; 1566: } 1567: 1568: if (GET_CODE (x) == SUBREG) 1569: { 1570: if (GET_CODE (SUBREG_REG (x)) != REG) 1571: abort (); 1.1.1.7 ! root 1572: invalidate (SUBREG_REG (x), VOIDmode); 1.1 root 1573: return; 1574: } 1575: 1576: /* X is not a register; it must be a memory reference with 1577: a nonvarying address. Remove all hash table elements 1578: that refer to overlapping pieces of memory. */ 1579: 1580: if (GET_CODE (x) != MEM) 1581: abort (); 1582: 1.1.1.7 ! root 1583: if (full_mode == VOIDmode) ! 1584: full_mode = GET_MODE (x); ! 1585: ! 1586: set_nonvarying_address_components (XEXP (x, 0), GET_MODE_SIZE (full_mode), 1.1.1.5 root 1587: &base, &start, &end); 1.1 root 1588: 1589: for (i = 0; i < NBUCKETS; i++) 1590: { 1591: register struct table_elt *next; 1592: for (p = table[i]; p; p = next) 1593: { 1594: next = p->next_same_hash; 1595: if (refers_to_mem_p (p->exp, base, start, end)) 1596: remove_from_table (p, i); 1597: } 1598: } 1599: } 1600: 1601: /* Remove all expressions that refer to register REGNO, 1602: since they are already invalid, and we are about to 1603: mark that register valid again and don't want the old 1604: expressions to reappear as valid. */ 1605: 1606: static void 1607: remove_invalid_refs (regno) 1608: int regno; 1609: { 1610: register int i; 1611: register struct table_elt *p, *next; 1612: 1613: for (i = 0; i < NBUCKETS; i++) 1614: for (p = table[i]; p; p = next) 1615: { 1616: next = p->next_same_hash; 1617: if (GET_CODE (p->exp) != REG 1.1.1.4 root 1618: && refers_to_regno_p (regno, regno + 1, p->exp, NULL_PTR)) 1.1 root 1619: remove_from_table (p, i); 1620: } 1621: } 1622: 1623: /* Recompute the hash codes of any valid entries in the hash table that 1624: reference X, if X is a register, or SUBREG_REG (X) if X is a SUBREG. 1625: 1626: This is called when we make a jump equivalence. */ 1627: 1628: static void 1629: rehash_using_reg (x) 1630: rtx x; 1631: { 1632: int i; 1633: struct table_elt *p, *next; 1.1.1.7 ! root 1634: unsigned hash; 1.1 root 1635: 1636: if (GET_CODE (x) == SUBREG) 1637: x = SUBREG_REG (x); 1638: 1639: /* If X is not a register or if the register is known not to be in any 1640: valid entries in the table, we have no work to do. */ 1641: 1642: if (GET_CODE (x) != REG 1643: || reg_in_table[REGNO (x)] < 0 1644: || reg_in_table[REGNO (x)] != reg_tick[REGNO (x)]) 1645: return; 1646: 1647: /* Scan all hash chains looking for valid entries that mention X. 1648: If we find one and it is in the wrong hash chain, move it. We can skip 1649: objects that are registers, since they are handled specially. */ 1650: 1651: for (i = 0; i < NBUCKETS; i++) 1652: for (p = table[i]; p; p = next) 1653: { 1654: next = p->next_same_hash; 1655: if (GET_CODE (p->exp) != REG && reg_mentioned_p (x, p->exp) 1.1.1.2 root 1656: && exp_equiv_p (p->exp, p->exp, 1, 0) 1.1 root 1657: && i != (hash = safe_hash (p->exp, p->mode) % NBUCKETS)) 1658: { 1659: if (p->next_same_hash) 1660: p->next_same_hash->prev_same_hash = p->prev_same_hash; 1661: 1662: if (p->prev_same_hash) 1663: p->prev_same_hash->next_same_hash = p->next_same_hash; 1664: else 1665: table[i] = p->next_same_hash; 1666: 1667: p->next_same_hash = table[hash]; 1668: p->prev_same_hash = 0; 1669: if (table[hash]) 1670: table[hash]->prev_same_hash = p; 1671: table[hash] = p; 1672: } 1673: } 1674: } 1675: 1676: /* Remove from the hash table all expressions that reference memory, 1677: or some of them as specified by *WRITES. */ 1678: 1679: static void 1680: invalidate_memory (writes) 1681: struct write_data *writes; 1682: { 1683: register int i; 1684: register struct table_elt *p, *next; 1685: int all = writes->all; 1686: int nonscalar = writes->nonscalar; 1687: 1688: for (i = 0; i < NBUCKETS; i++) 1689: for (p = table[i]; p; p = next) 1690: { 1691: next = p->next_same_hash; 1692: if (p->in_memory 1693: && (all 1694: || (nonscalar && p->in_struct) 1695: || cse_rtx_addr_varies_p (p->exp))) 1696: remove_from_table (p, i); 1697: } 1698: } 1699: 1700: /* Remove from the hash table any expression that is a call-clobbered 1701: register. Also update their TICK values. */ 1702: 1703: static void 1704: invalidate_for_call () 1705: { 1706: int regno, endregno; 1707: int i; 1.1.1.7 ! root 1708: unsigned hash; 1.1 root 1709: struct table_elt *p, *next; 1710: int in_table = 0; 1711: 1712: /* Go through all the hard registers. For each that is clobbered in 1713: a CALL_INSN, remove the register from quantity chains and update 1714: reg_tick if defined. Also see if any of these registers is currently 1715: in the table. */ 1716: 1717: for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++) 1718: if (TEST_HARD_REG_BIT (regs_invalidated_by_call, regno)) 1719: { 1720: delete_reg_equiv (regno); 1721: if (reg_tick[regno] >= 0) 1722: reg_tick[regno]++; 1723: 1.1.1.7 ! root 1724: in_table |= (TEST_HARD_REG_BIT (hard_regs_in_table, regno) != 0); 1.1 root 1725: } 1726: 1727: /* In the case where we have no call-clobbered hard registers in the 1728: table, we are done. Otherwise, scan the table and remove any 1729: entry that overlaps a call-clobbered register. */ 1730: 1731: if (in_table) 1732: for (hash = 0; hash < NBUCKETS; hash++) 1733: for (p = table[hash]; p; p = next) 1734: { 1735: next = p->next_same_hash; 1736: 1737: if (GET_CODE (p->exp) != REG 1738: || REGNO (p->exp) >= FIRST_PSEUDO_REGISTER) 1739: continue; 1740: 1741: regno = REGNO (p->exp); 1742: endregno = regno + HARD_REGNO_NREGS (regno, GET_MODE (p->exp)); 1743: 1744: for (i = regno; i < endregno; i++) 1745: if (TEST_HARD_REG_BIT (regs_invalidated_by_call, i)) 1746: { 1747: remove_from_table (p, hash); 1748: break; 1749: } 1750: } 1751: } 1752: 1753: /* Given an expression X of type CONST, 1754: and ELT which is its table entry (or 0 if it 1755: is not in the hash table), 1756: return an alternate expression for X as a register plus integer. 1757: If none can be found, return 0. */ 1758: 1759: static rtx 1760: use_related_value (x, elt) 1761: rtx x; 1762: struct table_elt *elt; 1763: { 1764: register struct table_elt *relt = 0; 1765: register struct table_elt *p, *q; 1.1.1.4 root 1766: HOST_WIDE_INT offset; 1.1 root 1767: 1768: /* First, is there anything related known? 1769: If we have a table element, we can tell from that. 1770: Otherwise, must look it up. */ 1771: 1772: if (elt != 0 && elt->related_value != 0) 1773: relt = elt; 1774: else if (elt == 0 && GET_CODE (x) == CONST) 1775: { 1776: rtx subexp = get_related_value (x); 1777: if (subexp != 0) 1778: relt = lookup (subexp, 1779: safe_hash (subexp, GET_MODE (subexp)) % NBUCKETS, 1780: GET_MODE (subexp)); 1781: } 1782: 1783: if (relt == 0) 1784: return 0; 1785: 1786: /* Search all related table entries for one that has an 1787: equivalent register. */ 1788: 1789: p = relt; 1790: while (1) 1791: { 1792: /* This loop is strange in that it is executed in two different cases. 1793: The first is when X is already in the table. Then it is searching 1794: the RELATED_VALUE list of X's class (RELT). The second case is when 1795: X is not in the table. Then RELT points to a class for the related 1796: value. 1797: 1798: Ensure that, whatever case we are in, that we ignore classes that have 1799: the same value as X. */ 1800: 1801: if (rtx_equal_p (x, p->exp)) 1802: q = 0; 1803: else 1804: for (q = p->first_same_value; q; q = q->next_same_value) 1805: if (GET_CODE (q->exp) == REG) 1806: break; 1807: 1808: if (q) 1809: break; 1810: 1811: p = p->related_value; 1812: 1813: /* We went all the way around, so there is nothing to be found. 1814: Alternatively, perhaps RELT was in the table for some other reason 1815: and it has no related values recorded. */ 1816: if (p == relt || p == 0) 1817: break; 1818: } 1819: 1820: if (q == 0) 1821: return 0; 1822: 1823: offset = (get_integer_term (x) - get_integer_term (p->exp)); 1824: /* Note: OFFSET may be 0 if P->xexp and X are related by commutativity. */ 1825: return plus_constant (q->exp, offset); 1826: } 1827: 1828: /* Hash an rtx. We are careful to make sure the value is never negative. 1829: Equivalent registers hash identically. 1830: MODE is used in hashing for CONST_INTs only; 1831: otherwise the mode of X is used. 1832: 1833: Store 1 in do_not_record if any subexpression is volatile. 1834: 1835: Store 1 in hash_arg_in_memory if X contains a MEM rtx 1836: which does not have the RTX_UNCHANGING_P bit set. 1837: In this case, also store 1 in hash_arg_in_struct 1838: if there is a MEM rtx which has the MEM_IN_STRUCT_P bit set. 1839: 1840: Note that cse_insn knows that the hash code of a MEM expression 1841: is just (int) MEM plus the hash code of the address. */ 1842: 1.1.1.7 ! root 1843: static unsigned 1.1 root 1844: canon_hash (x, mode) 1845: rtx x; 1846: enum machine_mode mode; 1847: { 1848: register int i, j; 1.1.1.7 ! root 1849: register unsigned hash = 0; 1.1 root 1850: register enum rtx_code code; 1851: register char *fmt; 1852: 1853: /* repeat is used to turn tail-recursion into iteration. */ 1854: repeat: 1855: if (x == 0) 1856: return hash; 1857: 1858: code = GET_CODE (x); 1859: switch (code) 1860: { 1861: case REG: 1862: { 1863: register int regno = REGNO (x); 1864: 1865: /* On some machines, we can't record any non-fixed hard register, 1866: because extending its life will cause reload problems. We 1867: consider ap, fp, and sp to be fixed for this purpose. 1868: On all machines, we can't record any global registers. */ 1869: 1870: if (regno < FIRST_PSEUDO_REGISTER 1871: && (global_regs[regno] 1872: #ifdef SMALL_REGISTER_CLASSES 1873: || (! fixed_regs[regno] 1874: && regno != FRAME_POINTER_REGNUM 1.1.1.6 root 1875: && regno != HARD_FRAME_POINTER_REGNUM 1.1 root 1876: && regno != ARG_POINTER_REGNUM 1877: && regno != STACK_POINTER_REGNUM) 1878: #endif 1879: )) 1880: { 1881: do_not_record = 1; 1882: return 0; 1883: } 1.1.1.7 ! root 1884: hash += ((unsigned) REG << 7) + (unsigned) reg_qty[regno]; ! 1885: return hash; 1.1 root 1886: } 1887: 1888: case CONST_INT: 1.1.1.7 ! root 1889: { ! 1890: unsigned HOST_WIDE_INT tem = INTVAL (x); ! 1891: hash += ((unsigned) CONST_INT << 7) + (unsigned) mode + tem; ! 1892: return hash; ! 1893: } 1.1 root 1894: 1895: case CONST_DOUBLE: 1896: /* This is like the general case, except that it only counts 1897: the integers representing the constant. */ 1.1.1.7 ! root 1898: hash += (unsigned) code + (unsigned) GET_MODE (x); ! 1899: for (i = 2; i < GET_RTX_LENGTH (CONST_DOUBLE); i++) ! 1900: { ! 1901: unsigned tem = XINT (x, i); ! 1902: hash += tem; ! 1903: } 1.1 root 1904: return hash; 1905: 1906: /* Assume there is only one rtx object for any given label. */ 1907: case LABEL_REF: 1.1.1.7 ! root 1908: hash ! 1909: += ((unsigned) LABEL_REF << 7) + (unsigned HOST_WIDE_INT) XEXP (x, 0); ! 1910: return hash; 1.1 root 1911: 1912: case SYMBOL_REF: 1.1.1.7 ! root 1913: hash ! 1914: += ((unsigned) SYMBOL_REF << 7) + (unsigned HOST_WIDE_INT) XSTR (x, 0); ! 1915: return hash; 1.1 root 1916: 1917: case MEM: 1918: if (MEM_VOLATILE_P (x)) 1919: { 1920: do_not_record = 1; 1921: return 0; 1922: } 1923: if (! RTX_UNCHANGING_P (x)) 1924: { 1925: hash_arg_in_memory = 1; 1926: if (MEM_IN_STRUCT_P (x)) hash_arg_in_struct = 1; 1927: } 1928: /* Now that we have already found this special case, 1929: might as well speed it up as much as possible. */ 1.1.1.7 ! root 1930: hash += (unsigned) MEM; 1.1 root 1931: x = XEXP (x, 0); 1932: goto repeat; 1933: 1934: case PRE_DEC: 1935: case PRE_INC: 1936: case POST_DEC: 1937: case POST_INC: 1938: case PC: 1939: case CC0: 1940: case CALL: 1941: case UNSPEC_VOLATILE: 1942: do_not_record = 1; 1943: return 0; 1944: 1945: case ASM_OPERANDS: 1946: if (MEM_VOLATILE_P (x)) 1947: { 1948: do_not_record = 1; 1949: return 0; 1950: } 1951: } 1952: 1953: i = GET_RTX_LENGTH (code) - 1; 1.1.1.7 ! root 1954: hash += (unsigned) code + (unsigned) GET_MODE (x); 1.1 root 1955: fmt = GET_RTX_FORMAT (code); 1956: for (; i >= 0; i--) 1957: { 1958: if (fmt[i] == 'e') 1959: { 1960: rtx tem = XEXP (x, i); 1961: 1962: /* If we are about to do the last recursive call 1963: needed at this level, change it into iteration. 1964: This function is called enough to be worth it. */ 1965: if (i == 0) 1966: { 1967: x = tem; 1968: goto repeat; 1969: } 1970: hash += canon_hash (tem, 0); 1971: } 1972: else if (fmt[i] == 'E') 1973: for (j = 0; j < XVECLEN (x, i); j++) 1974: hash += canon_hash (XVECEXP (x, i, j), 0); 1975: else if (fmt[i] == 's') 1976: { 1.1.1.7 ! root 1977: register unsigned char *p = (unsigned char *) XSTR (x, i); 1.1 root 1978: if (p) 1979: while (*p) 1.1.1.7 ! root 1980: hash += *p++; 1.1 root 1981: } 1982: else if (fmt[i] == 'i') 1983: { 1.1.1.7 ! root 1984: register unsigned tem = XINT (x, i); ! 1985: hash += tem; 1.1 root 1986: } 1987: else 1988: abort (); 1989: } 1990: return hash; 1991: } 1992: 1993: /* Like canon_hash but with no side effects. */ 1994: 1.1.1.7 ! root 1995: static unsigned 1.1 root 1996: safe_hash (x, mode) 1997: rtx x; 1998: enum machine_mode mode; 1999: { 2000: int save_do_not_record = do_not_record; 2001: int save_hash_arg_in_memory = hash_arg_in_memory; 2002: int save_hash_arg_in_struct = hash_arg_in_struct; 1.1.1.7 ! root 2003: unsigned hash = canon_hash (x, mode); 1.1 root 2004: hash_arg_in_memory = save_hash_arg_in_memory; 2005: hash_arg_in_struct = save_hash_arg_in_struct; 2006: do_not_record = save_do_not_record; 2007: return hash; 2008: } 2009: 2010: /* Return 1 iff X and Y would canonicalize into the same thing, 2011: without actually constructing the canonicalization of either one. 2012: If VALIDATE is nonzero, 2013: we assume X is an expression being processed from the rtl 2014: and Y was found in the hash table. We check register refs 2015: in Y for being marked as valid. 2016: 2017: If EQUAL_VALUES is nonzero, we allow a register to match a constant value 2018: that is known to be in the register. Ordinarily, we don't allow them 2019: to match, because letting them match would cause unpredictable results 2020: in all the places that search a hash table chain for an equivalent 2021: for a given value. A possible equivalent that has different structure 2022: has its hash code computed from different data. Whether the hash code 2023: is the same as that of the the given value is pure luck. */ 2024: 2025: static int 2026: exp_equiv_p (x, y, validate, equal_values) 2027: rtx x, y; 2028: int validate; 2029: int equal_values; 2030: { 1.1.1.4 root 2031: register int i, j; 1.1 root 2032: register enum rtx_code code; 2033: register char *fmt; 2034: 2035: /* Note: it is incorrect to assume an expression is equivalent to itself 2036: if VALIDATE is nonzero. */ 2037: if (x == y && !validate) 2038: return 1; 2039: if (x == 0 || y == 0) 2040: return x == y; 2041: 2042: code = GET_CODE (x); 2043: if (code != GET_CODE (y)) 2044: { 2045: if (!equal_values) 2046: return 0; 2047: 2048: /* If X is a constant and Y is a register or vice versa, they may be 2049: equivalent. We only have to validate if Y is a register. */ 2050: if (CONSTANT_P (x) && GET_CODE (y) == REG 2051: && REGNO_QTY_VALID_P (REGNO (y)) 2052: && GET_MODE (y) == qty_mode[reg_qty[REGNO (y)]] 2053: && rtx_equal_p (x, qty_const[reg_qty[REGNO (y)]]) 2054: && (! validate || reg_in_table[REGNO (y)] == reg_tick[REGNO (y)])) 2055: return 1; 2056: 2057: if (CONSTANT_P (y) && code == REG 2058: && REGNO_QTY_VALID_P (REGNO (x)) 2059: && GET_MODE (x) == qty_mode[reg_qty[REGNO (x)]] 2060: && rtx_equal_p (y, qty_const[reg_qty[REGNO (x)]])) 2061: return 1; 2062: 2063: return 0; 2064: } 2065: 2066: /* (MULT:SI x y) and (MULT:HI x y) are NOT equivalent. */ 2067: if (GET_MODE (x) != GET_MODE (y)) 2068: return 0; 2069: 2070: switch (code) 2071: { 2072: case PC: 2073: case CC0: 2074: return x == y; 2075: 2076: case CONST_INT: 1.1.1.4 root 2077: return INTVAL (x) == INTVAL (y); 1.1 root 2078: 2079: case LABEL_REF: 2080: return XEXP (x, 0) == XEXP (y, 0); 2081: 1.1.1.7 ! root 2082: case SYMBOL_REF: ! 2083: return XSTR (x, 0) == XSTR (y, 0); ! 2084: 1.1 root 2085: case REG: 2086: { 2087: int regno = REGNO (y); 2088: int endregno 2089: = regno + (regno >= FIRST_PSEUDO_REGISTER ? 1 2090: : HARD_REGNO_NREGS (regno, GET_MODE (y))); 2091: int i; 2092: 2093: /* If the quantities are not the same, the expressions are not 2094: equivalent. If there are and we are not to validate, they 2095: are equivalent. Otherwise, ensure all regs are up-to-date. */ 2096: 2097: if (reg_qty[REGNO (x)] != reg_qty[regno]) 2098: return 0; 2099: 2100: if (! validate) 2101: return 1; 2102: 2103: for (i = regno; i < endregno; i++) 2104: if (reg_in_table[i] != reg_tick[i]) 2105: return 0; 2106: 2107: return 1; 2108: } 2109: 2110: /* For commutative operations, check both orders. */ 2111: case PLUS: 2112: case MULT: 2113: case AND: 2114: case IOR: 2115: case XOR: 2116: case NE: 2117: case EQ: 2118: return ((exp_equiv_p (XEXP (x, 0), XEXP (y, 0), validate, equal_values) 2119: && exp_equiv_p (XEXP (x, 1), XEXP (y, 1), 2120: validate, equal_values)) 2121: || (exp_equiv_p (XEXP (x, 0), XEXP (y, 1), 2122: validate, equal_values) 2123: && exp_equiv_p (XEXP (x, 1), XEXP (y, 0), 2124: validate, equal_values))); 2125: } 2126: 2127: /* Compare the elements. If any pair of corresponding elements 2128: fail to match, return 0 for the whole things. */ 2129: 2130: fmt = GET_RTX_FORMAT (code); 2131: for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--) 2132: { 1.1.1.4 root 2133: switch (fmt[i]) 1.1 root 2134: { 1.1.1.4 root 2135: case 'e': 1.1 root 2136: if (! exp_equiv_p (XEXP (x, i), XEXP (y, i), validate, equal_values)) 2137: return 0; 1.1.1.4 root 2138: break; 2139: 2140: case 'E': 1.1 root 2141: if (XVECLEN (x, i) != XVECLEN (y, i)) 2142: return 0; 2143: for (j = 0; j < XVECLEN (x, i); j++) 2144: if (! exp_equiv_p (XVECEXP (x, i, j), XVECEXP (y, i, j), 2145: validate, equal_values)) 2146: return 0; 1.1.1.4 root 2147: break; 2148: 2149: case 's': 1.1 root 2150: if (strcmp (XSTR (x, i), XSTR (y, i))) 2151: return 0; 1.1.1.4 root 2152: break; 2153: 2154: case 'i': 1.1 root 2155: if (XINT (x, i) != XINT (y, i)) 2156: return 0; 1.1.1.4 root 2157: break; 2158: 2159: case 'w': 2160: if (XWINT (x, i) != XWINT (y, i)) 2161: return 0; 2162: break; 2163: 2164: case '0': 2165: break; 2166: 2167: default: 2168: abort (); 1.1 root 2169: } 1.1.1.4 root 2170: } 2171: 1.1 root 2172: return 1; 2173: } 2174: 2175: /* Return 1 iff any subexpression of X matches Y. 2176: Here we do not require that X or Y be valid (for registers referred to) 2177: for being in the hash table. */ 2178: 1.1.1.5 root 2179: static int 1.1 root 2180: refers_to_p (x, y) 2181: rtx x, y; 2182: { 2183: register int i; 2184: register enum rtx_code code; 2185: register char *fmt; 2186: 2187: repeat: 2188: if (x == y) 2189: return 1; 2190: if (x == 0 || y == 0) 2191: return 0; 2192: 2193: code = GET_CODE (x); 2194: /* If X as a whole has the same code as Y, they may match. 2195: If so, return 1. */ 2196: if (code == GET_CODE (y)) 2197: { 2198: if (exp_equiv_p (x, y, 0, 1)) 2199: return 1; 2200: } 2201: 2202: /* X does not match, so try its subexpressions. */ 2203: 2204: fmt = GET_RTX_FORMAT (code); 2205: for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--) 2206: if (fmt[i] == 'e') 2207: { 2208: if (i == 0) 2209: { 2210: x = XEXP (x, 0); 2211: goto repeat; 2212: } 2213: else 2214: if (refers_to_p (XEXP (x, i), y)) 2215: return 1; 2216: } 2217: else if (fmt[i] == 'E') 2218: { 2219: int j; 2220: for (j = 0; j < XVECLEN (x, i); j++) 2221: if (refers_to_p (XVECEXP (x, i, j), y)) 2222: return 1; 2223: } 2224: 2225: return 0; 2226: } 2227: 1.1.1.5 root 2228: /* Given ADDR and SIZE (a memory address, and the size of the memory reference), 2229: set PBASE, PSTART, and PEND which correspond to the base of the address, 2230: the starting offset, and ending offset respectively. 2231: 1.1.1.7 ! root 2232: ADDR is known to be a nonvarying address. */ 1.1.1.5 root 2233: 1.1.1.7 ! root 2234: /* ??? Despite what the comments say, this function is in fact frequently ! 2235: passed varying addresses. This does not appear to cause any problems. */ 1.1.1.5 root 2236: 2237: static void 2238: set_nonvarying_address_components (addr, size, pbase, pstart, pend) 2239: rtx addr; 2240: int size; 2241: rtx *pbase; 2242: HOST_WIDE_INT *pstart, *pend; 2243: { 2244: rtx base; 1.1.1.7 ! root 2245: HOST_WIDE_INT start, end; 1.1.1.5 root 2246: 2247: base = addr; 2248: start = 0; 2249: end = 0; 2250: 2251: /* Registers with nonvarying addresses usually have constant equivalents; 2252: but the frame pointer register is also possible. */ 2253: if (GET_CODE (base) == REG 2254: && qty_const != 0 2255: && REGNO_QTY_VALID_P (REGNO (base)) 2256: && qty_mode[reg_qty[REGNO (base)]] == GET_MODE (base) 2257: && qty_const[reg_qty[REGNO (base)]] != 0) 2258: base = qty_const[reg_qty[REGNO (base)]]; 2259: else if (GET_CODE (base) == PLUS 2260: && GET_CODE (XEXP (base, 1)) == CONST_INT 2261: && GET_CODE (XEXP (base, 0)) == REG 2262: && qty_const != 0 2263: && REGNO_QTY_VALID_P (REGNO (XEXP (base, 0))) 2264: && (qty_mode[reg_qty[REGNO (XEXP (base, 0))]] 2265: == GET_MODE (XEXP (base, 0))) 2266: && qty_const[reg_qty[REGNO (XEXP (base, 0))]]) 2267: { 2268: start = INTVAL (XEXP (base, 1)); 2269: base = qty_const[reg_qty[REGNO (XEXP (base, 0))]]; 2270: } 2271: 1.1.1.7 ! root 2272: /* Handle everything that we can find inside an address that has been ! 2273: viewed as constant. */ ! 2274: ! 2275: while (1) ! 2276: { ! 2277: /* If no part of this switch does a "continue", the code outside ! 2278: will exit this loop. */ ! 2279: ! 2280: switch (GET_CODE (base)) ! 2281: { ! 2282: case LO_SUM: ! 2283: /* By definition, operand1 of a LO_SUM is the associated constant ! 2284: address. Use the associated constant address as the base ! 2285: instead. */ ! 2286: base = XEXP (base, 1); ! 2287: continue; ! 2288: ! 2289: case CONST: ! 2290: /* Strip off CONST. */ ! 2291: base = XEXP (base, 0); ! 2292: continue; ! 2293: ! 2294: case PLUS: ! 2295: if (GET_CODE (XEXP (base, 1)) == CONST_INT) ! 2296: { ! 2297: start += INTVAL (XEXP (base, 1)); ! 2298: base = XEXP (base, 0); ! 2299: continue; ! 2300: } ! 2301: break; ! 2302: ! 2303: case AND: ! 2304: /* Handle the case of an AND which is the negative of a power of ! 2305: two. This is used to represent unaligned memory operations. */ ! 2306: if (GET_CODE (XEXP (base, 1)) == CONST_INT ! 2307: && exact_log2 (- INTVAL (XEXP (base, 1))) > 0) ! 2308: { ! 2309: set_nonvarying_address_components (XEXP (base, 0), size, ! 2310: pbase, pstart, pend); ! 2311: ! 2312: /* Assume the worst misalignment. START is affected, but not ! 2313: END, so compensate but adjusting SIZE. Don't lose any ! 2314: constant we already had. */ ! 2315: ! 2316: size = *pend - *pstart - INTVAL (XEXP (base, 1)) - 1; ! 2317: start += *pstart - INTVAL (XEXP (base, 1)) - 1; ! 2318: base = *pbase; ! 2319: } ! 2320: break; ! 2321: } ! 2322: ! 2323: break; ! 2324: } 1.1.1.5 root 2325: 1.1.1.7 ! root 2326: if (GET_CODE (base) == CONST_INT) 1.1.1.5 root 2327: { 1.1.1.7 ! root 2328: start += INTVAL (base); ! 2329: base = const0_rtx; 1.1.1.5 root 2330: } 2331: 2332: end = start + size; 2333: 2334: /* Set the return values. */ 2335: *pbase = base; 2336: *pstart = start; 2337: *pend = end; 2338: } 2339: 1.1 root 2340: /* Return 1 iff any subexpression of X refers to memory 2341: at an address of BASE plus some offset 2342: such that any of the bytes' offsets fall between START (inclusive) 2343: and END (exclusive). 2344: 1.1.1.5 root 2345: The value is undefined if X is a varying address (as determined by 2346: cse_rtx_addr_varies_p). This function is not used in such cases. 1.1 root 2347: 2348: When used in the cse pass, `qty_const' is nonzero, and it is used 2349: to treat an address that is a register with a known constant value 2350: as if it were that constant value. 2351: In the loop pass, `qty_const' is zero, so this is not done. */ 2352: 1.1.1.5 root 2353: static int 1.1 root 2354: refers_to_mem_p (x, base, start, end) 2355: rtx x, base; 1.1.1.4 root 2356: HOST_WIDE_INT start, end; 1.1 root 2357: { 1.1.1.4 root 2358: register HOST_WIDE_INT i; 1.1 root 2359: register enum rtx_code code; 2360: register char *fmt; 2361: 2362: repeat: 2363: if (x == 0) 2364: return 0; 2365: 2366: code = GET_CODE (x); 2367: if (code == MEM) 2368: { 2369: register rtx addr = XEXP (x, 0); /* Get the address. */ 1.1.1.5 root 2370: rtx mybase; 2371: HOST_WIDE_INT mystart, myend; 1.1 root 2372: 1.1.1.5 root 2373: set_nonvarying_address_components (addr, GET_MODE_SIZE (GET_MODE (x)), 2374: &mybase, &mystart, &myend); 2375: 2376: 2377: /* refers_to_mem_p is never called with varying addresses. 2378: If the base addresses are not equal, there is no chance 2379: of the memory addresses conflicting. */ 2380: if (! rtx_equal_p (mybase, base)) 1.1 root 2381: return 0; 2382: 1.1.1.5 root 2383: return myend > start && mystart < end; 1.1 root 2384: } 2385: 2386: /* X does not match, so try its subexpressions. */ 2387: 2388: fmt = GET_RTX_FORMAT (code); 2389: for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--) 2390: if (fmt[i] == 'e') 2391: { 2392: if (i == 0) 2393: { 2394: x = XEXP (x, 0); 2395: goto repeat; 2396: } 2397: else 2398: if (refers_to_mem_p (XEXP (x, i), base, start, end)) 2399: return 1; 2400: } 2401: else if (fmt[i] == 'E') 2402: { 2403: int j; 2404: for (j = 0; j < XVECLEN (x, i); j++) 2405: if (refers_to_mem_p (XVECEXP (x, i, j), base, start, end)) 2406: return 1; 2407: } 2408: 2409: return 0; 2410: } 2411: 2412: /* Nonzero if X refers to memory at a varying address; 2413: except that a register which has at the moment a known constant value 2414: isn't considered variable. */ 2415: 2416: static int 2417: cse_rtx_addr_varies_p (x) 2418: rtx x; 2419: { 2420: /* We need not check for X and the equivalence class being of the same 2421: mode because if X is equivalent to a constant in some mode, it 2422: doesn't vary in any mode. */ 2423: 2424: if (GET_CODE (x) == MEM 2425: && GET_CODE (XEXP (x, 0)) == REG 2426: && REGNO_QTY_VALID_P (REGNO (XEXP (x, 0))) 2427: && GET_MODE (XEXP (x, 0)) == qty_mode[reg_qty[REGNO (XEXP (x, 0))]] 2428: && qty_const[reg_qty[REGNO (XEXP (x, 0))]] != 0) 2429: return 0; 2430: 2431: if (GET_CODE (x) == MEM 2432: && GET_CODE (XEXP (x, 0)) == PLUS 2433: && GET_CODE (XEXP (XEXP (x, 0), 1)) == CONST_INT 2434: && GET_CODE (XEXP (XEXP (x, 0), 0)) == REG 2435: && REGNO_QTY_VALID_P (REGNO (XEXP (XEXP (x, 0), 0))) 2436: && (GET_MODE (XEXP (XEXP (x, 0), 0)) 2437: == qty_mode[reg_qty[REGNO (XEXP (XEXP (x, 0), 0))]]) 2438: && qty_const[reg_qty[REGNO (XEXP (XEXP (x, 0), 0))]]) 2439: return 0; 2440: 2441: return rtx_addr_varies_p (x); 2442: } 2443: 2444: /* Canonicalize an expression: 2445: replace each register reference inside it 2446: with the "oldest" equivalent register. 2447: 2448: If INSN is non-zero and we are replacing a pseudo with a hard register 1.1.1.4 root 2449: or vice versa, validate_change is used to ensure that INSN remains valid 2450: after we make our substitution. The calls are made with IN_GROUP non-zero 2451: so apply_change_group must be called upon the outermost return from this 2452: function (unless INSN is zero). The result of apply_change_group can 2453: generally be discarded since the changes we are making are optional. */ 1.1 root 2454: 2455: static rtx 2456: canon_reg (x, insn) 2457: rtx x; 2458: rtx insn; 2459: { 2460: register int i; 2461: register enum rtx_code code; 2462: register char *fmt; 2463: 2464: if (x == 0) 2465: return x; 2466: 2467: code = GET_CODE (x); 2468: switch (code) 2469: { 2470: case PC: 2471: case CC0: 2472: case CONST: 2473: case CONST_INT: 2474: case CONST_DOUBLE: 2475: case SYMBOL_REF: 2476: case LABEL_REF: 2477: case ADDR_VEC: 2478: case ADDR_DIFF_VEC: 2479: return x; 2480: 2481: case REG: 2482: { 2483: register int first; 2484: 2485: /* Never replace a hard reg, because hard regs can appear 2486: in more than one machine mode, and we must preserve the mode 2487: of each occurrence. Also, some hard regs appear in 2488: MEMs that are shared and mustn't be altered. Don't try to 2489: replace any reg that maps to a reg of class NO_REGS. */ 2490: if (REGNO (x) < FIRST_PSEUDO_REGISTER 2491: || ! REGNO_QTY_VALID_P (REGNO (x))) 2492: return x; 2493: 2494: first = qty_first_reg[reg_qty[REGNO (x)]]; 2495: return (first >= FIRST_PSEUDO_REGISTER ? regno_reg_rtx[first] 2496: : REGNO_REG_CLASS (first) == NO_REGS ? x 2497: : gen_rtx (REG, qty_mode[reg_qty[REGNO (x)]], first)); 2498: } 2499: } 2500: 2501: fmt = GET_RTX_FORMAT (code); 2502: for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--) 2503: { 2504: register int j; 2505: 2506: if (fmt[i] == 'e') 2507: { 2508: rtx new = canon_reg (XEXP (x, i), insn); 2509: 2510: /* If replacing pseudo with hard reg or vice versa, ensure the 1.1.1.3 root 2511: insn remains valid. Likewise if the insn has MATCH_DUPs. */ 1.1.1.4 root 2512: if (insn != 0 && new != 0 2513: && GET_CODE (new) == REG && GET_CODE (XEXP (x, i)) == REG 1.1.1.3 root 2514: && (((REGNO (new) < FIRST_PSEUDO_REGISTER) 2515: != (REGNO (XEXP (x, i)) < FIRST_PSEUDO_REGISTER)) 1.1.1.4 root 2516: || insn_n_dups[recog_memoized (insn)] > 0)) 2517: validate_change (insn, &XEXP (x, i), new, 1); 1.1 root 2518: else 2519: XEXP (x, i) = new; 2520: } 2521: else if (fmt[i] == 'E') 2522: for (j = 0; j < XVECLEN (x, i); j++) 2523: XVECEXP (x, i, j) = canon_reg (XVECEXP (x, i, j), insn); 2524: } 2525: 2526: return x; 2527: } 2528: 2529: /* LOC is a location with INSN that is an operand address (the contents of 2530: a MEM). Find the best equivalent address to use that is valid for this 2531: insn. 2532: 2533: On most CISC machines, complicated address modes are costly, and rtx_cost 2534: is a good approximation for that cost. However, most RISC machines have 2535: only a few (usually only one) memory reference formats. If an address is 2536: valid at all, it is often just as cheap as any other address. Hence, for 2537: RISC machines, we use the configuration macro `ADDRESS_COST' to compare the 2538: costs of various addresses. For two addresses of equal cost, choose the one 2539: with the highest `rtx_cost' value as that has the potential of eliminating 2540: the most insns. For equal costs, we choose the first in the equivalence 2541: class. Note that we ignore the fact that pseudo registers are cheaper 2542: than hard registers here because we would also prefer the pseudo registers. 2543: */ 2544: 1.1.1.5 root 2545: static void 1.1 root 2546: find_best_addr (insn, loc) 2547: rtx insn; 2548: rtx *loc; 2549: { 2550: struct table_elt *elt, *p; 2551: rtx addr = *loc; 2552: int our_cost; 2553: int found_better = 1; 2554: int save_do_not_record = do_not_record; 2555: int save_hash_arg_in_memory = hash_arg_in_memory; 2556: int save_hash_arg_in_struct = hash_arg_in_struct; 2557: int addr_volatile; 2558: int regno; 1.1.1.7 ! root 2559: unsigned hash; 1.1 root 2560: 2561: /* Do not try to replace constant addresses or addresses of local and 2562: argument slots. These MEM expressions are made only once and inserted 2563: in many instructions, as well as being used to control symbol table 2564: output. It is not safe to clobber them. 2565: 2566: There are some uncommon cases where the address is already in a register 2567: for some reason, but we cannot take advantage of that because we have 2568: no easy way to unshare the MEM. In addition, looking up all stack 2569: addresses is costly. */ 2570: if ((GET_CODE (addr) == PLUS 2571: && GET_CODE (XEXP (addr, 0)) == REG 2572: && GET_CODE (XEXP (addr, 1)) == CONST_INT 2573: && (regno = REGNO (XEXP (addr, 0)), 1.1.1.6 root 2574: regno == FRAME_POINTER_REGNUM || regno == HARD_FRAME_POINTER_REGNUM 2575: || regno == ARG_POINTER_REGNUM)) 1.1 root 2576: || (GET_CODE (addr) == REG 1.1.1.6 root 2577: && (regno = REGNO (addr), regno == FRAME_POINTER_REGNUM 2578: || regno == HARD_FRAME_POINTER_REGNUM 2579: || regno == ARG_POINTER_REGNUM)) 1.1 root 2580: || CONSTANT_ADDRESS_P (addr)) 2581: return; 2582: 2583: /* If this address is not simply a register, try to fold it. This will 2584: sometimes simplify the expression. Many simplifications 2585: will not be valid, but some, usually applying the associative rule, will 2586: be valid and produce better code. */ 2587: if (GET_CODE (addr) != REG 2588: && validate_change (insn, loc, fold_rtx (addr, insn), 0)) 2589: addr = *loc; 2590: 1.1.1.4 root 2591: /* If this address is not in the hash table, we can't look for equivalences 2592: of the whole address. Also, ignore if volatile. */ 2593: 1.1 root 2594: do_not_record = 0; 1.1.1.7 ! root 2595: hash = HASH (addr, Pmode); 1.1 root 2596: addr_volatile = do_not_record; 2597: do_not_record = save_do_not_record; 2598: hash_arg_in_memory = save_hash_arg_in_memory; 2599: hash_arg_in_struct = save_hash_arg_in_struct; 2600: 2601: if (addr_volatile) 2602: return; 2603: 1.1.1.7 ! root 2604: elt = lookup (addr, hash, Pmode); 1.1 root 2605: 2606: #ifndef ADDRESS_COST 1.1.1.4 root 2607: if (elt) 2608: { 2609: our_cost = elt->cost; 1.1 root 2610: 1.1.1.4 root 2611: /* Find the lowest cost below ours that works. */ 2612: for (elt = elt->first_same_value; elt; elt = elt->next_same_value) 2613: if (elt->cost < our_cost 2614: && (GET_CODE (elt->exp) == REG 2615: || exp_equiv_p (elt->exp, elt->exp, 1, 0)) 2616: && validate_change (insn, loc, 2617: canon_reg (copy_rtx (elt->exp), NULL_RTX), 0)) 2618: return; 2619: } 1.1 root 2620: #else 2621: 1.1.1.4 root 2622: if (elt) 2623: { 2624: /* We need to find the best (under the criteria documented above) entry 2625: in the class that is valid. We use the `flag' field to indicate 2626: choices that were invalid and iterate until we can't find a better 2627: one that hasn't already been tried. */ 2628: 2629: for (p = elt->first_same_value; p; p = p->next_same_value) 2630: p->flag = 0; 1.1 root 2631: 1.1.1.4 root 2632: while (found_better) 2633: { 2634: int best_addr_cost = ADDRESS_COST (*loc); 2635: int best_rtx_cost = (elt->cost + 1) >> 1; 2636: struct table_elt *best_elt = elt; 2637: 2638: found_better = 0; 2639: for (p = elt->first_same_value; p; p = p->next_same_value) 2640: if (! p->flag 2641: && (GET_CODE (p->exp) == REG 2642: || exp_equiv_p (p->exp, p->exp, 1, 0)) 2643: && (ADDRESS_COST (p->exp) < best_addr_cost 2644: || (ADDRESS_COST (p->exp) == best_addr_cost 2645: && (p->cost + 1) >> 1 > best_rtx_cost))) 2646: { 2647: found_better = 1; 2648: best_addr_cost = ADDRESS_COST (p->exp); 2649: best_rtx_cost = (p->cost + 1) >> 1; 2650: best_elt = p; 2651: } 1.1 root 2652: 1.1.1.4 root 2653: if (found_better) 2654: { 2655: if (validate_change (insn, loc, 2656: canon_reg (copy_rtx (best_elt->exp), 2657: NULL_RTX), 0)) 2658: return; 2659: else 2660: best_elt->flag = 1; 2661: } 2662: } 2663: } 2664: 2665: /* If the address is a binary operation with the first operand a register 2666: and the second a constant, do the same as above, but looking for 2667: equivalences of the register. Then try to simplify before checking for 2668: the best address to use. This catches a few cases: First is when we 2669: have REG+const and the register is another REG+const. We can often merge 2670: the constants and eliminate one insn and one register. It may also be 2671: that a machine has a cheap REG+REG+const. Finally, this improves the 2672: code on the Alpha for unaligned byte stores. */ 2673: 2674: if (flag_expensive_optimizations 2675: && (GET_RTX_CLASS (GET_CODE (*loc)) == '2' 2676: || GET_RTX_CLASS (GET_CODE (*loc)) == 'c') 2677: && GET_CODE (XEXP (*loc, 0)) == REG 2678: && GET_CODE (XEXP (*loc, 1)) == CONST_INT) 1.1 root 2679: { 1.1.1.4 root 2680: rtx c = XEXP (*loc, 1); 2681: 2682: do_not_record = 0; 1.1.1.7 ! root 2683: hash = HASH (XEXP (*loc, 0), Pmode); 1.1.1.4 root 2684: do_not_record = save_do_not_record; 2685: hash_arg_in_memory = save_hash_arg_in_memory; 2686: hash_arg_in_struct = save_hash_arg_in_struct; 2687: 1.1.1.7 ! root 2688: elt = lookup (XEXP (*loc, 0), hash, Pmode); 1.1.1.4 root 2689: if (elt == 0) 2690: return; 2691: 2692: /* We need to find the best (under the criteria documented above) entry 2693: in the class that is valid. We use the `flag' field to indicate 2694: choices that were invalid and iterate until we can't find a better 2695: one that hasn't already been tried. */ 1.1 root 2696: 2697: for (p = elt->first_same_value; p; p = p->next_same_value) 1.1.1.4 root 2698: p->flag = 0; 1.1 root 2699: 1.1.1.4 root 2700: while (found_better) 1.1 root 2701: { 1.1.1.4 root 2702: int best_addr_cost = ADDRESS_COST (*loc); 2703: int best_rtx_cost = (COST (*loc) + 1) >> 1; 2704: struct table_elt *best_elt = elt; 2705: rtx best_rtx = *loc; 1.1.1.7 ! root 2706: int count; ! 2707: ! 2708: /* This is at worst case an O(n^2) algorithm, so limit our search ! 2709: to the first 32 elements on the list. This avoids trouble ! 2710: compiling code with very long basic blocks that can easily ! 2711: call cse_gen_binary so many times that we run out of memory. */ 1.1.1.4 root 2712: 2713: found_better = 0; 1.1.1.7 ! root 2714: for (p = elt->first_same_value, count = 0; ! 2715: p && count < 32; ! 2716: p = p->next_same_value, count++) 1.1.1.4 root 2717: if (! p->flag 2718: && (GET_CODE (p->exp) == REG 2719: || exp_equiv_p (p->exp, p->exp, 1, 0))) 2720: { 1.1.1.5 root 2721: rtx new = cse_gen_binary (GET_CODE (*loc), Pmode, p->exp, c); 1.1.1.4 root 2722: 2723: if ((ADDRESS_COST (new) < best_addr_cost 2724: || (ADDRESS_COST (new) == best_addr_cost 2725: && (COST (new) + 1) >> 1 > best_rtx_cost))) 2726: { 2727: found_better = 1; 2728: best_addr_cost = ADDRESS_COST (new); 2729: best_rtx_cost = (COST (new) + 1) >> 1; 2730: best_elt = p; 2731: best_rtx = new; 2732: } 2733: } 2734: 2735: if (found_better) 2736: { 2737: if (validate_change (insn, loc, 2738: canon_reg (copy_rtx (best_rtx), 2739: NULL_RTX), 0)) 2740: return; 2741: else 2742: best_elt->flag = 1; 2743: } 1.1 root 2744: } 2745: } 2746: #endif 2747: } 2748: 2749: /* Given an operation (CODE, *PARG1, *PARG2), where code is a comparison 2750: operation (EQ, NE, GT, etc.), follow it back through the hash table and 2751: what values are being compared. 2752: 2753: *PARG1 and *PARG2 are updated to contain the rtx representing the values 2754: actually being compared. For example, if *PARG1 was (cc0) and *PARG2 2755: was (const_int 0), *PARG1 and *PARG2 will be set to the objects that were 2756: compared to produce cc0. 2757: 2758: The return value is the comparison operator and is either the code of 2759: A or the code corresponding to the inverse of the comparison. */ 2760: 2761: static enum rtx_code 1.1.1.4 root 2762: find_comparison_args (code, parg1, parg2, pmode1, pmode2) 1.1 root 2763: enum rtx_code code; 2764: rtx *parg1, *parg2; 1.1.1.4 root 2765: enum machine_mode *pmode1, *pmode2; 1.1 root 2766: { 2767: rtx arg1, arg2; 2768: 2769: arg1 = *parg1, arg2 = *parg2; 2770: 2771: /* If ARG2 is const0_rtx, see what ARG1 is equivalent to. */ 2772: 1.1.1.4 root 2773: while (arg2 == CONST0_RTX (GET_MODE (arg1))) 1.1 root 2774: { 2775: /* Set non-zero when we find something of interest. */ 2776: rtx x = 0; 2777: int reverse_code = 0; 2778: struct table_elt *p = 0; 2779: 2780: /* If arg1 is a COMPARE, extract the comparison arguments from it. 2781: On machines with CC0, this is the only case that can occur, since 2782: fold_rtx will return the COMPARE or item being compared with zero 2783: when given CC0. */ 2784: 2785: if (GET_CODE (arg1) == COMPARE && arg2 == const0_rtx) 2786: x = arg1; 2787: 2788: /* If ARG1 is a comparison operator and CODE is testing for 2789: STORE_FLAG_VALUE, get the inner arguments. */ 2790: 2791: else if (GET_RTX_CLASS (GET_CODE (arg1)) == '<') 2792: { 1.1.1.4 root 2793: if (code == NE 2794: || (GET_MODE_CLASS (GET_MODE (arg1)) == MODE_INT 2795: && code == LT && STORE_FLAG_VALUE == -1) 2796: #ifdef FLOAT_STORE_FLAG_VALUE 2797: || (GET_MODE_CLASS (GET_MODE (arg1)) == MODE_FLOAT 2798: && FLOAT_STORE_FLAG_VALUE < 0) 2799: #endif 2800: ) 1.1 root 2801: x = arg1; 1.1.1.4 root 2802: else if (code == EQ 2803: || (GET_MODE_CLASS (GET_MODE (arg1)) == MODE_INT 2804: && code == GE && STORE_FLAG_VALUE == -1) 2805: #ifdef FLOAT_STORE_FLAG_VALUE 2806: || (GET_MODE_CLASS (GET_MODE (arg1)) == MODE_FLOAT 2807: && FLOAT_STORE_FLAG_VALUE < 0) 2808: #endif 2809: ) 1.1 root 2810: x = arg1, reverse_code = 1; 2811: } 2812: 2813: /* ??? We could also check for 2814: 2815: (ne (and (eq (...) (const_int 1))) (const_int 0)) 2816: 2817: and related forms, but let's wait until we see them occurring. */ 2818: 2819: if (x == 0) 2820: /* Look up ARG1 in the hash table and see if it has an equivalence 2821: that lets us see what is being compared. */ 2822: p = lookup (arg1, safe_hash (arg1, GET_MODE (arg1)) % NBUCKETS, 2823: GET_MODE (arg1)); 2824: if (p) p = p->first_same_value; 2825: 2826: for (; p; p = p->next_same_value) 2827: { 2828: enum machine_mode inner_mode = GET_MODE (p->exp); 2829: 2830: /* If the entry isn't valid, skip it. */ 2831: if (! exp_equiv_p (p->exp, p->exp, 1, 0)) 2832: continue; 2833: 2834: if (GET_CODE (p->exp) == COMPARE 2835: /* Another possibility is that this machine has a compare insn 2836: that includes the comparison code. In that case, ARG1 would 2837: be equivalent to a comparison operation that would set ARG1 to 2838: either STORE_FLAG_VALUE or zero. If this is an NE operation, 2839: ORIG_CODE is the actual comparison being done; if it is an EQ, 2840: we must reverse ORIG_CODE. On machine with a negative value 2841: for STORE_FLAG_VALUE, also look at LT and GE operations. */ 2842: || ((code == NE 2843: || (code == LT 1.1.1.4 root 2844: && GET_MODE_CLASS (inner_mode) == MODE_INT 2845: && (GET_MODE_BITSIZE (inner_mode) 2846: <= HOST_BITS_PER_WIDE_INT) 1.1 root 2847: && (STORE_FLAG_VALUE 1.1.1.4 root 2848: & ((HOST_WIDE_INT) 1 2849: << (GET_MODE_BITSIZE (inner_mode) - 1)))) 2850: #ifdef FLOAT_STORE_FLAG_VALUE 2851: || (code == LT 2852: && GET_MODE_CLASS (inner_mode) == MODE_FLOAT 2853: && FLOAT_STORE_FLAG_VALUE < 0) 2854: #endif 2855: ) 1.1 root 2856: && GET_RTX_CLASS (GET_CODE (p->exp)) == '<')) 2857: { 2858: x = p->exp; 2859: break; 2860: } 2861: else if ((code == EQ 2862: || (code == GE 1.1.1.4 root 2863: && GET_MODE_CLASS (inner_mode) == MODE_INT 2864: && (GET_MODE_BITSIZE (inner_mode) 2865: <= HOST_BITS_PER_WIDE_INT) 1.1 root 2866: && (STORE_FLAG_VALUE 1.1.1.4 root 2867: & ((HOST_WIDE_INT) 1 2868: << (GET_MODE_BITSIZE (inner_mode) - 1)))) 2869: #ifdef FLOAT_STORE_FLAG_VALUE 2870: || (code == GE 2871: && GET_MODE_CLASS (inner_mode) == MODE_FLOAT 2872: && FLOAT_STORE_FLAG_VALUE < 0) 2873: #endif 2874: ) 1.1 root 2875: && GET_RTX_CLASS (GET_CODE (p->exp)) == '<') 2876: { 2877: reverse_code = 1; 2878: x = p->exp; 2879: break; 2880: } 2881: 2882: /* If this is fp + constant, the equivalent is a better operand since 2883: it may let us predict the value of the comparison. */ 2884: else if (NONZERO_BASE_PLUS_P (p->exp)) 2885: { 2886: arg1 = p->exp; 2887: continue; 2888: } 2889: } 2890: 2891: /* If we didn't find a useful equivalence for ARG1, we are done. 2892: Otherwise, set up for the next iteration. */ 2893: if (x == 0) 2894: break; 2895: 2896: arg1 = XEXP (x, 0), arg2 = XEXP (x, 1); 2897: if (GET_RTX_CLASS (GET_CODE (x)) == '<') 2898: code = GET_CODE (x); 2899: 2900: if (reverse_code) 2901: code = reverse_condition (code); 2902: } 2903: 1.1.1.4 root 2904: /* Return our results. Return the modes from before fold_rtx 2905: because fold_rtx might produce const_int, and then it's too late. */ 2906: *pmode1 = GET_MODE (arg1), *pmode2 = GET_MODE (arg2); 1.1 root 2907: *parg1 = fold_rtx (arg1, 0), *parg2 = fold_rtx (arg2, 0); 2908: 2909: return code; 2910: } 2911: 2912: /* Try to simplify a unary operation CODE whose output mode is to be 2913: MODE with input operand OP whose mode was originally OP_MODE. 2914: Return zero if no simplification can be made. */ 2915: 2916: rtx 2917: simplify_unary_operation (code, mode, op, op_mode) 2918: enum rtx_code code; 2919: enum machine_mode mode; 2920: rtx op; 2921: enum machine_mode op_mode; 2922: { 2923: register int width = GET_MODE_BITSIZE (mode); 2924: 2925: /* The order of these tests is critical so that, for example, we don't 2926: check the wrong mode (input vs. output) for a conversion operation, 2927: such as FIX. At some point, this should be simplified. */ 2928: 1.1.1.7 ! root 2929: #if !defined(REAL_IS_NOT_DOUBLE) || defined(REAL_ARITHMETIC) 1.1 root 2930: 1.1.1.7 ! root 2931: if (code == FLOAT && GET_MODE (op) == VOIDmode ! 2932: && (GET_CODE (op) == CONST_DOUBLE || GET_CODE (op) == CONST_INT)) 1.1 root 2933: { 1.1.1.7 ! root 2934: HOST_WIDE_INT hv, lv; 1.1 root 2935: REAL_VALUE_TYPE d; 2936: 1.1.1.7 ! root 2937: if (GET_CODE (op) == CONST_INT) ! 2938: lv = INTVAL (op), hv = INTVAL (op) < 0 ? -1 : 0; ! 2939: else ! 2940: lv = CONST_DOUBLE_LOW (op), hv = CONST_DOUBLE_HIGH (op); 1.1 root 2941: 2942: #ifdef REAL_ARITHMETIC 1.1.1.7 ! root 2943: REAL_VALUE_FROM_INT (d, lv, hv); 1.1 root 2944: #else 1.1.1.7 ! root 2945: if (hv < 0) 1.1 root 2946: { 1.1.1.7 ! root 2947: d = (double) (~ hv); 1.1.1.4 root 2948: d *= ((double) ((HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT / 2)) 2949: * (double) ((HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT / 2))); 1.1.1.7 ! root 2950: d += (double) (unsigned HOST_WIDE_INT) (~ lv); 1.1 root 2951: d = (- d - 1.0); 2952: } 2953: else 2954: { 1.1.1.7 ! root 2955: d = (double) hv; 1.1.1.4 root 2956: d *= ((double) ((HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT / 2)) 2957: * (double) ((HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT / 2))); 1.1.1.7 ! root 2958: d += (double) (unsigned HOST_WIDE_INT) lv; 1.1 root 2959: } 2960: #endif /* REAL_ARITHMETIC */ 1.1.1.7 ! root 2961: 1.1 root 2962: return CONST_DOUBLE_FROM_REAL_VALUE (d, mode); 2963: } 1.1.1.7 ! root 2964: else if (code == UNSIGNED_FLOAT && GET_MODE (op) == VOIDmode ! 2965: && (GET_CODE (op) == CONST_DOUBLE || GET_CODE (op) == CONST_INT)) 1.1 root 2966: { 1.1.1.7 ! root 2967: HOST_WIDE_INT hv, lv; 1.1 root 2968: REAL_VALUE_TYPE d; 2969: 1.1.1.7 ! root 2970: if (GET_CODE (op) == CONST_INT) ! 2971: lv = INTVAL (op), hv = INTVAL (op) < 0 ? -1 : 0; ! 2972: else ! 2973: lv = CONST_DOUBLE_LOW (op), hv = CONST_DOUBLE_HIGH (op); ! 2974: ! 2975: if (GET_MODE_BITSIZE (op_mode) >= HOST_BITS_PER_WIDE_INT * 2) ! 2976: ; ! 2977: else ! 2978: hv = 0, lv &= GET_MODE_MASK (op_mode); ! 2979: 1.1 root 2980: #ifdef REAL_ARITHMETIC 1.1.1.7 ! root 2981: REAL_VALUE_FROM_UNSIGNED_INT (d, lv, hv); 1.1 root 2982: #else 1.1.1.7 ! root 2983: ! 2984: d = (double) (unsigned HOST_WIDE_INT) hv; 1.1.1.4 root 2985: d *= ((double) ((HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT / 2)) 2986: * (double) ((HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT / 2))); 1.1.1.7 ! root 2987: d += (double) (unsigned HOST_WIDE_INT) lv; 1.1 root 2988: #endif /* REAL_ARITHMETIC */ 1.1.1.7 ! root 2989: 1.1 root 2990: return CONST_DOUBLE_FROM_REAL_VALUE (d, mode); 2991: } 2992: #endif 2993: 1.1.1.4 root 2994: if (GET_CODE (op) == CONST_INT 2995: && width <= HOST_BITS_PER_WIDE_INT && width > 0) 1.1 root 2996: { 1.1.1.4 root 2997: register HOST_WIDE_INT arg0 = INTVAL (op); 2998: register HOST_WIDE_INT val; 1.1 root 2999: 3000: switch (code) 3001: { 3002: case NOT: 3003: val = ~ arg0; 3004: break; 3005: 3006: case NEG: 3007: val = - arg0; 3008: break; 3009: 3010: case ABS: 3011: val = (arg0 >= 0 ? arg0 : - arg0); 3012: break; 3013: 3014: case FFS: 3015: /* Don't use ffs here. Instead, get low order bit and then its 3016: number. If arg0 is zero, this will return 0, as desired. */ 3017: arg0 &= GET_MODE_MASK (mode); 3018: val = exact_log2 (arg0 & (- arg0)) + 1; 3019: break; 3020: 3021: case TRUNCATE: 3022: val = arg0; 3023: break; 3024: 3025: case ZERO_EXTEND: 3026: if (op_mode == VOIDmode) 3027: op_mode = mode; 1.1.1.4 root 3028: if (GET_MODE_BITSIZE (op_mode) == HOST_BITS_PER_WIDE_INT) 3029: { 3030: /* If we were really extending the mode, 3031: we would have to distinguish between zero-extension 3032: and sign-extension. */ 3033: if (width != GET_MODE_BITSIZE (op_mode)) 3034: abort (); 3035: val = arg0; 3036: } 3037: else if (GET_MODE_BITSIZE (op_mode) < HOST_BITS_PER_WIDE_INT) 3038: val = arg0 & ~((HOST_WIDE_INT) (-1) << GET_MODE_BITSIZE (op_mode)); 1.1 root 3039: else 3040: return 0; 3041: break; 3042: 3043: case SIGN_EXTEND: 3044: if (op_mode == VOIDmode) 3045: op_mode = mode; 1.1.1.4 root 3046: if (GET_MODE_BITSIZE (op_mode) == HOST_BITS_PER_WIDE_INT) 3047: { 3048: /* If we were really extending the mode, 3049: we would have to distinguish between zero-extension 3050: and sign-extension. */ 3051: if (width != GET_MODE_BITSIZE (op_mode)) 3052: abort (); 3053: val = arg0; 3054: } 3055: else if (GET_MODE_BITSIZE (op_mode) < HOST_BITS_PER_WIDE_INT) 3056: { 3057: val 3058: = arg0 & ~((HOST_WIDE_INT) (-1) << GET_MODE_BITSIZE (op_mode)); 3059: if (val 3060: & ((HOST_WIDE_INT) 1 << (GET_MODE_BITSIZE (op_mode) - 1))) 3061: val -= (HOST_WIDE_INT) 1 << GET_MODE_BITSIZE (op_mode); 1.1 root 3062: } 3063: else 3064: return 0; 3065: break; 3066: 1.1.1.2 root 3067: case SQRT: 3068: return 0; 3069: 1.1 root 3070: default: 3071: abort (); 3072: } 3073: 3074: /* Clear the bits that don't belong in our mode, 3075: unless they and our sign bit are all one. 3076: So we get either a reasonable negative value or a reasonable 3077: unsigned value for this mode. */ 1.1.1.4 root 3078: if (width < HOST_BITS_PER_WIDE_INT 3079: && ((val & ((HOST_WIDE_INT) (-1) << (width - 1))) 3080: != ((HOST_WIDE_INT) (-1) << (width - 1)))) 1.1 root 3081: val &= (1 << width) - 1; 3082: 1.1.1.4 root 3083: return GEN_INT (val); 1.1 root 3084: } 3085: 3086: /* We can do some operations on integer CONST_DOUBLEs. Also allow 3087: for a DImode operation on a CONST_INT. */ 1.1.1.7 ! root 3088: else if (GET_MODE (op) == VOIDmode && width <= HOST_BITS_PER_INT * 2 1.1 root 3089: && (GET_CODE (op) == CONST_DOUBLE || GET_CODE (op) == CONST_INT)) 3090: { 1.1.1.4 root 3091: HOST_WIDE_INT l1, h1, lv, hv; 1.1 root 3092: 3093: if (GET_CODE (op) == CONST_DOUBLE) 3094: l1 = CONST_DOUBLE_LOW (op), h1 = CONST_DOUBLE_HIGH (op); 3095: else 3096: l1 = INTVAL (op), h1 = l1 < 0 ? -1 : 0; 3097: 3098: switch (code) 3099: { 3100: case NOT: 3101: lv = ~ l1; 3102: hv = ~ h1; 3103: break; 3104: 3105: case NEG: 3106: neg_double (l1, h1, &lv, &hv); 3107: break; 3108: 3109: case ABS: 3110: if (h1 < 0) 3111: neg_double (l1, h1, &lv, &hv); 3112: else 3113: lv = l1, hv = h1; 3114: break; 3115: 3116: case FFS: 3117: hv = 0; 3118: if (l1 == 0) 1.1.1.4 root 3119: lv = HOST_BITS_PER_WIDE_INT + exact_log2 (h1 & (-h1)) + 1; 1.1 root 3120: else 3121: lv = exact_log2 (l1 & (-l1)) + 1; 3122: break; 3123: 3124: case TRUNCATE: 1.1.1.7 ! root 3125: /* This is just a change-of-mode, so do nothing. */ ! 3126: lv = l1, hv = h1; 1.1 root 3127: break; 3128: 1.1.1.4 root 3129: case ZERO_EXTEND: 3130: if (op_mode == VOIDmode 3131: || GET_MODE_BITSIZE (op_mode) > HOST_BITS_PER_WIDE_INT) 3132: return 0; 3133: 3134: hv = 0; 3135: lv = l1 & GET_MODE_MASK (op_mode); 3136: break; 3137: 3138: case SIGN_EXTEND: 3139: if (op_mode == VOIDmode 3140: || GET_MODE_BITSIZE (op_mode) > HOST_BITS_PER_WIDE_INT) 3141: return 0; 3142: else 3143: { 3144: lv = l1 & GET_MODE_MASK (op_mode); 3145: if (GET_MODE_BITSIZE (op_mode) < HOST_BITS_PER_WIDE_INT 3146: && (lv & ((HOST_WIDE_INT) 1 3147: << (GET_MODE_BITSIZE (op_mode) - 1))) != 0) 3148: lv -= (HOST_WIDE_INT) 1 << GET_MODE_BITSIZE (op_mode); 3149: 3150: hv = (lv < 0) ? ~ (HOST_WIDE_INT) 0 : 0; 3151: } 3152: break; 3153: 1.1.1.2 root 3154: case SQRT: 3155: return 0; 3156: 1.1 root 3157: default: 3158: return 0; 3159: } 3160: 3161: return immed_double_const (lv, hv, mode); 3162: } 3163: 3164: #if ! defined (REAL_IS_NOT_DOUBLE) || defined (REAL_ARITHMETIC) 3165: else if (GET_CODE (op) == CONST_DOUBLE 3166: && GET_MODE_CLASS (mode) == MODE_FLOAT) 3167: { 3168: REAL_VALUE_TYPE d; 3169: jmp_buf handler; 3170: rtx x; 3171: 3172: if (setjmp (handler)) 3173: /* There used to be a warning here, but that is inadvisable. 3174: People may want to cause traps, and the natural way 3175: to do it should not get a warning. */ 3176: return 0; 3177: 3178: set_float_handler (handler); 3179: 3180: REAL_VALUE_FROM_CONST_DOUBLE (d, op); 3181: 3182: switch (code) 3183: { 3184: case NEG: 3185: d = REAL_VALUE_NEGATE (d); 3186: break; 3187: 3188: case ABS: 1.1.1.3 root 3189: if (REAL_VALUE_NEGATIVE (d)) 1.1 root 3190: d = REAL_VALUE_NEGATE (d); 3191: break; 3192: 3193: case FLOAT_TRUNCATE: 1.1.1.5 root 3194: d = real_value_truncate (mode, d); 1.1 root 3195: break; 3196: 3197: case FLOAT_EXTEND: 3198: /* All this does is change the mode. */ 3199: break; 3200: 3201: case FIX: 1.1.1.5 root 3202: d = REAL_VALUE_RNDZINT (d); 1.1 root 3203: break; 3204: 3205: case UNSIGNED_FIX: 1.1.1.5 root 3206: d = REAL_VALUE_UNSIGNED_RNDZINT (d); 1.1 root 3207: break; 3208: 1.1.1.2 root 3209: case SQRT: 3210: return 0; 3211: 1.1 root 3212: default: 3213: abort (); 3214: } 3215: 1.1.1.7 ! root 3216: x = CONST_DOUBLE_FROM_REAL_VALUE (d, mode); 1.1.1.4 root 3217: set_float_handler (NULL_PTR); 1.1 root 3218: return x; 3219: } 1.1.1.7 ! root 3220: ! 3221: else if (GET_CODE (op) == CONST_DOUBLE ! 3222: && GET_MODE_CLASS (GET_MODE (op)) == MODE_FLOAT ! 3223: && GET_MODE_CLASS (mode) == MODE_INT 1.1.1.4 root 3224: && width <= HOST_BITS_PER_WIDE_INT && width > 0) 1.1 root 3225: { 3226: REAL_VALUE_TYPE d; 3227: jmp_buf handler; 1.1.1.4 root 3228: HOST_WIDE_INT val; 1.1 root 3229: 3230: if (setjmp (handler)) 3231: return 0; 3232: 3233: set_float_handler (handler); 3234: 3235: REAL_VALUE_FROM_CONST_DOUBLE (d, op); 3236: 3237: switch (code) 3238: { 3239: case FIX: 3240: val = REAL_VALUE_FIX (d); 3241: break; 3242: 3243: case UNSIGNED_FIX: 3244: val = REAL_VALUE_UNSIGNED_FIX (d); 3245: break; 3246: 3247: default: 3248: abort (); 3249: } 3250: 1.1.1.4 root 3251: set_float_handler (NULL_PTR); 1.1 root 3252: 3253: /* Clear the bits that don't belong in our mode, 3254: unless they and our sign bit are all one. 3255: So we get either a reasonable negative value or a reasonable 3256: unsigned value for this mode. */ 1.1.1.4 root 3257: if (width < HOST_BITS_PER_WIDE_INT 3258: && ((val & ((HOST_WIDE_INT) (-1) << (width - 1))) 3259: != ((HOST_WIDE_INT) (-1) << (width - 1)))) 3260: val &= ((HOST_WIDE_INT) 1 << width) - 1; 1.1 root 3261: 1.1.1.4 root 3262: return GEN_INT (val); 1.1 root 3263: } 3264: #endif 1.1.1.3 root 3265: /* This was formerly used only for non-IEEE float. 3266: [email protected] says it is safe for IEEE also. */ 3267: else 1.1 root 3268: { 3269: /* There are some simplifications we can do even if the operands 1.1.1.3 root 3270: aren't constant. */ 1.1 root 3271: switch (code) 3272: { 3273: case NEG: 3274: case NOT: 3275: /* (not (not X)) == X, similarly for NEG. */ 3276: if (GET_CODE (op) == code) 3277: return XEXP (op, 0); 3278: break; 3279: 3280: case SIGN_EXTEND: 3281: /* (sign_extend (truncate (minus (label_ref L1) (label_ref L2)))) 3282: becomes just the MINUS if its mode is MODE. This allows 3283: folding switch statements on machines using casesi (such as 3284: the Vax). */ 3285: if (GET_CODE (op) == TRUNCATE 3286: && GET_MODE (XEXP (op, 0)) == mode 3287: && GET_CODE (XEXP (op, 0)) == MINUS 3288: && GET_CODE (XEXP (XEXP (op, 0), 0)) == LABEL_REF 3289: && GET_CODE (XEXP (XEXP (op, 0), 1)) == LABEL_REF) 3290: return XEXP (op, 0); 3291: break; 3292: } 3293: 3294: return 0; 3295: } 3296: } 3297: 3298: /* Simplify a binary operation CODE with result mode MODE, operating on OP0 3299: and OP1. Return 0 if no simplification is possible. 3300: 3301: Don't use this for relational operations such as EQ or LT. 3302: Use simplify_relational_operation instead. */ 3303: 3304: rtx 3305: simplify_binary_operation (code, mode, op0, op1) 3306: enum rtx_code code; 3307: enum machine_mode mode; 3308: rtx op0, op1; 3309: { 1.1.1.4 root 3310: register HOST_WIDE_INT arg0, arg1, arg0s, arg1s; 3311: HOST_WIDE_INT val; 1.1 root 3312: int width = GET_MODE_BITSIZE (mode); 1.1.1.5 root 3313: rtx tem; 1.1 root 3314: 3315: /* Relational operations don't work here. We must know the mode 3316: of the operands in order to do the comparison correctly. 3317: Assuming a full word can give incorrect results. 3318: Consider comparing 128 with -128 in QImode. */ 3319: 3320: if (GET_RTX_CLASS (code) == '<') 3321: abort (); 3322: 3323: #if ! defined (REAL_IS_NOT_DOUBLE) || defined (REAL_ARITHMETIC) 3324: if (GET_MODE_CLASS (mode) == MODE_FLOAT 3325: && GET_CODE (op0) == CONST_DOUBLE && GET_CODE (op1) == CONST_DOUBLE 3326: && mode == GET_MODE (op0) && mode == GET_MODE (op1)) 3327: { 3328: REAL_VALUE_TYPE f0, f1, value; 3329: jmp_buf handler; 3330: 3331: if (setjmp (handler)) 3332: return 0; 3333: 3334: set_float_handler (handler); 3335: 3336: REAL_VALUE_FROM_CONST_DOUBLE (f0, op0); 3337: REAL_VALUE_FROM_CONST_DOUBLE (f1, op1); 1.1.1.4 root 3338: f0 = real_value_truncate (mode, f0); 3339: f1 = real_value_truncate (mode, f1); 1.1 root 3340: 3341: #ifdef REAL_ARITHMETIC 1.1.1.5 root 3342: REAL_ARITHMETIC (value, rtx_to_tree_code (code), f0, f1); 1.1 root 3343: #else 3344: switch (code) 3345: { 3346: case PLUS: 3347: value = f0 + f1; 3348: break; 3349: case MINUS: 3350: value = f0 - f1; 3351: break; 3352: case MULT: 3353: value = f0 * f1; 3354: break; 3355: case DIV: 3356: #ifndef REAL_INFINITY 3357: if (f1 == 0) 1.1.1.4 root 3358: return 0; 1.1 root 3359: #endif 3360: value = f0 / f1; 3361: break; 3362: case SMIN: 3363: value = MIN (f0, f1); 3364: break; 3365: case SMAX: 3366: value = MAX (f0, f1); 3367: break; 3368: default: 3369: abort (); 3370: } 3371: #endif 3372: 1.1.1.4 root 3373: value = real_value_truncate (mode, value); 1.1.1.7 ! root 3374: set_float_handler (NULL_PTR); ! 3375: return CONST_DOUBLE_FROM_REAL_VALUE (value, mode); 1.1 root 3376: } 1.1.1.5 root 3377: #endif /* not REAL_IS_NOT_DOUBLE, or REAL_ARITHMETIC */ 1.1 root 3378: 3379: /* We can fold some multi-word operations. */ 1.1.1.5 root 3380: if (GET_MODE_CLASS (mode) == MODE_INT 1.1.1.6 root 3381: && width == HOST_BITS_PER_WIDE_INT * 2 3382: && (GET_CODE (op0) == CONST_DOUBLE || GET_CODE (op0) == CONST_INT) 1.1.1.5 root 3383: && (GET_CODE (op1) == CONST_DOUBLE || GET_CODE (op1) == CONST_INT)) 1.1 root 3384: { 1.1.1.4 root 3385: HOST_WIDE_INT l1, l2, h1, h2, lv, hv; 1.1 root 3386: 1.1.1.6 root 3387: if (GET_CODE (op0) == CONST_DOUBLE) 3388: l1 = CONST_DOUBLE_LOW (op0), h1 = CONST_DOUBLE_HIGH (op0); 3389: else 3390: l1 = INTVAL (op0), h1 = l1 < 0 ? -1 : 0; 1.1 root 3391: 3392: if (GET_CODE (op1) == CONST_DOUBLE) 3393: l2 = CONST_DOUBLE_LOW (op1), h2 = CONST_DOUBLE_HIGH (op1); 3394: else 3395: l2 = INTVAL (op1), h2 = l2 < 0 ? -1 : 0; 3396: 3397: switch (code) 3398: { 3399: case MINUS: 3400: /* A - B == A + (-B). */ 3401: neg_double (l2, h2, &lv, &hv); 3402: l2 = lv, h2 = hv; 3403: 3404: /* .. fall through ... */ 3405: 3406: case PLUS: 3407: add_double (l1, h1, l2, h2, &lv, &hv); 3408: break; 3409: 3410: case MULT: 3411: mul_double (l1, h1, l2, h2, &lv, &hv); 3412: break; 3413: 3414: case DIV: case MOD: case UDIV: case UMOD: 3415: /* We'd need to include tree.h to do this and it doesn't seem worth 3416: it. */ 3417: return 0; 3418: 3419: case AND: 3420: lv = l1 & l2, hv = h1 & h2; 3421: break; 3422: 3423: case IOR: 3424: lv = l1 | l2, hv = h1 | h2; 3425: break; 3426: 3427: case XOR: 3428: lv = l1 ^ l2, hv = h1 ^ h2; 3429: break; 3430: 3431: case SMIN: 1.1.1.4 root 3432: if (h1 < h2 3433: || (h1 == h2 3434: && ((unsigned HOST_WIDE_INT) l1 3435: < (unsigned HOST_WIDE_INT) l2))) 1.1 root 3436: lv = l1, hv = h1; 3437: else 3438: lv = l2, hv = h2; 3439: break; 3440: 3441: case SMAX: 1.1.1.4 root 3442: if (h1 > h2 3443: || (h1 == h2 3444: && ((unsigned HOST_WIDE_INT) l1 3445: > (unsigned HOST_WIDE_INT) l2))) 1.1 root 3446: lv = l1, hv = h1; 3447: else 3448: lv = l2, hv = h2; 3449: break; 3450: 3451: case UMIN: 1.1.1.4 root 3452: if ((unsigned HOST_WIDE_INT) h1 < (unsigned HOST_WIDE_INT) h2 3453: || (h1 == h2 3454: && ((unsigned HOST_WIDE_INT) l1 3455: < (unsigned HOST_WIDE_INT) l2))) 1.1 root 3456: lv = l1, hv = h1; 3457: else 3458: lv = l2, hv = h2; 3459: break; 3460: 3461: case UMAX: 1.1.1.4 root 3462: if ((unsigned HOST_WIDE_INT) h1 > (unsigned HOST_WIDE_INT) h2 3463: || (h1 == h2 3464: && ((unsigned HOST_WIDE_INT) l1 3465: > (unsigned HOST_WIDE_INT) l2))) 1.1 root 3466: lv = l1, hv = h1; 3467: else 3468: lv = l2, hv = h2; 3469: break; 3470: 3471: case LSHIFTRT: case ASHIFTRT: 1.1.1.7 ! root 3472: case ASHIFT: 1.1 root 3473: case ROTATE: case ROTATERT: 3474: #ifdef SHIFT_COUNT_TRUNCATED 1.1.1.6 root 3475: if (SHIFT_COUNT_TRUNCATED) 3476: l2 &= (GET_MODE_BITSIZE (mode) - 1), h2 = 0; 1.1 root 3477: #endif 3478: 3479: if (h2 != 0 || l2 < 0 || l2 >= GET_MODE_BITSIZE (mode)) 3480: return 0; 3481: 3482: if (code == LSHIFTRT || code == ASHIFTRT) 3483: rshift_double (l1, h1, l2, GET_MODE_BITSIZE (mode), &lv, &hv, 3484: code == ASHIFTRT); 1.1.1.7 ! root 3485: else if (code == ASHIFT) ! 3486: lshift_double (l1, h1, l2, GET_MODE_BITSIZE (mode), &lv, &hv, 1); 1.1 root 3487: else if (code == ROTATE) 3488: lrotate_double (l1, h1, l2, GET_MODE_BITSIZE (mode), &lv, &hv); 3489: else /* code == ROTATERT */ 3490: rrotate_double (l1, h1, l2, GET_MODE_BITSIZE (mode), &lv, &hv); 3491: break; 3492: 3493: default: 3494: return 0; 3495: } 3496: 3497: return immed_double_const (lv, hv, mode); 3498: } 3499: 3500: if (GET_CODE (op0) != CONST_INT || GET_CODE (op1) != CONST_INT 1.1.1.4 root 3501: || width > HOST_BITS_PER_WIDE_INT || width == 0) 1.1 root 3502: { 3503: /* Even if we can't compute a constant result, 3504: there are some cases worth simplifying. */ 3505: 3506: switch (code) 3507: { 3508: case PLUS: 3509: /* In IEEE floating point, x+0 is not the same as x. Similarly 3510: for the other optimizations below. */ 3511: if (TARGET_FLOAT_FORMAT == IEEE_FLOAT_FORMAT 1.1.1.7 ! root 3512: && FLOAT_MODE_P (mode) && ! flag_fast_math) 1.1 root 3513: break; 3514: 3515: if (op1 == CONST0_RTX (mode)) 3516: return op0; 3517: 3518: /* ((-a) + b) -> (b - a) and similarly for (a + (-b)) */ 3519: if (GET_CODE (op0) == NEG) 1.1.1.5 root 3520: return cse_gen_binary (MINUS, mode, op1, XEXP (op0, 0)); 1.1 root 3521: else if (GET_CODE (op1) == NEG) 1.1.1.5 root 3522: return cse_gen_binary (MINUS, mode, op0, XEXP (op1, 0)); 1.1 root 3523: 1.1.1.5 root 3524: /* Handle both-operands-constant cases. We can only add 3525: CONST_INTs to constants since the sum of relocatable symbols 1.1.1.6 root 3526: can't be handled by most assemblers. Don't add CONST_INT 3527: to CONST_INT since overflow won't be computed properly if wider 3528: than HOST_BITS_PER_WIDE_INT. */ 1.1 root 3529: 1.1.1.6 root 3530: if (CONSTANT_P (op0) && GET_MODE (op0) != VOIDmode 3531: && GET_CODE (op1) == CONST_INT) 1.1.1.5 root 3532: return plus_constant (op0, INTVAL (op1)); 1.1.1.6 root 3533: else if (CONSTANT_P (op1) && GET_MODE (op1) != VOIDmode 3534: && GET_CODE (op0) == CONST_INT) 1.1.1.5 root 3535: return plus_constant (op1, INTVAL (op0)); 1.1 root 3536: 1.1.1.7 ! root 3537: /* See if this is something like X * C - X or vice versa or ! 3538: if the multiplication is written as a shift. If so, we can ! 3539: distribute and make a new multiply, shift, or maybe just ! 3540: have X (if C is 2 in the example above). But don't make ! 3541: real multiply if we didn't have one before. */ ! 3542: ! 3543: if (! FLOAT_MODE_P (mode)) ! 3544: { ! 3545: HOST_WIDE_INT coeff0 = 1, coeff1 = 1; ! 3546: rtx lhs = op0, rhs = op1; ! 3547: int had_mult = 0; ! 3548: ! 3549: if (GET_CODE (lhs) == NEG) ! 3550: coeff0 = -1, lhs = XEXP (lhs, 0); ! 3551: else if (GET_CODE (lhs) == MULT ! 3552: && GET_CODE (XEXP (lhs, 1)) == CONST_INT) ! 3553: { ! 3554: coeff0 = INTVAL (XEXP (lhs, 1)), lhs = XEXP (lhs, 0); ! 3555: had_mult = 1; ! 3556: } ! 3557: else if (GET_CODE (lhs) == ASHIFT ! 3558: && GET_CODE (XEXP (lhs, 1)) == CONST_INT ! 3559: && INTVAL (XEXP (lhs, 1)) >= 0 ! 3560: && INTVAL (XEXP (lhs, 1)) < HOST_BITS_PER_WIDE_INT) ! 3561: { ! 3562: coeff0 = ((HOST_WIDE_INT) 1) << INTVAL (XEXP (lhs, 1)); ! 3563: lhs = XEXP (lhs, 0); ! 3564: } ! 3565: ! 3566: if (GET_CODE (rhs) == NEG) ! 3567: coeff1 = -1, rhs = XEXP (rhs, 0); ! 3568: else if (GET_CODE (rhs) == MULT ! 3569: && GET_CODE (XEXP (rhs, 1)) == CONST_INT) ! 3570: { ! 3571: coeff1 = INTVAL (XEXP (rhs, 1)), rhs = XEXP (rhs, 0); ! 3572: had_mult = 1; ! 3573: } ! 3574: else if (GET_CODE (rhs) == ASHIFT ! 3575: && GET_CODE (XEXP (rhs, 1)) == CONST_INT ! 3576: && INTVAL (XEXP (rhs, 1)) >= 0 ! 3577: && INTVAL (XEXP (rhs, 1)) < HOST_BITS_PER_WIDE_INT) ! 3578: { ! 3579: coeff1 = ((HOST_WIDE_INT) 1) << INTVAL (XEXP (rhs, 1)); ! 3580: rhs = XEXP (rhs, 0); ! 3581: } ! 3582: ! 3583: if (rtx_equal_p (lhs, rhs)) ! 3584: { ! 3585: tem = cse_gen_binary (MULT, mode, lhs, ! 3586: GEN_INT (coeff0 + coeff1)); ! 3587: return (GET_CODE (tem) == MULT && ! had_mult) ? 0 : tem; ! 3588: } ! 3589: } ! 3590: 1.1.1.5 root 3591: /* If one of the operands is a PLUS or a MINUS, see if we can 3592: simplify this by the associative law. 3593: Don't use the associative law for floating point. 3594: The inaccuracy makes it nonassociative, 3595: and subtle programs can break if operations are associated. */ 1.1 root 3596: 1.1.1.6 root 3597: if (INTEGRAL_MODE_P (mode) 1.1.1.5 root 3598: && (GET_CODE (op0) == PLUS || GET_CODE (op0) == MINUS 3599: || GET_CODE (op1) == PLUS || GET_CODE (op1) == MINUS) 3600: && (tem = simplify_plus_minus (code, mode, op0, op1)) != 0) 3601: return tem; 1.1 root 3602: break; 3603: 3604: case COMPARE: 3605: #ifdef HAVE_cc0 3606: /* Convert (compare FOO (const_int 0)) to FOO unless we aren't 3607: using cc0, in which case we want to leave it as a COMPARE 3608: so we can distinguish it from a register-register-copy. 3609: 3610: In IEEE floating point, x-0 is not the same as x. */ 3611: 3612: if ((TARGET_FLOAT_FORMAT != IEEE_FLOAT_FORMAT 1.1.1.7 ! root 3613: || ! FLOAT_MODE_P (mode) || flag_fast_math) 1.1 root 3614: && op1 == CONST0_RTX (mode)) 3615: return op0; 3616: #else 3617: /* Do nothing here. */ 3618: #endif 3619: break; 3620: 3621: case MINUS: 1.1.1.3 root 3622: /* None of these optimizations can be done for IEEE 3623: floating point. */ 3624: if (TARGET_FLOAT_FORMAT == IEEE_FLOAT_FORMAT 1.1.1.7 ! root 3625: && FLOAT_MODE_P (mode) && ! flag_fast_math) 1.1.1.3 root 3626: break; 3627: 1.1.1.7 ! root 3628: /* We can't assume x-x is 0 even with non-IEEE floating point, ! 3629: but since it is zero except in very strange circumstances, we ! 3630: will treat it as zero with -ffast-math. */ 1.1 root 3631: if (rtx_equal_p (op0, op1) 3632: && ! side_effects_p (op0) 1.1.1.7 ! root 3633: && (! FLOAT_MODE_P (mode) || flag_fast_math)) ! 3634: return CONST0_RTX (mode); 1.1 root 3635: 3636: /* Change subtraction from zero into negation. */ 3637: if (op0 == CONST0_RTX (mode)) 3638: return gen_rtx (NEG, mode, op1); 3639: 1.1.1.5 root 3640: /* (-1 - a) is ~a. */ 3641: if (op0 == constm1_rtx) 3642: return gen_rtx (NOT, mode, op1); 3643: 1.1 root 3644: /* Subtracting 0 has no effect. */ 3645: if (op1 == CONST0_RTX (mode)) 3646: return op0; 3647: 1.1.1.7 ! root 3648: /* See if this is something like X * C - X or vice versa or ! 3649: if the multiplication is written as a shift. If so, we can ! 3650: distribute and make a new multiply, shift, or maybe just ! 3651: have X (if C is 2 in the example above). But don't make ! 3652: real multiply if we didn't have one before. */ ! 3653: ! 3654: if (! FLOAT_MODE_P (mode)) ! 3655: { ! 3656: HOST_WIDE_INT coeff0 = 1, coeff1 = 1; ! 3657: rtx lhs = op0, rhs = op1; ! 3658: int had_mult = 0; ! 3659: ! 3660: if (GET_CODE (lhs) == NEG) ! 3661: coeff0 = -1, lhs = XEXP (lhs, 0); ! 3662: else if (GET_CODE (lhs) == MULT ! 3663: && GET_CODE (XEXP (lhs, 1)) == CONST_INT) ! 3664: { ! 3665: coeff0 = INTVAL (XEXP (lhs, 1)), lhs = XEXP (lhs, 0); ! 3666: had_mult = 1; ! 3667: } ! 3668: else if (GET_CODE (lhs) == ASHIFT ! 3669: && GET_CODE (XEXP (lhs, 1)) == CONST_INT ! 3670: && INTVAL (XEXP (lhs, 1)) >= 0 ! 3671: && INTVAL (XEXP (lhs, 1)) < HOST_BITS_PER_WIDE_INT) ! 3672: { ! 3673: coeff0 = ((HOST_WIDE_INT) 1) << INTVAL (XEXP (lhs, 1)); ! 3674: lhs = XEXP (lhs, 0); ! 3675: } ! 3676: ! 3677: if (GET_CODE (rhs) == NEG) ! 3678: coeff1 = - 1, rhs = XEXP (rhs, 0); ! 3679: else if (GET_CODE (rhs) == MULT ! 3680: && GET_CODE (XEXP (rhs, 1)) == CONST_INT) ! 3681: { ! 3682: coeff1 = INTVAL (XEXP (rhs, 1)), rhs = XEXP (rhs, 0); ! 3683: had_mult = 1; ! 3684: } ! 3685: else if (GET_CODE (rhs) == ASHIFT ! 3686: && GET_CODE (XEXP (rhs, 1)) == CONST_INT ! 3687: && INTVAL (XEXP (rhs, 1)) >= 0 ! 3688: && INTVAL (XEXP (rhs, 1)) < HOST_BITS_PER_WIDE_INT) ! 3689: { ! 3690: coeff1 = ((HOST_WIDE_INT) 1) << INTVAL (XEXP (rhs, 1)); ! 3691: rhs = XEXP (rhs, 0); ! 3692: } ! 3693: ! 3694: if (rtx_equal_p (lhs, rhs)) ! 3695: { ! 3696: tem = cse_gen_binary (MULT, mode, lhs, ! 3697: GEN_INT (coeff0 - coeff1)); ! 3698: return (GET_CODE (tem) == MULT && ! had_mult) ? 0 : tem; ! 3699: } ! 3700: } ! 3701: 1.1 root 3702: /* (a - (-b)) -> (a + b). */ 3703: if (GET_CODE (op1) == NEG) 1.1.1.5 root 3704: return cse_gen_binary (PLUS, mode, op0, XEXP (op1, 0)); 1.1 root 3705: 1.1.1.5 root 3706: /* If one of the operands is a PLUS or a MINUS, see if we can 3707: simplify this by the associative law. 3708: Don't use the associative law for floating point. 1.1 root 3709: The inaccuracy makes it nonassociative, 3710: and subtle programs can break if operations are associated. */ 3711: 1.1.1.6 root 3712: if (INTEGRAL_MODE_P (mode) 1.1.1.5 root 3713: && (GET_CODE (op0) == PLUS || GET_CODE (op0) == MINUS 3714: || GET_CODE (op1) == PLUS || GET_CODE (op1) == MINUS) 3715: && (tem = simplify_plus_minus (code, mode, op0, op1)) != 0) 3716: return tem; 1.1 root 3717: 3718: /* Don't let a relocatable value get a negative coeff. */ 1.1.1.7 ! root 3719: if (GET_CODE (op1) == CONST_INT && GET_MODE (op0) != VOIDmode) 1.1 root 3720: return plus_constant (op0, - INTVAL (op1)); 3721: break; 3722: 3723: case MULT: 3724: if (op1 == constm1_rtx) 3725: { 1.1.1.5 root 3726: tem = simplify_unary_operation (NEG, mode, op0, mode); 1.1 root 3727: 3728: return tem ? tem : gen_rtx (NEG, mode, op0); 3729: } 3730: 3731: /* In IEEE floating point, x*0 is not always 0. */ 3732: if ((TARGET_FLOAT_FORMAT != IEEE_FLOAT_FORMAT 1.1.1.7 ! root 3733: || ! FLOAT_MODE_P (mode) || flag_fast_math) 1.1 root 3734: && op1 == CONST0_RTX (mode) 3735: && ! side_effects_p (op0)) 3736: return op1; 3737: 3738: /* In IEEE floating point, x*1 is not equivalent to x for nans. 3739: However, ANSI says we can drop signals, 3740: so we can do this anyway. */ 3741: if (op1 == CONST1_RTX (mode)) 3742: return op0; 3743: 1.1.1.7 ! root 3744: /* Convert multiply by constant power of two into shift unless ! 3745: we are still generating RTL. This test is a kludge. */ 1.1 root 3746: if (GET_CODE (op1) == CONST_INT 1.1.1.7 ! root 3747: && (val = exact_log2 (INTVAL (op1))) >= 0 ! 3748: && ! rtx_equal_function_value_matters) 1.1.1.4 root 3749: return gen_rtx (ASHIFT, mode, op0, GEN_INT (val)); 1.1 root 3750: 3751: if (GET_CODE (op1) == CONST_DOUBLE 3752: && GET_MODE_CLASS (GET_MODE (op1)) == MODE_FLOAT) 3753: { 3754: REAL_VALUE_TYPE d; 1.1.1.5 root 3755: jmp_buf handler; 3756: int op1is2, op1ism1; 3757: 3758: if (setjmp (handler)) 3759: return 0; 3760: 3761: set_float_handler (handler); 1.1 root 3762: REAL_VALUE_FROM_CONST_DOUBLE (d, op1); 1.1.1.5 root 3763: op1is2 = REAL_VALUES_EQUAL (d, dconst2); 3764: op1ism1 = REAL_VALUES_EQUAL (d, dconstm1); 3765: set_float_handler (NULL_PTR); 1.1 root 3766: 3767: /* x*2 is x+x and x*(-1) is -x */ 1.1.1.5 root 3768: if (op1is2 && GET_MODE (op0) == mode) 1.1 root 3769: return gen_rtx (PLUS, mode, op0, copy_rtx (op0)); 3770: 1.1.1.5 root 3771: else if (op1ism1 && GET_MODE (op0) == mode) 1.1 root 3772: return gen_rtx (NEG, mode, op0); 3773: } 3774: break; 3775: 3776: case IOR: 3777: if (op1 == const0_rtx) 3778: return op0; 3779: if (GET_CODE (op1) == CONST_INT 3780: && (INTVAL (op1) & GET_MODE_MASK (mode)) == GET_MODE_MASK (mode)) 3781: return op1; 3782: if (rtx_equal_p (op0, op1) && ! side_effects_p (op0)) 3783: return op0; 3784: /* A | (~A) -> -1 */ 3785: if (((GET_CODE (op0) == NOT && rtx_equal_p (XEXP (op0, 0), op1)) 3786: || (GET_CODE (op1) == NOT && rtx_equal_p (XEXP (op1, 0), op0))) 1.1.1.5 root 3787: && ! side_effects_p (op0) 3788: && GET_MODE_CLASS (mode) != MODE_CC) 1.1 root 3789: return constm1_rtx; 3790: break; 3791: 3792: case XOR: 3793: if (op1 == const0_rtx) 3794: return op0; 3795: if (GET_CODE (op1) == CONST_INT 3796: && (INTVAL (op1) & GET_MODE_MASK (mode)) == GET_MODE_MASK (mode)) 3797: return gen_rtx (NOT, mode, op0); 1.1.1.5 root 3798: if (op0 == op1 && ! side_effects_p (op0) 3799: && GET_MODE_CLASS (mode) != MODE_CC) 1.1 root 3800: return const0_rtx; 3801: break; 3802: 3803: case AND: 3804: if (op1 == const0_rtx && ! side_effects_p (op0)) 3805: return const0_rtx; 3806: if (GET_CODE (op1) == CONST_INT 3807: && (INTVAL (op1) & GET_MODE_MASK (mode)) == GET_MODE_MASK (mode)) 3808: return op0; 1.1.1.5 root 3809: if (op0 == op1 && ! side_effects_p (op0) 3810: && GET_MODE_CLASS (mode) != MODE_CC) 1.1 root 3811: return op0; 3812: /* A & (~A) -> 0 */ 3813: if (((GET_CODE (op0) == NOT && rtx_equal_p (XEXP (op0, 0), op1)) 3814: || (GET_CODE (op1) == NOT && rtx_equal_p (XEXP (op1, 0), op0))) 1.1.1.5 root 3815: && ! side_effects_p (op0) 3816: && GET_MODE_CLASS (mode) != MODE_CC) 1.1 root 3817: return const0_rtx; 3818: break; 3819: 3820: case UDIV: 3821: /* Convert divide by power of two into shift (divide by 1 handled 3822: below). */ 3823: if (GET_CODE (op1) == CONST_INT 3824: && (arg1 = exact_log2 (INTVAL (op1))) > 0) 1.1.1.4 root 3825: return gen_rtx (LSHIFTRT, mode, op0, GEN_INT (arg1)); 1.1 root 3826: 3827: /* ... fall through ... */ 3828: 3829: case DIV: 3830: if (op1 == CONST1_RTX (mode)) 3831: return op0; 1.1.1.4 root 3832: 3833: /* In IEEE floating point, 0/x is not always 0. */ 3834: if ((TARGET_FLOAT_FORMAT != IEEE_FLOAT_FORMAT 1.1.1.7 ! root 3835: || ! FLOAT_MODE_P (mode) || flag_fast_math) 1.1.1.4 root 3836: && op0 == CONST0_RTX (mode) 3837: && ! side_effects_p (op1)) 1.1 root 3838: return op0; 1.1.1.4 root 3839: 1.1 root 3840: #if ! defined (REAL_IS_NOT_DOUBLE) || defined (REAL_ARITHMETIC) 1.1.1.7 ! root 3841: /* Change division by a constant into multiplication. Only do ! 3842: this with -ffast-math until an expert says it is safe in ! 3843: general. */ 1.1 root 3844: else if (GET_CODE (op1) == CONST_DOUBLE 3845: && GET_MODE_CLASS (GET_MODE (op1)) == MODE_FLOAT 1.1.1.7 ! root 3846: && op1 != CONST0_RTX (mode) ! 3847: && flag_fast_math) 1.1 root 3848: { 3849: REAL_VALUE_TYPE d; 3850: REAL_VALUE_FROM_CONST_DOUBLE (d, op1); 1.1.1.7 ! root 3851: ! 3852: if (! REAL_VALUES_EQUAL (d, dconst0)) ! 3853: { 1.1 root 3854: #if defined (REAL_ARITHMETIC) 1.1.1.7 ! root 3855: REAL_ARITHMETIC (d, rtx_to_tree_code (DIV), dconst1, d); ! 3856: return gen_rtx (MULT, mode, op0, ! 3857: CONST_DOUBLE_FROM_REAL_VALUE (d, mode)); 1.1 root 3858: #else 1.1.1.7 ! root 3859: return gen_rtx (MULT, mode, op0, ! 3860: CONST_DOUBLE_FROM_REAL_VALUE (1./d, mode)); 1.1 root 3861: #endif 1.1.1.7 ! root 3862: } ! 3863: } 1.1 root 3864: #endif 3865: break; 3866: 3867: case UMOD: 3868: /* Handle modulus by power of two (mod with 1 handled below). */ 3869: if (GET_CODE (op1) == CONST_INT 3870: && exact_log2 (INTVAL (op1)) > 0) 1.1.1.4 root 3871: return gen_rtx (AND, mode, op0, GEN_INT (INTVAL (op1) - 1)); 1.1 root 3872: 3873: /* ... fall through ... */ 3874: 3875: case MOD: 3876: if ((op0 == const0_rtx || op1 == const1_rtx) 3877: && ! side_effects_p (op0) && ! side_effects_p (op1)) 3878: return const0_rtx; 3879: break; 3880: 3881: case ROTATERT: 3882: case ROTATE: 3883: /* Rotating ~0 always results in ~0. */ 1.1.1.4 root 3884: if (GET_CODE (op0) == CONST_INT && width <= HOST_BITS_PER_WIDE_INT 1.1 root 3885: && INTVAL (op0) == GET_MODE_MASK (mode) 3886: && ! side_effects_p (op1)) 3887: return op0; 3888: 3889: /* ... fall through ... */ 3890: 3891: case ASHIFT: 3892: case ASHIFTRT: 3893: case LSHIFTRT: 3894: if (op1 == const0_rtx) 3895: return op0; 3896: if (op0 == const0_rtx && ! side_effects_p (op1)) 3897: return op0; 3898: break; 3899: 3900: case SMIN: 1.1.1.4 root 3901: if (width <= HOST_BITS_PER_WIDE_INT && GET_CODE (op1) == CONST_INT 3902: && INTVAL (op1) == (HOST_WIDE_INT) 1 << (width -1) 1.1 root 3903: && ! side_effects_p (op0)) 3904: return op1; 3905: else if (rtx_equal_p (op0, op1) && ! side_effects_p (op0)) 3906: return op0; 3907: break; 3908: 3909: case SMAX: 1.1.1.4 root 3910: if (width <= HOST_BITS_PER_WIDE_INT && GET_CODE (op1) == CONST_INT 1.1.1.5 root 3911: && (INTVAL (op1) 3912: == (unsigned HOST_WIDE_INT) GET_MODE_MASK (mode) >> 1) 1.1 root 3913: && ! side_effects_p (op0)) 3914: return op1; 3915: else if (rtx_equal_p (op0, op1) && ! side_effects_p (op0)) 3916: return op0; 3917: break; 3918: 3919: case UMIN: 3920: if (op1 == const0_rtx && ! side_effects_p (op0)) 3921: return op1; 3922: else if (rtx_equal_p (op0, op1) && ! side_effects_p (op0)) 3923: return op0; 3924: break; 3925: 3926: case UMAX: 3927: if (op1 == constm1_rtx && ! side_effects_p (op0)) 3928: return op1; 3929: else if (rtx_equal_p (op0, op1) && ! side_effects_p (op0)) 3930: return op0; 3931: break; 3932: 3933: default: 3934: abort (); 3935: } 3936: 3937: return 0; 3938: } 3939: 3940: /* Get the integer argument values in two forms: 3941: zero-extended in ARG0, ARG1 and sign-extended in ARG0S, ARG1S. */ 3942: 3943: arg0 = INTVAL (op0); 3944: arg1 = INTVAL (op1); 3945: 1.1.1.4 root 3946: if (width < HOST_BITS_PER_WIDE_INT) 1.1 root 3947: { 1.1.1.4 root 3948: arg0 &= ((HOST_WIDE_INT) 1 << width) - 1; 3949: arg1 &= ((HOST_WIDE_INT) 1 << width) - 1; 1.1 root 3950: 3951: arg0s = arg0; 1.1.1.4 root 3952: if (arg0s & ((HOST_WIDE_INT) 1 << (width - 1))) 3953: arg0s |= ((HOST_WIDE_INT) (-1) << width); 1.1 root 3954: 3955: arg1s = arg1; 1.1.1.4 root 3956: if (arg1s & ((HOST_WIDE_INT) 1 << (width - 1))) 3957: arg1s |= ((HOST_WIDE_INT) (-1) << width); 1.1 root 3958: } 3959: else 3960: { 3961: arg0s = arg0; 3962: arg1s = arg1; 3963: } 3964: 3965: /* Compute the value of the arithmetic. */ 3966: 3967: switch (code) 3968: { 3969: case PLUS: 1.1.1.2 root 3970: val = arg0s + arg1s; 1.1 root 3971: break; 3972: 3973: case MINUS: 1.1.1.2 root 3974: val = arg0s - arg1s; 1.1 root 3975: break; 3976: 3977: case MULT: 3978: val = arg0s * arg1s; 3979: break; 3980: 3981: case DIV: 3982: if (arg1s == 0) 3983: return 0; 3984: val = arg0s / arg1s; 3985: break; 3986: 3987: case MOD: 3988: if (arg1s == 0) 3989: return 0; 3990: val = arg0s % arg1s; 3991: break; 3992: 3993: case UDIV: 3994: if (arg1 == 0) 3995: return 0; 1.1.1.4 root 3996: val = (unsigned HOST_WIDE_INT) arg0 / arg1; 1.1 root 3997: break; 3998: 3999: case UMOD: 4000: if (arg1 == 0) 4001: return 0; 1.1.1.4 root 4002: val = (unsigned HOST_WIDE_INT) arg0 % arg1; 1.1 root 4003: break; 4004: 4005: case AND: 4006: val = arg0 & arg1; 4007: break; 4008: 4009: case IOR: 4010: val = arg0 | arg1; 4011: break; 4012: 4013: case XOR: 4014: val = arg0 ^ arg1; 4015: break; 4016: 4017: case LSHIFTRT: 4018: /* If shift count is undefined, don't fold it; let the machine do 4019: what it wants. But truncate it if the machine will do that. */ 4020: if (arg1 < 0) 4021: return 0; 4022: 4023: #ifdef SHIFT_COUNT_TRUNCATED 1.1.1.6 root 4024: if (SHIFT_COUNT_TRUNCATED) 1.1.1.7 ! root 4025: arg1 %= width; 1.1 root 4026: #endif 4027: 1.1.1.4 root 4028: val = ((unsigned HOST_WIDE_INT) arg0) >> arg1; 1.1 root 4029: break; 4030: 4031: case ASHIFT: 4032: if (arg1 < 0) 4033: return 0; 4034: 4035: #ifdef SHIFT_COUNT_TRUNCATED 1.1.1.6 root 4036: if (SHIFT_COUNT_TRUNCATED) 1.1.1.7 ! root 4037: arg1 %= width; 1.1 root 4038: #endif 4039: 1.1.1.4 root 4040: val = ((unsigned HOST_WIDE_INT) arg0) << arg1; 1.1 root 4041: break; 4042: 4043: case ASHIFTRT: 4044: if (arg1 < 0) 4045: return 0; 4046: 4047: #ifdef SHIFT_COUNT_TRUNCATED 1.1.1.6 root 4048: if (SHIFT_COUNT_TRUNCATED) 1.1.1.7 ! root 4049: arg1 %= width; 1.1 root 4050: #endif 4051: 4052: val = arg0s >> arg1; 1.1.1.4 root 4053: 4054: /* Bootstrap compiler may not have sign extended the right shift. 4055: Manually extend the sign to insure bootstrap cc matches gcc. */ 4056: if (arg0s < 0 && arg1 > 0) 4057: val |= ((HOST_WIDE_INT) -1) << (HOST_BITS_PER_WIDE_INT - arg1); 4058: 1.1 root 4059: break; 4060: 4061: case ROTATERT: 4062: if (arg1 < 0) 4063: return 0; 4064: 4065: arg1 %= width; 1.1.1.4 root 4066: val = ((((unsigned HOST_WIDE_INT) arg0) << (width - arg1)) 4067: | (((unsigned HOST_WIDE_INT) arg0) >> arg1)); 1.1 root 4068: break; 4069: 4070: case ROTATE: 4071: if (arg1 < 0) 4072: return 0; 4073: 4074: arg1 %= width; 1.1.1.4 root 4075: val = ((((unsigned HOST_WIDE_INT) arg0) << arg1) 4076: | (((unsigned HOST_WIDE_INT) arg0) >> (width - arg1))); 1.1 root 4077: break; 4078: 4079: case COMPARE: 4080: /* Do nothing here. */ 4081: return 0; 4082: 1.1.1.3 root 4083: case SMIN: 4084: val = arg0s <= arg1s ? arg0s : arg1s; 4085: break; 4086: 4087: case UMIN: 1.1.1.4 root 4088: val = ((unsigned HOST_WIDE_INT) arg0 4089: <= (unsigned HOST_WIDE_INT) arg1 ? arg0 : arg1); 1.1.1.3 root 4090: break; 4091: 4092: case SMAX: 4093: val = arg0s > arg1s ? arg0s : arg1s; 4094: break; 4095: 4096: case UMAX: 1.1.1.4 root 4097: val = ((unsigned HOST_WIDE_INT) arg0 4098: > (unsigned HOST_WIDE_INT) arg1 ? arg0 : arg1); 1.1.1.3 root 4099: break; 4100: 1.1 root 4101: default: 4102: abort (); 4103: } 4104: 4105: /* Clear the bits that don't belong in our mode, unless they and our sign 4106: bit are all one. So we get either a reasonable negative value or a 4107: reasonable unsigned value for this mode. */ 1.1.1.4 root 4108: if (width < HOST_BITS_PER_WIDE_INT 4109: && ((val & ((HOST_WIDE_INT) (-1) << (width - 1))) 4110: != ((HOST_WIDE_INT) (-1) << (width - 1)))) 4111: val &= ((HOST_WIDE_INT) 1 << width) - 1; 4112: 4113: return GEN_INT (val); 1.1 root 4114: } 4115: 1.1.1.5 root 4116: /* Simplify a PLUS or MINUS, at least one of whose operands may be another 4117: PLUS or MINUS. 4118: 4119: Rather than test for specific case, we do this by a brute-force method 4120: and do all possible simplifications until no more changes occur. Then 4121: we rebuild the operation. */ 4122: 4123: static rtx 4124: simplify_plus_minus (code, mode, op0, op1) 4125: enum rtx_code code; 4126: enum machine_mode mode; 4127: rtx op0, op1; 4128: { 4129: rtx ops[8]; 4130: int negs[8]; 4131: rtx result, tem; 4132: int n_ops = 2, input_ops = 2, input_consts = 0, n_consts = 0; 4133: int first = 1, negate = 0, changed; 4134: int i, j; 4135: 1.1.1.7 ! root 4136: bzero ((char *) ops, sizeof ops); 1.1.1.5 root 4137: 4138: /* Set up the two operands and then expand them until nothing has been 4139: changed. If we run out of room in our array, give up; this should 4140: almost never happen. */ 4141: 4142: ops[0] = op0, ops[1] = op1, negs[0] = 0, negs[1] = (code == MINUS); 4143: 4144: changed = 1; 4145: while (changed) 4146: { 4147: changed = 0; 4148: 4149: for (i = 0; i < n_ops; i++) 4150: switch (GET_CODE (ops[i])) 4151: { 4152: case PLUS: 4153: case MINUS: 4154: if (n_ops == 7) 4155: return 0; 4156: 4157: ops[n_ops] = XEXP (ops[i], 1); 4158: negs[n_ops++] = GET_CODE (ops[i]) == MINUS ? !negs[i] : negs[i]; 4159: ops[i] = XEXP (ops[i], 0); 4160: input_ops++; 4161: changed = 1; 4162: break; 4163: 4164: case NEG: 4165: ops[i] = XEXP (ops[i], 0); 4166: negs[i] = ! negs[i]; 4167: changed = 1; 4168: break; 4169: 4170: case CONST: 4171: ops[i] = XEXP (ops[i], 0); 4172: input_consts++; 4173: changed = 1; 4174: break; 4175: 4176: case NOT: 4177: /* ~a -> (-a - 1) */ 4178: if (n_ops != 7) 4179: { 4180: ops[n_ops] = constm1_rtx; 4181: negs[n_ops++] = negs[i]; 4182: ops[i] = XEXP (ops[i], 0); 4183: negs[i] = ! negs[i]; 4184: changed = 1; 4185: } 4186: break; 4187: 4188: case CONST_INT: 4189: if (negs[i]) 4190: ops[i] = GEN_INT (- INTVAL (ops[i])), negs[i] = 0, changed = 1; 4191: break; 4192: } 4193: } 4194: 4195: /* If we only have two operands, we can't do anything. */ 4196: if (n_ops <= 2) 4197: return 0; 4198: 4199: /* Now simplify each pair of operands until nothing changes. The first 4200: time through just simplify constants against each other. */ 4201: 4202: changed = 1; 4203: while (changed) 4204: { 4205: changed = first; 4206: 4207: for (i = 0; i < n_ops - 1; i++) 4208: for (j = i + 1; j < n_ops; j++) 4209: if (ops[i] != 0 && ops[j] != 0 4210: && (! first || (CONSTANT_P (ops[i]) && CONSTANT_P (ops[j])))) 4211: { 4212: rtx lhs = ops[i], rhs = ops[j]; 4213: enum rtx_code ncode = PLUS; 4214: 4215: if (negs[i] && ! negs[j]) 4216: lhs = ops[j], rhs = ops[i], ncode = MINUS; 4217: else if (! negs[i] && negs[j]) 4218: ncode = MINUS; 4219: 4220: tem = simplify_binary_operation (ncode, mode, lhs, rhs); 4221: if (tem) 4222: { 4223: ops[i] = tem, ops[j] = 0; 4224: negs[i] = negs[i] && negs[j]; 4225: if (GET_CODE (tem) == NEG) 4226: ops[i] = XEXP (tem, 0), negs[i] = ! negs[i]; 4227: 4228: if (GET_CODE (ops[i]) == CONST_INT && negs[i]) 4229: ops[i] = GEN_INT (- INTVAL (ops[i])), negs[i] = 0; 4230: changed = 1; 4231: } 4232: } 4233: 4234: first = 0; 4235: } 4236: 4237: /* Pack all the operands to the lower-numbered entries and give up if 4238: we didn't reduce the number of operands we had. Make sure we 4239: count a CONST as two operands. If we have the same number of 4240: operands, but have made more CONSTs than we had, this is also 4241: an improvement, so accept it. */ 4242: 4243: for (i = 0, j = 0; j < n_ops; j++) 4244: if (ops[j] != 0) 4245: { 4246: ops[i] = ops[j], negs[i++] = negs[j]; 4247: if (GET_CODE (ops[j]) == CONST) 4248: n_consts++; 4249: } 4250: 4251: if (i + n_consts > input_ops 4252: || (i + n_consts == input_ops && n_consts <= input_consts)) 4253: return 0; 4254: 4255: n_ops = i; 4256: 4257: /* If we have a CONST_INT, put it last. */ 4258: for (i = 0; i < n_ops - 1; i++) 4259: if (GET_CODE (ops[i]) == CONST_INT) 4260: { 4261: tem = ops[n_ops - 1], ops[n_ops - 1] = ops[i] , ops[i] = tem; 4262: j = negs[n_ops - 1], negs[n_ops - 1] = negs[i], negs[i] = j; 4263: } 4264: 4265: /* Put a non-negated operand first. If there aren't any, make all 4266: operands positive and negate the whole thing later. */ 4267: for (i = 0; i < n_ops && negs[i]; i++) 4268: ; 4269: 4270: if (i == n_ops) 4271: { 4272: for (i = 0; i < n_ops; i++) 4273: negs[i] = 0; 4274: negate = 1; 4275: } 4276: else if (i != 0) 4277: { 4278: tem = ops[0], ops[0] = ops[i], ops[i] = tem; 4279: j = negs[0], negs[0] = negs[i], negs[i] = j; 4280: } 4281: 4282: /* Now make the result by performing the requested operations. */ 4283: result = ops[0]; 4284: for (i = 1; i < n_ops; i++) 4285: result = cse_gen_binary (negs[i] ? MINUS : PLUS, mode, result, ops[i]); 4286: 4287: return negate ? gen_rtx (NEG, mode, result) : result; 4288: } 4289: 4290: /* Make a binary operation by properly ordering the operands and 4291: seeing if the expression folds. */ 4292: 4293: static rtx 4294: cse_gen_binary (code, mode, op0, op1) 4295: enum rtx_code code; 4296: enum machine_mode mode; 4297: rtx op0, op1; 4298: { 4299: rtx tem; 4300: 4301: /* Put complex operands first and constants second if commutative. */ 4302: if (GET_RTX_CLASS (code) == 'c' 4303: && ((CONSTANT_P (op0) && GET_CODE (op1) != CONST_INT) 4304: || (GET_RTX_CLASS (GET_CODE (op0)) == 'o' 4305: && GET_RTX_CLASS (GET_CODE (op1)) != 'o') 4306: || (GET_CODE (op0) == SUBREG 4307: && GET_RTX_CLASS (GET_CODE (SUBREG_REG (op0))) == 'o' 4308: && GET_RTX_CLASS (GET_CODE (op1)) != 'o'))) 4309: tem = op0, op0 = op1, op1 = tem; 4310: 4311: /* If this simplifies, do it. */ 4312: tem = simplify_binary_operation (code, mode, op0, op1); 4313: 4314: if (tem) 4315: return tem; 4316: 4317: /* Handle addition and subtraction of CONST_INT specially. Otherwise, 4318: just form the operation. */ 4319: 4320: if (code == PLUS && GET_CODE (op1) == CONST_INT 4321: && GET_MODE (op0) != VOIDmode) 4322: return plus_constant (op0, INTVAL (op1)); 4323: else if (code == MINUS && GET_CODE (op1) == CONST_INT 4324: && GET_MODE (op0) != VOIDmode) 4325: return plus_constant (op0, - INTVAL (op1)); 4326: else 4327: return gen_rtx (code, mode, op0, op1); 4328: } 4329: 1.1 root 4330: /* Like simplify_binary_operation except used for relational operators. 1.1.1.7 ! root 4331: MODE is the mode of the operands, not that of the result. If MODE ! 4332: is VOIDmode, both operands must also be VOIDmode and we compare the ! 4333: operands in "infinite precision". ! 4334: ! 4335: If no simplification is possible, this function returns zero. Otherwise, ! 4336: it returns either const_true_rtx or const0_rtx. */ 1.1 root 4337: 4338: rtx 4339: simplify_relational_operation (code, mode, op0, op1) 4340: enum rtx_code code; 4341: enum machine_mode mode; 4342: rtx op0, op1; 4343: { 1.1.1.7 ! root 4344: int equal, op0lt, op0ltu, op1lt, op1ltu; ! 4345: rtx tem; 1.1 root 4346: 4347: /* If op0 is a compare, extract the comparison arguments from it. */ 4348: if (GET_CODE (op0) == COMPARE && op1 == const0_rtx) 4349: op1 = XEXP (op0, 1), op0 = XEXP (op0, 0); 4350: 1.1.1.7 ! root 4351: /* We can't simplify MODE_CC values since we don't know what the ! 4352: actual comparison is. */ ! 4353: if (GET_MODE_CLASS (GET_MODE (op0)) == MODE_CC ! 4354: #ifdef HAVE_cc0 ! 4355: || op0 == cc0_rtx ! 4356: #endif ! 4357: ) 1.1.1.5 root 4358: return 0; 4359: 1.1.1.7 ! root 4360: /* For integer comparisons of A and B maybe we can simplify A - B and can ! 4361: then simplify a comparison of that with zero. If A and B are both either ! 4362: a register or a CONST_INT, this can't help; testing for these cases will ! 4363: prevent infinite recursion here and speed things up. ! 4364: ! 4365: If CODE is an unsigned comparison, we can only do this if A - B is a ! 4366: constant integer, and then we have to compare that integer with zero as a ! 4367: signed comparison. Note that this will give the incorrect result from ! 4368: comparisons that overflow. Since these are undefined, this is probably ! 4369: OK. If it causes a problem, we can check for A or B being an address ! 4370: (fp + const or SYMBOL_REF) and only do it in that case. */ ! 4371: ! 4372: if (INTEGRAL_MODE_P (mode) && op1 != const0_rtx ! 4373: && ! ((GET_CODE (op0) == REG || GET_CODE (op0) == CONST_INT) ! 4374: && (GET_CODE (op1) == REG || GET_CODE (op1) == CONST_INT)) ! 4375: && 0 != (tem = simplify_binary_operation (MINUS, mode, op0, op1)) ! 4376: && (GET_CODE (tem) == CONST_INT ! 4377: || (code != GTU && code != GEU && ! 4378: code != LTU && code != LEU))) ! 4379: return simplify_relational_operation (signed_condition (code), ! 4380: mode, tem, const0_rtx); ! 4381: ! 4382: /* For non-IEEE floating-point, if the two operands are equal, we know the ! 4383: result. */ ! 4384: if (rtx_equal_p (op0, op1) ! 4385: && (TARGET_FLOAT_FORMAT != IEEE_FLOAT_FORMAT ! 4386: || ! FLOAT_MODE_P (GET_MODE (op0)) || flag_fast_math)) ! 4387: equal = 1, op0lt = 0, op0ltu = 0, op1lt = 0, op1ltu = 0; 1.1.1.5 root 4388: 1.1.1.7 ! root 4389: /* If the operands are floating-point constants, see if we can fold ! 4390: the result. */ ! 4391: #if ! defined (REAL_IS_NOT_DOUBLE) || defined (REAL_ARITHMETIC) ! 4392: else if (GET_CODE (op0) == CONST_DOUBLE && GET_CODE (op1) == CONST_DOUBLE ! 4393: && GET_MODE_CLASS (GET_MODE (op0)) == MODE_FLOAT) 1.1 root 4394: { 1.1.1.7 ! root 4395: REAL_VALUE_TYPE d0, d1; ! 4396: jmp_buf handler; ! 4397: ! 4398: if (setjmp (handler)) ! 4399: return 0; 1.1.1.5 root 4400: 1.1.1.7 ! root 4401: set_float_handler (handler); ! 4402: REAL_VALUE_FROM_CONST_DOUBLE (d0, op0); ! 4403: REAL_VALUE_FROM_CONST_DOUBLE (d1, op1); ! 4404: equal = REAL_VALUES_EQUAL (d0, d1); ! 4405: op0lt = op0ltu = REAL_VALUES_LESS (d0, d1); ! 4406: op1lt = op1ltu = REAL_VALUES_LESS (d1, d0); ! 4407: set_float_handler (NULL_PTR); ! 4408: } ! 4409: #endif /* not REAL_IS_NOT_DOUBLE, or REAL_ARITHMETIC */ 1.1 root 4410: 1.1.1.7 ! root 4411: /* Otherwise, see if the operands are both integers. */ ! 4412: else if ((GET_MODE_CLASS (mode) == MODE_INT || mode == VOIDmode) ! 4413: && (GET_CODE (op0) == CONST_DOUBLE || GET_CODE (op0) == CONST_INT) ! 4414: && (GET_CODE (op1) == CONST_DOUBLE || GET_CODE (op1) == CONST_INT)) ! 4415: { ! 4416: int width = GET_MODE_BITSIZE (mode); ! 4417: HOST_WIDE_INT l0s, h0s, l1s, h1s; ! 4418: unsigned HOST_WIDE_INT l0u, h0u, l1u, h1u; 1.1 root 4419: 1.1.1.7 ! root 4420: /* Get the two words comprising each integer constant. */ ! 4421: if (GET_CODE (op0) == CONST_DOUBLE) ! 4422: { ! 4423: l0u = l0s = CONST_DOUBLE_LOW (op0); ! 4424: h0u = h0s = CONST_DOUBLE_HIGH (op0); ! 4425: } ! 4426: else ! 4427: { ! 4428: l0u = l0s = INTVAL (op0); ! 4429: h0u = 0, h0s = l0s < 0 ? -1 : 0; ! 4430: } ! 4431: ! 4432: if (GET_CODE (op1) == CONST_DOUBLE) ! 4433: { ! 4434: l1u = l1s = CONST_DOUBLE_LOW (op1); ! 4435: h1u = h1s = CONST_DOUBLE_HIGH (op1); ! 4436: } ! 4437: else ! 4438: { ! 4439: l1u = l1s = INTVAL (op1); ! 4440: h1u = 0, h1s = l1s < 0 ? -1 : 0; 1.1 root 4441: } 1.1.1.5 root 4442: 1.1.1.7 ! root 4443: /* If WIDTH is nonzero and smaller than HOST_BITS_PER_WIDE_INT, ! 4444: we have to sign or zero-extend the values. */ ! 4445: if (width != 0 && width <= HOST_BITS_PER_WIDE_INT) ! 4446: h0u = h1u = 0, h0s = l0s < 0 ? -1 : 0, h1s = l1s < 0 ? -1 : 0; 1.1.1.5 root 4447: 1.1.1.7 ! root 4448: if (width != 0 && width < HOST_BITS_PER_WIDE_INT) ! 4449: { ! 4450: l0u &= ((HOST_WIDE_INT) 1 << width) - 1; ! 4451: l1u &= ((HOST_WIDE_INT) 1 << width) - 1; 1.1.1.5 root 4452: 1.1.1.7 ! root 4453: if (l0s & ((HOST_WIDE_INT) 1 << (width - 1))) ! 4454: l0s |= ((HOST_WIDE_INT) (-1) << width); 1.1.1.5 root 4455: 1.1.1.7 ! root 4456: if (l1s & ((HOST_WIDE_INT) 1 << (width - 1))) ! 4457: l1s |= ((HOST_WIDE_INT) (-1) << width); 1.1.1.5 root 4458: } 4459: 1.1.1.7 ! root 4460: equal = (h0u == h1u && l0u == l1u); ! 4461: op0lt = (h0s < h1s || (h0s == h1s && l0s < l1s)); ! 4462: op1lt = (h1s < h0s || (h1s == h0s && l1s < l0s)); ! 4463: op0ltu = (h0u < h1u || (h0u == h1u && l0u < l1u)); ! 4464: op1ltu = (h1u < h0u || (h1u == h0u && l1u < l0u)); ! 4465: } ! 4466: ! 4467: /* Otherwise, there are some code-specific tests we can make. */ ! 4468: else ! 4469: { 1.1 root 4470: switch (code) 4471: { 4472: case EQ: 1.1.1.7 ! root 4473: /* References to the frame plus a constant or labels cannot ! 4474: be zero, but a SYMBOL_REF can due to #pragma weak. */ ! 4475: if (((NONZERO_BASE_PLUS_P (op0) && op1 == const0_rtx) ! 4476: || GET_CODE (op0) == LABEL_REF) ! 4477: #if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM ! 4478: /* On some machines, the ap reg can be 0 sometimes. */ ! 4479: && op0 != arg_pointer_rtx ! 4480: #endif ! 4481: ) ! 4482: return const0_rtx; ! 4483: break; 1.1 root 4484: 4485: case NE: 1.1.1.7 ! root 4486: if (((NONZERO_BASE_PLUS_P (op0) && op1 == const0_rtx) ! 4487: || GET_CODE (op0) == LABEL_REF) ! 4488: #if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM ! 4489: && op0 != arg_pointer_rtx 1.1 root 4490: #endif 1.1.1.7 ! root 4491: ) 1.1 root 4492: return const_true_rtx; 4493: break; 4494: 4495: case GEU: 1.1.1.7 ! root 4496: /* Unsigned values are never negative. */ ! 4497: if (op1 == const0_rtx) 1.1 root 4498: return const_true_rtx; 4499: break; 4500: 4501: case LTU: 1.1.1.7 ! root 4502: if (op1 == const0_rtx) 1.1 root 4503: return const0_rtx; 4504: break; 4505: 4506: case LEU: 4507: /* Unsigned values are never greater than the largest 4508: unsigned value. */ 4509: if (GET_CODE (op1) == CONST_INT 4510: && INTVAL (op1) == GET_MODE_MASK (mode) 1.1.1.7 ! root 4511: && INTEGRAL_MODE_P (mode)) ! 4512: return const_true_rtx; 1.1 root 4513: break; 4514: 4515: case GTU: 4516: if (GET_CODE (op1) == CONST_INT 4517: && INTVAL (op1) == GET_MODE_MASK (mode) 1.1.1.6 root 4518: && INTEGRAL_MODE_P (mode)) 1.1 root 4519: return const0_rtx; 4520: break; 4521: } 4522: 4523: return 0; 4524: } 4525: 1.1.1.7 ! root 4526: /* If we reach here, EQUAL, OP0LT, OP0LTU, OP1LT, and OP1LTU are set ! 4527: as appropriate. */ 1.1 root 4528: switch (code) 4529: { 4530: case EQ: 1.1.1.7 ! root 4531: return equal ? const_true_rtx : const0_rtx; ! 4532: case NE: ! 4533: return ! equal ? const_true_rtx : const0_rtx; 1.1 root 4534: case LT: 1.1.1.7 ! root 4535: return op0lt ? const_true_rtx : const0_rtx; 1.1 root 4536: case GT: 1.1.1.7 ! root 4537: return op1lt ? const_true_rtx : const0_rtx; 1.1 root 4538: case LTU: 1.1.1.7 ! root 4539: return op0ltu ? const_true_rtx : const0_rtx; 1.1 root 4540: case GTU: 1.1.1.7 ! root 4541: return op1ltu ? const_true_rtx : const0_rtx; ! 4542: case LE: ! 4543: return equal || op0lt ? const_true_rtx : const0_rtx; ! 4544: case GE: ! 4545: return equal || op1lt ? const_true_rtx : const0_rtx; ! 4546: case LEU: ! 4547: return equal || op0ltu ? const_true_rtx : const0_rtx; ! 4548: case GEU: ! 4549: return equal || op1ltu ? const_true_rtx : const0_rtx; 1.1 root 4550: } 4551: 1.1.1.7 ! root 4552: abort (); 1.1 root 4553: } 4554: 4555: /* Simplify CODE, an operation with result mode MODE and three operands, 4556: OP0, OP1, and OP2. OP0_MODE was the mode of OP0 before it became 4557: a constant. Return 0 if no simplifications is possible. */ 4558: 4559: rtx 4560: simplify_ternary_operation (code, mode, op0_mode, op0, op1, op2) 4561: enum rtx_code code; 4562: enum machine_mode mode, op0_mode; 4563: rtx op0, op1, op2; 4564: { 4565: int width = GET_MODE_BITSIZE (mode); 4566: 4567: /* VOIDmode means "infinite" precision. */ 4568: if (width == 0) 1.1.1.4 root 4569: width = HOST_BITS_PER_WIDE_INT; 1.1 root 4570: 4571: switch (code) 4572: { 4573: case SIGN_EXTRACT: 4574: case ZERO_EXTRACT: 4575: if (GET_CODE (op0) == CONST_INT 4576: && GET_CODE (op1) == CONST_INT 4577: && GET_CODE (op2) == CONST_INT 4578: && INTVAL (op1) + INTVAL (op2) <= GET_MODE_BITSIZE (op0_mode) 1.1.1.4 root 4579: && width <= HOST_BITS_PER_WIDE_INT) 1.1 root 4580: { 4581: /* Extracting a bit-field from a constant */ 1.1.1.4 root 4582: HOST_WIDE_INT val = INTVAL (op0); 1.1 root 4583: 4584: #if BITS_BIG_ENDIAN 4585: val >>= (GET_MODE_BITSIZE (op0_mode) - INTVAL (op2) - INTVAL (op1)); 4586: #else 4587: val >>= INTVAL (op2); 4588: #endif 1.1.1.4 root 4589: if (HOST_BITS_PER_WIDE_INT != INTVAL (op1)) 1.1 root 4590: { 4591: /* First zero-extend. */ 1.1.1.4 root 4592: val &= ((HOST_WIDE_INT) 1 << INTVAL (op1)) - 1; 1.1 root 4593: /* If desired, propagate sign bit. */ 1.1.1.4 root 4594: if (code == SIGN_EXTRACT 4595: && (val & ((HOST_WIDE_INT) 1 << (INTVAL (op1) - 1)))) 4596: val |= ~ (((HOST_WIDE_INT) 1 << INTVAL (op1)) - 1); 1.1 root 4597: } 4598: 4599: /* Clear the bits that don't belong in our mode, 4600: unless they and our sign bit are all one. 4601: So we get either a reasonable negative value or a reasonable 4602: unsigned value for this mode. */ 1.1.1.4 root 4603: if (width < HOST_BITS_PER_WIDE_INT 4604: && ((val & ((HOST_WIDE_INT) (-1) << (width - 1))) 4605: != ((HOST_WIDE_INT) (-1) << (width - 1)))) 4606: val &= ((HOST_WIDE_INT) 1 << width) - 1; 1.1 root 4607: 1.1.1.4 root 4608: return GEN_INT (val); 1.1 root 4609: } 4610: break; 4611: 4612: case IF_THEN_ELSE: 4613: if (GET_CODE (op0) == CONST_INT) 4614: return op0 != const0_rtx ? op1 : op2; 4615: break; 4616: 4617: default: 4618: abort (); 4619: } 4620: 4621: return 0; 4622: } 4623: 4624: /* If X is a nontrivial arithmetic operation on an argument 4625: for which a constant value can be determined, return 4626: the result of operating on that value, as a constant. 4627: Otherwise, return X, possibly with one or more operands 4628: modified by recursive calls to this function. 4629: 4630: If X is a register whose contents are known, we do NOT 1.1.1.5 root 4631: return those contents here. equiv_constant is called to 4632: perform that task. 1.1 root 4633: 4634: INSN is the insn that we may be modifying. If it is 0, make a copy 4635: of X before modifying it. */ 4636: 4637: static rtx 4638: fold_rtx (x, insn) 4639: rtx x; 4640: rtx insn; 4641: { 4642: register enum rtx_code code; 4643: register enum machine_mode mode; 4644: register char *fmt; 1.1.1.4 root 4645: register int i; 1.1 root 4646: rtx new = 0; 4647: int copied = 0; 4648: int must_swap = 0; 4649: 4650: /* Folded equivalents of first two operands of X. */ 4651: rtx folded_arg0; 4652: rtx folded_arg1; 4653: 4654: /* Constant equivalents of first three operands of X; 4655: 0 when no such equivalent is known. */ 4656: rtx const_arg0; 4657: rtx const_arg1; 4658: rtx const_arg2; 4659: 4660: /* The mode of the first operand of X. We need this for sign and zero 4661: extends. */ 4662: enum machine_mode mode_arg0; 4663: 4664: if (x == 0) 4665: return x; 4666: 4667: mode = GET_MODE (x); 4668: code = GET_CODE (x); 4669: switch (code) 4670: { 4671: case CONST: 4672: case CONST_INT: 4673: case CONST_DOUBLE: 4674: case SYMBOL_REF: 4675: case LABEL_REF: 4676: case REG: 4677: /* No use simplifying an EXPR_LIST 4678: since they are used only for lists of args 4679: in a function call's REG_EQUAL note. */ 4680: case EXPR_LIST: 4681: return x; 4682: 4683: #ifdef HAVE_cc0 4684: case CC0: 4685: return prev_insn_cc0; 4686: #endif 4687: 4688: case PC: 4689: /* If the next insn is a CODE_LABEL followed by a jump table, 4690: PC's value is a LABEL_REF pointing to that label. That 4691: lets us fold switch statements on the Vax. */ 4692: if (insn && GET_CODE (insn) == JUMP_INSN) 4693: { 4694: rtx next = next_nonnote_insn (insn); 4695: 4696: if (next && GET_CODE (next) == CODE_LABEL 4697: && NEXT_INSN (next) != 0 4698: && GET_CODE (NEXT_INSN (next)) == JUMP_INSN 4699: && (GET_CODE (PATTERN (NEXT_INSN (next))) == ADDR_VEC 4700: || GET_CODE (PATTERN (NEXT_INSN (next))) == ADDR_DIFF_VEC)) 4701: return gen_rtx (LABEL_REF, Pmode, next); 4702: } 4703: break; 4704: 4705: case SUBREG: 1.1.1.4 root 4706: /* See if we previously assigned a constant value to this SUBREG. */ 4707: if ((new = lookup_as_function (x, CONST_INT)) != 0 4708: || (new = lookup_as_function (x, CONST_DOUBLE)) != 0) 1.1 root 4709: return new; 4710: 1.1.1.4 root 4711: /* If this is a paradoxical SUBREG, we have no idea what value the 4712: extra bits would have. However, if the operand is equivalent 4713: to a SUBREG whose operand is the same as our mode, and all the 4714: modes are within a word, we can just use the inner operand 1.1.1.6 root 4715: because these SUBREGs just say how to treat the register. 4716: 4717: Similarly if we find an integer constant. */ 1.1.1.4 root 4718: 1.1.1.3 root 4719: if (GET_MODE_SIZE (mode) > GET_MODE_SIZE (GET_MODE (SUBREG_REG (x)))) 1.1.1.4 root 4720: { 4721: enum machine_mode imode = GET_MODE (SUBREG_REG (x)); 4722: struct table_elt *elt; 4723: 4724: if (GET_MODE_SIZE (mode) <= UNITS_PER_WORD 4725: && GET_MODE_SIZE (imode) <= UNITS_PER_WORD 4726: && (elt = lookup (SUBREG_REG (x), HASH (SUBREG_REG (x), imode), 4727: imode)) != 0) 1.1.1.6 root 4728: for (elt = elt->first_same_value; 4729: elt; elt = elt->next_same_value) 4730: { 4731: if (CONSTANT_P (elt->exp) 4732: && GET_MODE (elt->exp) == VOIDmode) 4733: return elt->exp; 4734: 1.1.1.4 root 4735: if (GET_CODE (elt->exp) == SUBREG 4736: && GET_MODE (SUBREG_REG (elt->exp)) == mode 4737: && exp_equiv_p (elt->exp, elt->exp, 1, 0)) 4738: return copy_rtx (SUBREG_REG (elt->exp)); 4739: } 4740: 4741: return x; 4742: } 1.1.1.3 root 4743: 1.1 root 4744: /* Fold SUBREG_REG. If it changed, see if we can simplify the SUBREG. 4745: We might be able to if the SUBREG is extracting a single word in an 4746: integral mode or extracting the low part. */ 4747: 4748: folded_arg0 = fold_rtx (SUBREG_REG (x), insn); 4749: const_arg0 = equiv_constant (folded_arg0); 4750: if (const_arg0) 4751: folded_arg0 = const_arg0; 4752: 4753: if (folded_arg0 != SUBREG_REG (x)) 4754: { 4755: new = 0; 4756: 4757: if (GET_MODE_CLASS (mode) == MODE_INT 4758: && GET_MODE_SIZE (mode) == UNITS_PER_WORD 4759: && GET_MODE (SUBREG_REG (x)) != VOIDmode) 4760: new = operand_subword (folded_arg0, SUBREG_WORD (x), 0, 4761: GET_MODE (SUBREG_REG (x))); 4762: if (new == 0 && subreg_lowpart_p (x)) 4763: new = gen_lowpart_if_possible (mode, folded_arg0); 4764: if (new) 4765: return new; 4766: } 1.1.1.3 root 4767: 4768: /* If this is a narrowing SUBREG and our operand is a REG, see if 1.1.1.4 root 4769: we can find an equivalence for REG that is an arithmetic operation 1.1.1.3 root 4770: in a wider mode where both operands are paradoxical SUBREGs 4771: from objects of our result mode. In that case, we couldn't report 4772: an equivalent value for that operation, since we don't know what the 4773: extra bits will be. But we can find an equivalence for this SUBREG 4774: by folding that operation is the narrow mode. This allows us to 4775: fold arithmetic in narrow modes when the machine only supports 1.1.1.4 root 4776: word-sized arithmetic. 4777: 4778: Also look for a case where we have a SUBREG whose operand is the 4779: same as our result. If both modes are smaller than a word, we 4780: are simply interpreting a register in different modes and we 4781: can use the inner value. */ 1.1.1.3 root 4782: 4783: if (GET_CODE (folded_arg0) == REG 1.1.1.4 root 4784: && GET_MODE_SIZE (mode) < GET_MODE_SIZE (GET_MODE (folded_arg0)) 4785: && subreg_lowpart_p (x)) 1.1.1.3 root 4786: { 4787: struct table_elt *elt; 4788: 4789: /* We can use HASH here since we know that canon_hash won't be 4790: called. */ 4791: elt = lookup (folded_arg0, 4792: HASH (folded_arg0, GET_MODE (folded_arg0)), 4793: GET_MODE (folded_arg0)); 4794: 4795: if (elt) 4796: elt = elt->first_same_value; 4797: 4798: for (; elt; elt = elt->next_same_value) 4799: { 1.1.1.4 root 4800: enum rtx_code eltcode = GET_CODE (elt->exp); 4801: 1.1.1.3 root 4802: /* Just check for unary and binary operations. */ 4803: if (GET_RTX_CLASS (GET_CODE (elt->exp)) == '1' 4804: && GET_CODE (elt->exp) != SIGN_EXTEND 4805: && GET_CODE (elt->exp) != ZERO_EXTEND 4806: && GET_CODE (XEXP (elt->exp, 0)) == SUBREG 4807: && GET_MODE (SUBREG_REG (XEXP (elt->exp, 0))) == mode) 4808: { 4809: rtx op0 = SUBREG_REG (XEXP (elt->exp, 0)); 4810: 4811: if (GET_CODE (op0) != REG && ! CONSTANT_P (op0)) 1.1.1.4 root 4812: op0 = fold_rtx (op0, NULL_RTX); 1.1.1.3 root 4813: 4814: op0 = equiv_constant (op0); 4815: if (op0) 4816: new = simplify_unary_operation (GET_CODE (elt->exp), mode, 4817: op0, mode); 4818: } 4819: else if ((GET_RTX_CLASS (GET_CODE (elt->exp)) == '2' 4820: || GET_RTX_CLASS (GET_CODE (elt->exp)) == 'c') 1.1.1.4 root 4821: && eltcode != DIV && eltcode != MOD 4822: && eltcode != UDIV && eltcode != UMOD 4823: && eltcode != ASHIFTRT && eltcode != LSHIFTRT 4824: && eltcode != ROTATE && eltcode != ROTATERT 1.1.1.3 root 4825: && ((GET_CODE (XEXP (elt->exp, 0)) == SUBREG 4826: && (GET_MODE (SUBREG_REG (XEXP (elt->exp, 0))) 4827: == mode)) 4828: || CONSTANT_P (XEXP (elt->exp, 0))) 4829: && ((GET_CODE (XEXP (elt->exp, 1)) == SUBREG 4830: && (GET_MODE (SUBREG_REG (XEXP (elt->exp, 1))) 4831: == mode)) 4832: || CONSTANT_P (XEXP (elt->exp, 1)))) 4833: { 4834: rtx op0 = gen_lowpart_common (mode, XEXP (elt->exp, 0)); 4835: rtx op1 = gen_lowpart_common (mode, XEXP (elt->exp, 1)); 4836: 4837: if (op0 && GET_CODE (op0) != REG && ! CONSTANT_P (op0)) 1.1.1.4 root 4838: op0 = fold_rtx (op0, NULL_RTX); 1.1.1.3 root 4839: 4840: if (op0) 4841: op0 = equiv_constant (op0); 4842: 4843: if (op1 && GET_CODE (op1) != REG && ! CONSTANT_P (op1)) 1.1.1.4 root 4844: op1 = fold_rtx (op1, NULL_RTX); 1.1.1.3 root 4845: 4846: if (op1) 4847: op1 = equiv_constant (op1); 4848: 1.1.1.6 root 4849: /* If we are looking for the low SImode part of 4850: (ashift:DI c (const_int 32)), it doesn't work 4851: to compute that in SImode, because a 32-bit shift 4852: in SImode is unpredictable. We know the value is 0. */ 4853: if (op0 && op1 1.1.1.7 ! root 4854: && GET_CODE (elt->exp) == ASHIFT 1.1.1.6 root 4855: && GET_CODE (op1) == CONST_INT 4856: && INTVAL (op1) >= GET_MODE_BITSIZE (mode)) 4857: { 4858: if (INTVAL (op1) < GET_MODE_BITSIZE (GET_MODE (elt->exp))) 4859: 4860: /* If the count fits in the inner mode's width, 4861: but exceeds the outer mode's width, 4862: the value will get truncated to 0 4863: by the subreg. */ 4864: new = const0_rtx; 4865: else 4866: /* If the count exceeds even the inner mode's width, 4867: don't fold this expression. */ 4868: new = 0; 4869: } 4870: else if (op0 && op1) 1.1.1.3 root 4871: new = simplify_binary_operation (GET_CODE (elt->exp), mode, 4872: op0, op1); 4873: } 4874: 1.1.1.4 root 4875: else if (GET_CODE (elt->exp) == SUBREG 4876: && GET_MODE (SUBREG_REG (elt->exp)) == mode 4877: && (GET_MODE_SIZE (GET_MODE (folded_arg0)) 4878: <= UNITS_PER_WORD) 4879: && exp_equiv_p (elt->exp, elt->exp, 1, 0)) 4880: new = copy_rtx (SUBREG_REG (elt->exp)); 4881: 1.1.1.3 root 4882: if (new) 4883: return new; 4884: } 4885: } 4886: 1.1 root 4887: return x; 4888: 4889: case NOT: 4890: case NEG: 4891: /* If we have (NOT Y), see if Y is known to be (NOT Z). 4892: If so, (NOT Y) simplifies to Z. Similarly for NEG. */ 4893: new = lookup_as_function (XEXP (x, 0), code); 4894: if (new) 4895: return fold_rtx (copy_rtx (XEXP (new, 0)), insn); 4896: break; 1.1.1.4 root 4897: 1.1 root 4898: case MEM: 4899: /* If we are not actually processing an insn, don't try to find the 4900: best address. Not only don't we care, but we could modify the 4901: MEM in an invalid way since we have no insn to validate against. */ 4902: if (insn != 0) 4903: find_best_addr (insn, &XEXP (x, 0)); 4904: 4905: { 4906: /* Even if we don't fold in the insn itself, 4907: we can safely do so here, in hopes of getting a constant. */ 1.1.1.4 root 4908: rtx addr = fold_rtx (XEXP (x, 0), NULL_RTX); 1.1 root 4909: rtx base = 0; 1.1.1.4 root 4910: HOST_WIDE_INT offset = 0; 1.1 root 4911: 4912: if (GET_CODE (addr) == REG 4913: && REGNO_QTY_VALID_P (REGNO (addr)) 4914: && GET_MODE (addr) == qty_mode[reg_qty[REGNO (addr)]] 4915: && qty_const[reg_qty[REGNO (addr)]] != 0) 4916: addr = qty_const[reg_qty[REGNO (addr)]]; 4917: 4918: /* If address is constant, split it into a base and integer offset. */ 4919: if (GET_CODE (addr) == SYMBOL_REF || GET_CODE (addr) == LABEL_REF) 4920: base = addr; 4921: else if (GET_CODE (addr) == CONST && GET_CODE (XEXP (addr, 0)) == PLUS 4922: && GET_CODE (XEXP (XEXP (addr, 0), 1)) == CONST_INT) 4923: { 4924: base = XEXP (XEXP (addr, 0), 0); 4925: offset = INTVAL (XEXP (XEXP (addr, 0), 1)); 4926: } 4927: else if (GET_CODE (addr) == LO_SUM 4928: && GET_CODE (XEXP (addr, 1)) == SYMBOL_REF) 4929: base = XEXP (addr, 1); 4930: 4931: /* If this is a constant pool reference, we can fold it into its 4932: constant to allow better value tracking. */ 4933: if (base && GET_CODE (base) == SYMBOL_REF 4934: && CONSTANT_POOL_ADDRESS_P (base)) 4935: { 4936: rtx constant = get_pool_constant (base); 4937: enum machine_mode const_mode = get_pool_mode (base); 4938: rtx new; 4939: 4940: if (CONSTANT_P (constant) && GET_CODE (constant) != CONST_INT) 4941: constant_pool_entries_cost = COST (constant); 4942: 4943: /* If we are loading the full constant, we have an equivalence. */ 4944: if (offset == 0 && mode == const_mode) 4945: return constant; 4946: 4947: /* If this actually isn't a constant (wierd!), we can't do 4948: anything. Otherwise, handle the two most common cases: 4949: extracting a word from a multi-word constant, and extracting 4950: the low-order bits. Other cases don't seem common enough to 4951: worry about. */ 4952: if (! CONSTANT_P (constant)) 4953: return x; 4954: 4955: if (GET_MODE_CLASS (mode) == MODE_INT 4956: && GET_MODE_SIZE (mode) == UNITS_PER_WORD 4957: && offset % UNITS_PER_WORD == 0 4958: && (new = operand_subword (constant, 4959: offset / UNITS_PER_WORD, 4960: 0, const_mode)) != 0) 4961: return new; 4962: 4963: if (((BYTES_BIG_ENDIAN 4964: && offset == GET_MODE_SIZE (GET_MODE (constant)) - 1) 4965: || (! BYTES_BIG_ENDIAN && offset == 0)) 4966: && (new = gen_lowpart_if_possible (mode, constant)) != 0) 4967: return new; 4968: } 4969: 4970: /* If this is a reference to a label at a known position in a jump 4971: table, we also know its value. */ 4972: if (base && GET_CODE (base) == LABEL_REF) 4973: { 4974: rtx label = XEXP (base, 0); 4975: rtx table_insn = NEXT_INSN (label); 4976: 4977: if (table_insn && GET_CODE (table_insn) == JUMP_INSN 4978: && GET_CODE (PATTERN (table_insn)) == ADDR_VEC) 4979: { 4980: rtx table = PATTERN (table_insn); 4981: 4982: if (offset >= 0 4983: && (offset / GET_MODE_SIZE (GET_MODE (table)) 4984: < XVECLEN (table, 0))) 4985: return XVECEXP (table, 0, 4986: offset / GET_MODE_SIZE (GET_MODE (table))); 4987: } 4988: if (table_insn && GET_CODE (table_insn) == JUMP_INSN 4989: && GET_CODE (PATTERN (table_insn)) == ADDR_DIFF_VEC) 4990: { 4991: rtx table = PATTERN (table_insn); 4992: 4993: if (offset >= 0 4994: && (offset / GET_MODE_SIZE (GET_MODE (table)) 4995: < XVECLEN (table, 1))) 4996: { 4997: offset /= GET_MODE_SIZE (GET_MODE (table)); 4998: new = gen_rtx (MINUS, Pmode, XVECEXP (table, 1, offset), 4999: XEXP (table, 0)); 5000: 5001: if (GET_MODE (table) != Pmode) 5002: new = gen_rtx (TRUNCATE, GET_MODE (table), new); 5003: 1.1.1.7 ! root 5004: /* Indicate this is a constant. This isn't a ! 5005: valid form of CONST, but it will only be used ! 5006: to fold the next insns and then discarded, so ! 5007: it should be safe. */ ! 5008: return gen_rtx (CONST, GET_MODE (new), new); 1.1 root 5009: } 5010: } 5011: } 5012: 5013: return x; 5014: } 5015: } 5016: 5017: const_arg0 = 0; 5018: const_arg1 = 0; 5019: const_arg2 = 0; 5020: mode_arg0 = VOIDmode; 5021: 5022: /* Try folding our operands. 5023: Then see which ones have constant values known. */ 5024: 5025: fmt = GET_RTX_FORMAT (code); 5026: for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--) 5027: if (fmt[i] == 'e') 5028: { 5029: rtx arg = XEXP (x, i); 5030: rtx folded_arg = arg, const_arg = 0; 5031: enum machine_mode mode_arg = GET_MODE (arg); 5032: rtx cheap_arg, expensive_arg; 5033: rtx replacements[2]; 5034: int j; 5035: 5036: /* Most arguments are cheap, so handle them specially. */ 5037: switch (GET_CODE (arg)) 5038: { 5039: case REG: 5040: /* This is the same as calling equiv_constant; it is duplicated 5041: here for speed. */ 5042: if (REGNO_QTY_VALID_P (REGNO (arg)) 5043: && qty_const[reg_qty[REGNO (arg)]] != 0 5044: && GET_CODE (qty_const[reg_qty[REGNO (arg)]]) != REG 5045: && GET_CODE (qty_const[reg_qty[REGNO (arg)]]) != PLUS) 5046: const_arg 5047: = gen_lowpart_if_possible (GET_MODE (arg), 5048: qty_const[reg_qty[REGNO (arg)]]); 5049: break; 5050: 5051: case CONST: 5052: case CONST_INT: 5053: case SYMBOL_REF: 5054: case LABEL_REF: 5055: case CONST_DOUBLE: 5056: const_arg = arg; 5057: break; 5058: 5059: #ifdef HAVE_cc0 5060: case CC0: 5061: folded_arg = prev_insn_cc0; 5062: mode_arg = prev_insn_cc0_mode; 5063: const_arg = equiv_constant (folded_arg); 5064: break; 5065: #endif 5066: 5067: default: 5068: folded_arg = fold_rtx (arg, insn); 5069: const_arg = equiv_constant (folded_arg); 5070: } 5071: 5072: /* For the first three operands, see if the operand 5073: is constant or equivalent to a constant. */ 5074: switch (i) 5075: { 5076: case 0: 5077: folded_arg0 = folded_arg; 5078: const_arg0 = const_arg; 5079: mode_arg0 = mode_arg; 5080: break; 5081: case 1: 5082: folded_arg1 = folded_arg; 5083: const_arg1 = const_arg; 5084: break; 5085: case 2: 5086: const_arg2 = const_arg; 5087: break; 5088: } 5089: 5090: /* Pick the least expensive of the folded argument and an 5091: equivalent constant argument. */ 5092: if (const_arg == 0 || const_arg == folded_arg 5093: || COST (const_arg) > COST (folded_arg)) 5094: cheap_arg = folded_arg, expensive_arg = const_arg; 5095: else 5096: cheap_arg = const_arg, expensive_arg = folded_arg; 5097: 5098: /* Try to replace the operand with the cheapest of the two 5099: possibilities. If it doesn't work and this is either of the first 5100: two operands of a commutative operation, try swapping them. 5101: If THAT fails, try the more expensive, provided it is cheaper 5102: than what is already there. */ 5103: 5104: if (cheap_arg == XEXP (x, i)) 5105: continue; 5106: 5107: if (insn == 0 && ! copied) 5108: { 5109: x = copy_rtx (x); 5110: copied = 1; 5111: } 5112: 5113: replacements[0] = cheap_arg, replacements[1] = expensive_arg; 5114: for (j = 0; 5115: j < 2 && replacements[j] 5116: && COST (replacements[j]) < COST (XEXP (x, i)); 5117: j++) 5118: { 5119: if (validate_change (insn, &XEXP (x, i), replacements[j], 0)) 5120: break; 5121: 5122: if (code == NE || code == EQ || GET_RTX_CLASS (code) == 'c') 5123: { 5124: validate_change (insn, &XEXP (x, i), XEXP (x, 1 - i), 1); 5125: validate_change (insn, &XEXP (x, 1 - i), replacements[j], 1); 5126: 5127: if (apply_change_group ()) 5128: { 5129: /* Swap them back to be invalid so that this loop can 5130: continue and flag them to be swapped back later. */ 5131: rtx tem; 5132: 5133: tem = XEXP (x, 0); XEXP (x, 0) = XEXP (x, 1); 5134: XEXP (x, 1) = tem; 5135: must_swap = 1; 5136: break; 5137: } 5138: } 5139: } 5140: } 5141: 5142: else if (fmt[i] == 'E') 5143: /* Don't try to fold inside of a vector of expressions. 5144: Doing nothing is harmless. */ 5145: ; 5146: 5147: /* If a commutative operation, place a constant integer as the second 5148: operand unless the first operand is also a constant integer. Otherwise, 5149: place any constant second unless the first operand is also a constant. */ 5150: 5151: if (code == EQ || code == NE || GET_RTX_CLASS (code) == 'c') 5152: { 5153: if (must_swap || (const_arg0 5154: && (const_arg1 == 0 5155: || (GET_CODE (const_arg0) == CONST_INT 5156: && GET_CODE (const_arg1) != CONST_INT)))) 5157: { 5158: register rtx tem = XEXP (x, 0); 5159: 5160: if (insn == 0 && ! copied) 5161: { 5162: x = copy_rtx (x); 5163: copied = 1; 5164: } 5165: 5166: validate_change (insn, &XEXP (x, 0), XEXP (x, 1), 1); 5167: validate_change (insn, &XEXP (x, 1), tem, 1); 5168: if (apply_change_group ()) 5169: { 5170: tem = const_arg0, const_arg0 = const_arg1, const_arg1 = tem; 5171: tem = folded_arg0, folded_arg0 = folded_arg1, folded_arg1 = tem; 5172: } 5173: } 5174: } 5175: 5176: /* If X is an arithmetic operation, see if we can simplify it. */ 5177: 5178: switch (GET_RTX_CLASS (code)) 5179: { 5180: case '1': 1.1.1.7 ! root 5181: { ! 5182: int is_const = 0; ! 5183: ! 5184: /* We can't simplify extension ops unless we know the ! 5185: original mode. */ ! 5186: if ((code == ZERO_EXTEND || code == SIGN_EXTEND) ! 5187: && mode_arg0 == VOIDmode) ! 5188: break; ! 5189: ! 5190: /* If we had a CONST, strip it off and put it back later if we ! 5191: fold. */ ! 5192: if (const_arg0 != 0 && GET_CODE (const_arg0) == CONST) ! 5193: is_const = 1, const_arg0 = XEXP (const_arg0, 0); ! 5194: ! 5195: new = simplify_unary_operation (code, mode, ! 5196: const_arg0 ? const_arg0 : folded_arg0, ! 5197: mode_arg0); ! 5198: if (new != 0 && is_const) ! 5199: new = gen_rtx (CONST, mode, new); ! 5200: } 1.1 root 5201: break; 5202: 5203: case '<': 5204: /* See what items are actually being compared and set FOLDED_ARG[01] 5205: to those values and CODE to the actual comparison code. If any are 5206: constant, set CONST_ARG0 and CONST_ARG1 appropriately. We needn't 5207: do anything if both operands are already known to be constant. */ 5208: 5209: if (const_arg0 == 0 || const_arg1 == 0) 5210: { 5211: struct table_elt *p0, *p1; 1.1.1.4 root 5212: rtx true = const_true_rtx, false = const0_rtx; 5213: enum machine_mode mode_arg1; 5214: 5215: #ifdef FLOAT_STORE_FLAG_VALUE 5216: if (GET_MODE_CLASS (mode) == MODE_FLOAT) 5217: { 1.1.1.7 ! root 5218: true = CONST_DOUBLE_FROM_REAL_VALUE (FLOAT_STORE_FLAG_VALUE, ! 5219: mode); 1.1.1.4 root 5220: false = CONST0_RTX (mode); 5221: } 5222: #endif 1.1 root 5223: 1.1.1.4 root 5224: code = find_comparison_args (code, &folded_arg0, &folded_arg1, 5225: &mode_arg0, &mode_arg1); 1.1 root 5226: const_arg0 = equiv_constant (folded_arg0); 5227: const_arg1 = equiv_constant (folded_arg1); 5228: 1.1.1.4 root 5229: /* If the mode is VOIDmode or a MODE_CC mode, we don't know 5230: what kinds of things are being compared, so we can't do 5231: anything with this comparison. */ 1.1 root 5232: 5233: if (mode_arg0 == VOIDmode || GET_MODE_CLASS (mode_arg0) == MODE_CC) 5234: break; 5235: 5236: /* If we do not now have two constants being compared, see if we 5237: can nevertheless deduce some things about the comparison. */ 5238: if (const_arg0 == 0 || const_arg1 == 0) 5239: { 5240: /* Is FOLDED_ARG0 frame-pointer plus a constant? Or non-explicit 5241: constant? These aren't zero, but we don't know their sign. */ 5242: if (const_arg1 == const0_rtx 5243: && (NONZERO_BASE_PLUS_P (folded_arg0) 5244: #if 0 /* Sad to say, on sysvr4, #pragma weak can make a symbol address 5245: come out as 0. */ 5246: || GET_CODE (folded_arg0) == SYMBOL_REF 5247: #endif 5248: || GET_CODE (folded_arg0) == LABEL_REF 5249: || GET_CODE (folded_arg0) == CONST)) 5250: { 5251: if (code == EQ) 1.1.1.4 root 5252: return false; 1.1 root 5253: else if (code == NE) 1.1.1.4 root 5254: return true; 1.1 root 5255: } 5256: 5257: /* See if the two operands are the same. We don't do this 5258: for IEEE floating-point since we can't assume x == x 5259: since x might be a NaN. */ 5260: 5261: if ((TARGET_FLOAT_FORMAT != IEEE_FLOAT_FORMAT 1.1.1.7 ! root 5262: || ! FLOAT_MODE_P (mode_arg0) || flag_fast_math) 1.1 root 5263: && (folded_arg0 == folded_arg1 5264: || (GET_CODE (folded_arg0) == REG 5265: && GET_CODE (folded_arg1) == REG 5266: && (reg_qty[REGNO (folded_arg0)] 5267: == reg_qty[REGNO (folded_arg1)])) 5268: || ((p0 = lookup (folded_arg0, 5269: (safe_hash (folded_arg0, mode_arg0) 5270: % NBUCKETS), mode_arg0)) 5271: && (p1 = lookup (folded_arg1, 5272: (safe_hash (folded_arg1, mode_arg0) 5273: % NBUCKETS), mode_arg0)) 5274: && p0->first_same_value == p1->first_same_value))) 5275: return ((code == EQ || code == LE || code == GE 5276: || code == LEU || code == GEU) 1.1.1.4 root 5277: ? true : false); 1.1 root 5278: 5279: /* If FOLDED_ARG0 is a register, see if the comparison we are 5280: doing now is either the same as we did before or the reverse 5281: (we only check the reverse if not floating-point). */ 5282: else if (GET_CODE (folded_arg0) == REG) 5283: { 5284: int qty = reg_qty[REGNO (folded_arg0)]; 5285: 5286: if (REGNO_QTY_VALID_P (REGNO (folded_arg0)) 5287: && (comparison_dominates_p (qty_comparison_code[qty], code) 5288: || (comparison_dominates_p (qty_comparison_code[qty], 5289: reverse_condition (code)) 1.1.1.6 root 5290: && ! FLOAT_MODE_P (mode_arg0))) 1.1 root 5291: && (rtx_equal_p (qty_comparison_const[qty], folded_arg1) 5292: || (const_arg1 5293: && rtx_equal_p (qty_comparison_const[qty], 5294: const_arg1)) 5295: || (GET_CODE (folded_arg1) == REG 5296: && (reg_qty[REGNO (folded_arg1)] 5297: == qty_comparison_qty[qty])))) 5298: return (comparison_dominates_p (qty_comparison_code[qty], 5299: code) 1.1.1.4 root 5300: ? true : false); 1.1 root 5301: } 5302: } 5303: } 5304: 5305: /* If we are comparing against zero, see if the first operand is 5306: equivalent to an IOR with a constant. If so, we may be able to 5307: determine the result of this comparison. */ 5308: 5309: if (const_arg1 == const0_rtx) 5310: { 5311: rtx y = lookup_as_function (folded_arg0, IOR); 5312: rtx inner_const; 5313: 5314: if (y != 0 5315: && (inner_const = equiv_constant (XEXP (y, 1))) != 0 5316: && GET_CODE (inner_const) == CONST_INT 5317: && INTVAL (inner_const) != 0) 5318: { 5319: int sign_bitnum = GET_MODE_BITSIZE (mode_arg0) - 1; 1.1.1.4 root 5320: int has_sign = (HOST_BITS_PER_WIDE_INT >= sign_bitnum 5321: && (INTVAL (inner_const) 5322: & ((HOST_WIDE_INT) 1 << sign_bitnum))); 5323: rtx true = const_true_rtx, false = const0_rtx; 5324: 5325: #ifdef FLOAT_STORE_FLAG_VALUE 5326: if (GET_MODE_CLASS (mode) == MODE_FLOAT) 5327: { 1.1.1.7 ! root 5328: true = CONST_DOUBLE_FROM_REAL_VALUE (FLOAT_STORE_FLAG_VALUE, ! 5329: mode); 1.1.1.4 root 5330: false = CONST0_RTX (mode); 5331: } 5332: #endif 1.1 root 5333: 5334: switch (code) 5335: { 5336: case EQ: 1.1.1.4 root 5337: return false; 1.1 root 5338: case NE: 1.1.1.4 root 5339: return true; 1.1 root 5340: case LT: case LE: 5341: if (has_sign) 1.1.1.4 root 5342: return true; 1.1 root 5343: break; 5344: case GT: case GE: 5345: if (has_sign) 1.1.1.4 root 5346: return false; 1.1 root 5347: break; 5348: } 5349: } 5350: } 5351: 5352: new = simplify_relational_operation (code, mode_arg0, 5353: const_arg0 ? const_arg0 : folded_arg0, 5354: const_arg1 ? const_arg1 : folded_arg1); 1.1.1.4 root 5355: #ifdef FLOAT_STORE_FLAG_VALUE 5356: if (new != 0 && GET_MODE_CLASS (mode) == MODE_FLOAT) 5357: new = ((new == const0_rtx) ? CONST0_RTX (mode) 1.1.1.7 ! root 5358: : CONST_DOUBLE_FROM_REAL_VALUE (FLOAT_STORE_FLAG_VALUE, mode)); 1.1.1.4 root 5359: #endif 1.1 root 5360: break; 5361: 5362: case '2': 5363: case 'c': 5364: switch (code) 5365: { 5366: case PLUS: 5367: /* If the second operand is a LABEL_REF, see if the first is a MINUS 5368: with that LABEL_REF as its second operand. If so, the result is 5369: the first operand of that MINUS. This handles switches with an 5370: ADDR_DIFF_VEC table. */ 5371: if (const_arg1 && GET_CODE (const_arg1) == LABEL_REF) 5372: { 1.1.1.7 ! root 5373: rtx y ! 5374: = GET_CODE (folded_arg0) == MINUS ? folded_arg0 ! 5375: : lookup_as_function (folded_arg0, MINUS); 1.1 root 5376: 5377: if (y != 0 && GET_CODE (XEXP (y, 1)) == LABEL_REF 5378: && XEXP (XEXP (y, 1), 0) == XEXP (const_arg1, 0)) 5379: return XEXP (y, 0); 1.1.1.7 ! root 5380: ! 5381: /* Now try for a CONST of a MINUS like the above. */ ! 5382: if ((y = (GET_CODE (folded_arg0) == CONST ? folded_arg0 ! 5383: : lookup_as_function (folded_arg0, CONST))) != 0 ! 5384: && GET_CODE (XEXP (y, 0)) == MINUS ! 5385: && GET_CODE (XEXP (XEXP (y, 0), 1)) == LABEL_REF ! 5386: && XEXP (XEXP (XEXP (y, 0),1), 0) == XEXP (const_arg1, 0)) ! 5387: return XEXP (XEXP (y, 0), 0); ! 5388: } ! 5389: ! 5390: /* Likewise if the operands are in the other order. */ ! 5391: if (const_arg0 && GET_CODE (const_arg0) == LABEL_REF) ! 5392: { ! 5393: rtx y ! 5394: = GET_CODE (folded_arg1) == MINUS ? folded_arg1 ! 5395: : lookup_as_function (folded_arg1, MINUS); ! 5396: ! 5397: if (y != 0 && GET_CODE (XEXP (y, 1)) == LABEL_REF ! 5398: && XEXP (XEXP (y, 1), 0) == XEXP (const_arg0, 0)) ! 5399: return XEXP (y, 0); ! 5400: ! 5401: /* Now try for a CONST of a MINUS like the above. */ ! 5402: if ((y = (GET_CODE (folded_arg1) == CONST ? folded_arg1 ! 5403: : lookup_as_function (folded_arg1, CONST))) != 0 ! 5404: && GET_CODE (XEXP (y, 0)) == MINUS ! 5405: && GET_CODE (XEXP (XEXP (y, 0), 1)) == LABEL_REF ! 5406: && XEXP (XEXP (XEXP (y, 0),1), 0) == XEXP (const_arg0, 0)) ! 5407: return XEXP (XEXP (y, 0), 0); ! 5408: } ! 5409: ! 5410: /* If second operand is a register equivalent to a negative ! 5411: CONST_INT, see if we can find a register equivalent to the ! 5412: positive constant. Make a MINUS if so. Don't do this for ! 5413: a negative constant since we might then alternate between ! 5414: chosing positive and negative constants. Having the positive ! 5415: constant previously-used is the more common case. */ ! 5416: if (const_arg1 && GET_CODE (const_arg1) == CONST_INT ! 5417: && INTVAL (const_arg1) < 0 && GET_CODE (folded_arg1) == REG) ! 5418: { ! 5419: rtx new_const = GEN_INT (- INTVAL (const_arg1)); ! 5420: struct table_elt *p ! 5421: = lookup (new_const, safe_hash (new_const, mode) % NBUCKETS, ! 5422: mode); ! 5423: ! 5424: if (p) ! 5425: for (p = p->first_same_value; p; p = p->next_same_value) ! 5426: if (GET_CODE (p->exp) == REG) ! 5427: return cse_gen_binary (MINUS, mode, folded_arg0, ! 5428: canon_reg (p->exp, NULL_RTX)); 1.1 root 5429: } 1.1.1.4 root 5430: goto from_plus; 5431: 5432: case MINUS: 5433: /* If we have (MINUS Y C), see if Y is known to be (PLUS Z C2). 5434: If so, produce (PLUS Z C2-C). */ 5435: if (const_arg1 != 0 && GET_CODE (const_arg1) == CONST_INT) 5436: { 5437: rtx y = lookup_as_function (XEXP (x, 0), PLUS); 5438: if (y && GET_CODE (XEXP (y, 1)) == CONST_INT) 1.1.1.6 root 5439: return fold_rtx (plus_constant (copy_rtx (y), 5440: -INTVAL (const_arg1)), 1.1.1.5 root 5441: NULL_RTX); 1.1.1.4 root 5442: } 1.1 root 5443: 5444: /* ... fall through ... */ 5445: 1.1.1.4 root 5446: from_plus: 1.1 root 5447: case SMIN: case SMAX: case UMIN: case UMAX: 5448: case IOR: case AND: case XOR: 5449: case MULT: case DIV: case UDIV: 5450: case ASHIFT: case LSHIFTRT: case ASHIFTRT: 5451: /* If we have (<op> <reg> <const_int>) for an associative OP and REG 5452: is known to be of similar form, we may be able to replace the 5453: operation with a combined operation. This may eliminate the 5454: intermediate operation if every use is simplified in this way. 5455: Note that the similar optimization done by combine.c only works 5456: if the intermediate operation's result has only one reference. */ 5457: 5458: if (GET_CODE (folded_arg0) == REG 5459: && const_arg1 && GET_CODE (const_arg1) == CONST_INT) 5460: { 5461: int is_shift 5462: = (code == ASHIFT || code == ASHIFTRT || code == LSHIFTRT); 5463: rtx y = lookup_as_function (folded_arg0, code); 5464: rtx inner_const; 5465: enum rtx_code associate_code; 5466: rtx new_const; 5467: 5468: if (y == 0 5469: || 0 == (inner_const 5470: = equiv_constant (fold_rtx (XEXP (y, 1), 0))) 5471: || GET_CODE (inner_const) != CONST_INT 5472: /* If we have compiled a statement like 5473: "if (x == (x & mask1))", and now are looking at 5474: "x & mask2", we will have a case where the first operand 5475: of Y is the same as our first operand. Unless we detect 5476: this case, an infinite loop will result. */ 5477: || XEXP (y, 0) == folded_arg0) 5478: break; 5479: 5480: /* Don't associate these operations if they are a PLUS with the 5481: same constant and it is a power of two. These might be doable 5482: with a pre- or post-increment. Similarly for two subtracts of 5483: identical powers of two with post decrement. */ 5484: 5485: if (code == PLUS && INTVAL (const_arg1) == INTVAL (inner_const) 5486: && (0 5487: #if defined(HAVE_PRE_INCREMENT) || defined(HAVE_POST_INCREMENT) 5488: || exact_log2 (INTVAL (const_arg1)) >= 0 5489: #endif 5490: #if defined(HAVE_PRE_DECREMENT) || defined(HAVE_POST_DECREMENT) 5491: || exact_log2 (- INTVAL (const_arg1)) >= 0 5492: #endif 5493: )) 5494: break; 5495: 5496: /* Compute the code used to compose the constants. For example, 5497: A/C1/C2 is A/(C1 * C2), so if CODE == DIV, we want MULT. */ 5498: 5499: associate_code 5500: = (code == MULT || code == DIV || code == UDIV ? MULT 5501: : is_shift || code == PLUS || code == MINUS ? PLUS : code); 5502: 5503: new_const = simplify_binary_operation (associate_code, mode, 5504: const_arg1, inner_const); 5505: 5506: if (new_const == 0) 5507: break; 5508: 5509: /* If we are associating shift operations, don't let this 1.1.1.5 root 5510: produce a shift of the size of the object or larger. 5511: This could occur when we follow a sign-extend by a right 5512: shift on a machine that does a sign-extend as a pair 5513: of shifts. */ 1.1 root 5514: 5515: if (is_shift && GET_CODE (new_const) == CONST_INT 1.1.1.5 root 5516: && INTVAL (new_const) >= GET_MODE_BITSIZE (mode)) 5517: { 5518: /* As an exception, we can turn an ASHIFTRT of this 5519: form into a shift of the number of bits - 1. */ 5520: if (code == ASHIFTRT) 5521: new_const = GEN_INT (GET_MODE_BITSIZE (mode) - 1); 5522: else 5523: break; 5524: } 1.1 root 5525: 5526: y = copy_rtx (XEXP (y, 0)); 5527: 5528: /* If Y contains our first operand (the most common way this 5529: can happen is if Y is a MEM), we would do into an infinite 5530: loop if we tried to fold it. So don't in that case. */ 5531: 5532: if (! reg_mentioned_p (folded_arg0, y)) 5533: y = fold_rtx (y, insn); 5534: 1.1.1.5 root 5535: return cse_gen_binary (code, mode, y, new_const); 1.1 root 5536: } 5537: } 5538: 5539: new = simplify_binary_operation (code, mode, 5540: const_arg0 ? const_arg0 : folded_arg0, 5541: const_arg1 ? const_arg1 : folded_arg1); 5542: break; 5543: 1.1.1.2 root 5544: case 'o': 5545: /* (lo_sum (high X) X) is simply X. */ 5546: if (code == LO_SUM && const_arg0 != 0 5547: && GET_CODE (const_arg0) == HIGH 5548: && rtx_equal_p (XEXP (const_arg0, 0), const_arg1)) 5549: return const_arg1; 5550: break; 5551: 1.1 root 5552: case '3': 5553: case 'b': 5554: new = simplify_ternary_operation (code, mode, mode_arg0, 5555: const_arg0 ? const_arg0 : folded_arg0, 5556: const_arg1 ? const_arg1 : folded_arg1, 5557: const_arg2 ? const_arg2 : XEXP (x, 2)); 5558: break; 5559: } 5560: 5561: return new ? new : x; 5562: } 5563: 5564: /* Return a constant value currently equivalent to X. 5565: Return 0 if we don't know one. */ 5566: 5567: static rtx 5568: equiv_constant (x) 5569: rtx x; 5570: { 5571: if (GET_CODE (x) == REG 5572: && REGNO_QTY_VALID_P (REGNO (x)) 5573: && qty_const[reg_qty[REGNO (x)]]) 5574: x = gen_lowpart_if_possible (GET_MODE (x), qty_const[reg_qty[REGNO (x)]]); 5575: 5576: if (x != 0 && CONSTANT_P (x)) 5577: return x; 5578: 1.1.1.3 root 5579: /* If X is a MEM, try to fold it outside the context of any insn to see if 5580: it might be equivalent to a constant. That handles the case where it 5581: is a constant-pool reference. Then try to look it up in the hash table 5582: in case it is something whose value we have seen before. */ 5583: 5584: if (GET_CODE (x) == MEM) 5585: { 5586: struct table_elt *elt; 5587: 1.1.1.4 root 5588: x = fold_rtx (x, NULL_RTX); 1.1.1.3 root 5589: if (CONSTANT_P (x)) 5590: return x; 5591: 5592: elt = lookup (x, safe_hash (x, GET_MODE (x)) % NBUCKETS, GET_MODE (x)); 5593: if (elt == 0) 5594: return 0; 5595: 5596: for (elt = elt->first_same_value; elt; elt = elt->next_same_value) 5597: if (elt->is_const && CONSTANT_P (elt->exp)) 5598: return elt->exp; 5599: } 5600: 1.1 root 5601: return 0; 5602: } 5603: 5604: /* Assuming that X is an rtx (e.g., MEM, REG or SUBREG) for a fixed-point 5605: number, return an rtx (MEM, SUBREG, or CONST_INT) that refers to the 5606: least-significant part of X. 5607: MODE specifies how big a part of X to return. 5608: 5609: If the requested operation cannot be done, 0 is returned. 5610: 5611: This is similar to gen_lowpart in emit-rtl.c. */ 5612: 5613: rtx 5614: gen_lowpart_if_possible (mode, x) 5615: enum machine_mode mode; 5616: register rtx x; 5617: { 5618: rtx result = gen_lowpart_common (mode, x); 5619: 5620: if (result) 5621: return result; 5622: else if (GET_CODE (x) == MEM) 5623: { 5624: /* This is the only other case we handle. */ 5625: register int offset = 0; 5626: rtx new; 5627: 5628: #if WORDS_BIG_ENDIAN 5629: offset = (MAX (GET_MODE_SIZE (GET_MODE (x)), UNITS_PER_WORD) 5630: - MAX (GET_MODE_SIZE (mode), UNITS_PER_WORD)); 5631: #endif 5632: #if BYTES_BIG_ENDIAN 5633: /* Adjust the address so that the address-after-the-data 5634: is unchanged. */ 5635: offset -= (MIN (UNITS_PER_WORD, GET_MODE_SIZE (mode)) 5636: - MIN (UNITS_PER_WORD, GET_MODE_SIZE (GET_MODE (x)))); 5637: #endif 5638: new = gen_rtx (MEM, mode, plus_constant (XEXP (x, 0), offset)); 5639: if (! memory_address_p (mode, XEXP (new, 0))) 5640: return 0; 5641: MEM_VOLATILE_P (new) = MEM_VOLATILE_P (x); 5642: RTX_UNCHANGING_P (new) = RTX_UNCHANGING_P (x); 5643: MEM_IN_STRUCT_P (new) = MEM_IN_STRUCT_P (x); 5644: return new; 5645: } 5646: else 5647: return 0; 5648: } 5649: 5650: /* Given INSN, a jump insn, TAKEN indicates if we are following the "taken" 5651: branch. It will be zero if not. 5652: 5653: In certain cases, this can cause us to add an equivalence. For example, 5654: if we are following the taken case of 5655: if (i == 2) 5656: we can add the fact that `i' and '2' are now equivalent. 5657: 5658: In any case, we can record that this comparison was passed. If the same 5659: comparison is seen later, we will know its value. */ 5660: 5661: static void 5662: record_jump_equiv (insn, taken) 5663: rtx insn; 5664: int taken; 5665: { 5666: int cond_known_true; 5667: rtx op0, op1; 1.1.1.4 root 5668: enum machine_mode mode, mode0, mode1; 1.1 root 5669: int reversed_nonequality = 0; 5670: enum rtx_code code; 5671: 5672: /* Ensure this is the right kind of insn. */ 5673: if (! condjump_p (insn) || simplejump_p (insn)) 5674: return; 5675: 5676: /* See if this jump condition is known true or false. */ 5677: if (taken) 5678: cond_known_true = (XEXP (SET_SRC (PATTERN (insn)), 2) == pc_rtx); 5679: else 5680: cond_known_true = (XEXP (SET_SRC (PATTERN (insn)), 1) == pc_rtx); 5681: 5682: /* Get the type of comparison being done and the operands being compared. 5683: If we had to reverse a non-equality condition, record that fact so we 5684: know that it isn't valid for floating-point. */ 5685: code = GET_CODE (XEXP (SET_SRC (PATTERN (insn)), 0)); 5686: op0 = fold_rtx (XEXP (XEXP (SET_SRC (PATTERN (insn)), 0), 0), insn); 5687: op1 = fold_rtx (XEXP (XEXP (SET_SRC (PATTERN (insn)), 0), 1), insn); 5688: 1.1.1.4 root 5689: code = find_comparison_args (code, &op0, &op1, &mode0, &mode1); 1.1 root 5690: if (! cond_known_true) 5691: { 5692: reversed_nonequality = (code != EQ && code != NE); 5693: code = reverse_condition (code); 5694: } 5695: 5696: /* The mode is the mode of the non-constant. */ 1.1.1.4 root 5697: mode = mode0; 5698: if (mode1 != VOIDmode) 5699: mode = mode1; 1.1 root 5700: 5701: record_jump_cond (code, mode, op0, op1, reversed_nonequality); 5702: } 5703: 5704: /* We know that comparison CODE applied to OP0 and OP1 in MODE is true. 5705: REVERSED_NONEQUALITY is nonzero if CODE had to be swapped. 5706: Make any useful entries we can with that information. Called from 5707: above function and called recursively. */ 5708: 5709: static void 5710: record_jump_cond (code, mode, op0, op1, reversed_nonequality) 5711: enum rtx_code code; 5712: enum machine_mode mode; 5713: rtx op0, op1; 5714: int reversed_nonequality; 5715: { 1.1.1.7 ! root 5716: unsigned op0_hash, op1_hash; 1.1 root 5717: int op0_in_memory, op0_in_struct, op1_in_memory, op1_in_struct; 5718: struct table_elt *op0_elt, *op1_elt; 5719: 5720: /* If OP0 and OP1 are known equal, and either is a paradoxical SUBREG, 5721: we know that they are also equal in the smaller mode (this is also 5722: true for all smaller modes whether or not there is a SUBREG, but 5723: is not worth testing for with no SUBREG. */ 5724: 1.1.1.5 root 5725: /* Note that GET_MODE (op0) may not equal MODE. */ 1.1 root 5726: if (code == EQ && GET_CODE (op0) == SUBREG 1.1.1.5 root 5727: && (GET_MODE_SIZE (GET_MODE (op0)) 5728: > GET_MODE_SIZE (GET_MODE (SUBREG_REG (op0))))) 1.1 root 5729: { 5730: enum machine_mode inner_mode = GET_MODE (SUBREG_REG (op0)); 5731: rtx tem = gen_lowpart_if_possible (inner_mode, op1); 5732: 5733: record_jump_cond (code, mode, SUBREG_REG (op0), 5734: tem ? tem : gen_rtx (SUBREG, inner_mode, op1, 0), 5735: reversed_nonequality); 5736: } 5737: 5738: if (code == EQ && GET_CODE (op1) == SUBREG 1.1.1.5 root 5739: && (GET_MODE_SIZE (GET_MODE (op1)) 5740: > GET_MODE_SIZE (GET_MODE (SUBREG_REG (op1))))) 1.1 root 5741: { 5742: enum machine_mode inner_mode = GET_MODE (SUBREG_REG (op1)); 5743: rtx tem = gen_lowpart_if_possible (inner_mode, op0); 5744: 5745: record_jump_cond (code, mode, SUBREG_REG (op1), 5746: tem ? tem : gen_rtx (SUBREG, inner_mode, op0, 0), 5747: reversed_nonequality); 5748: } 5749: 5750: /* Similarly, if this is an NE comparison, and either is a SUBREG 5751: making a smaller mode, we know the whole thing is also NE. */ 5752: 1.1.1.5 root 5753: /* Note that GET_MODE (op0) may not equal MODE; 5754: if we test MODE instead, we can get an infinite recursion 5755: alternating between two modes each wider than MODE. */ 5756: 1.1 root 5757: if (code == NE && GET_CODE (op0) == SUBREG 5758: && subreg_lowpart_p (op0) 1.1.1.5 root 5759: && (GET_MODE_SIZE (GET_MODE (op0)) 5760: < GET_MODE_SIZE (GET_MODE (SUBREG_REG (op0))))) 1.1 root 5761: { 5762: enum machine_mode inner_mode = GET_MODE (SUBREG_REG (op0)); 5763: rtx tem = gen_lowpart_if_possible (inner_mode, op1); 5764: 5765: record_jump_cond (code, mode, SUBREG_REG (op0), 5766: tem ? tem : gen_rtx (SUBREG, inner_mode, op1, 0), 5767: reversed_nonequality); 5768: } 5769: 5770: if (code == NE && GET_CODE (op1) == SUBREG 5771: && subreg_lowpart_p (op1) 1.1.1.5 root 5772: && (GET_MODE_SIZE (GET_MODE (op1)) 5773: < GET_MODE_SIZE (GET_MODE (SUBREG_REG (op1))))) 1.1 root 5774: { 5775: enum machine_mode inner_mode = GET_MODE (SUBREG_REG (op1)); 5776: rtx tem = gen_lowpart_if_possible (inner_mode, op0); 5777: 5778: record_jump_cond (code, mode, SUBREG_REG (op1), 5779: tem ? tem : gen_rtx (SUBREG, inner_mode, op0, 0), 5780: reversed_nonequality); 5781: } 5782: 5783: /* Hash both operands. */ 5784: 5785: do_not_record = 0; 5786: hash_arg_in_memory = 0; 5787: hash_arg_in_struct = 0; 1.1.1.7 ! root 5788: op0_hash = HASH (op0, mode); 1.1 root 5789: op0_in_memory = hash_arg_in_memory; 5790: op0_in_struct = hash_arg_in_struct; 5791: 5792: if (do_not_record) 5793: return; 5794: 5795: do_not_record = 0; 5796: hash_arg_in_memory = 0; 5797: hash_arg_in_struct = 0; 1.1.1.7 ! root 5798: op1_hash = HASH (op1, mode); 1.1 root 5799: op1_in_memory = hash_arg_in_memory; 5800: op1_in_struct = hash_arg_in_struct; 5801: 5802: if (do_not_record) 5803: return; 5804: 5805: /* Look up both operands. */ 1.1.1.7 ! root 5806: op0_elt = lookup (op0, op0_hash, mode); ! 5807: op1_elt = lookup (op1, op1_hash, mode); ! 5808: ! 5809: /* If both operands are already equivalent or if they are not in the ! 5810: table but are identical, do nothing. */ ! 5811: if ((op0_elt != 0 && op1_elt != 0 ! 5812: && op0_elt->first_same_value == op1_elt->first_same_value) ! 5813: || op0 == op1 || rtx_equal_p (op0, op1)) ! 5814: return; 1.1 root 5815: 5816: /* If we aren't setting two things equal all we can do is save this 1.1.1.4 root 5817: comparison. Similarly if this is floating-point. In the latter 5818: case, OP1 might be zero and both -0.0 and 0.0 are equal to it. 5819: If we record the equality, we might inadvertently delete code 5820: whose intent was to change -0 to +0. */ 5821: 1.1.1.6 root 5822: if (code != EQ || FLOAT_MODE_P (GET_MODE (op0))) 1.1 root 5823: { 5824: /* If we reversed a floating-point comparison, if OP0 is not a 5825: register, or if OP1 is neither a register or constant, we can't 5826: do anything. */ 5827: 5828: if (GET_CODE (op1) != REG) 5829: op1 = equiv_constant (op1); 5830: 1.1.1.6 root 5831: if ((reversed_nonequality && FLOAT_MODE_P (mode)) 1.1 root 5832: || GET_CODE (op0) != REG || op1 == 0) 5833: return; 5834: 5835: /* Put OP0 in the hash table if it isn't already. This gives it a 5836: new quantity number. */ 5837: if (op0_elt == 0) 5838: { 1.1.1.4 root 5839: if (insert_regs (op0, NULL_PTR, 0)) 1.1 root 5840: { 5841: rehash_using_reg (op0); 1.1.1.7 ! root 5842: op0_hash = HASH (op0, mode); 1.1.1.6 root 5843: 5844: /* If OP0 is contained in OP1, this changes its hash code 5845: as well. Faster to rehash than to check, except 5846: for the simple case of a constant. */ 5847: if (! CONSTANT_P (op1)) 1.1.1.7 ! root 5848: op1_hash = HASH (op1,mode); 1.1 root 5849: } 5850: 1.1.1.7 ! root 5851: op0_elt = insert (op0, NULL_PTR, op0_hash, mode); 1.1 root 5852: op0_elt->in_memory = op0_in_memory; 5853: op0_elt->in_struct = op0_in_struct; 5854: } 5855: 5856: qty_comparison_code[reg_qty[REGNO (op0)]] = code; 5857: if (GET_CODE (op1) == REG) 5858: { 1.1.1.5 root 5859: /* Look it up again--in case op0 and op1 are the same. */ 1.1.1.7 ! root 5860: op1_elt = lookup (op1, op1_hash, mode); 1.1.1.5 root 5861: 1.1 root 5862: /* Put OP1 in the hash table so it gets a new quantity number. */ 5863: if (op1_elt == 0) 5864: { 1.1.1.4 root 5865: if (insert_regs (op1, NULL_PTR, 0)) 1.1 root 5866: { 5867: rehash_using_reg (op1); 1.1.1.7 ! root 5868: op1_hash = HASH (op1, mode); 1.1 root 5869: } 5870: 1.1.1.7 ! root 5871: op1_elt = insert (op1, NULL_PTR, op1_hash, mode); 1.1 root 5872: op1_elt->in_memory = op1_in_memory; 5873: op1_elt->in_struct = op1_in_struct; 5874: } 5875: 5876: qty_comparison_qty[reg_qty[REGNO (op0)]] = reg_qty[REGNO (op1)]; 5877: qty_comparison_const[reg_qty[REGNO (op0)]] = 0; 5878: } 5879: else 5880: { 5881: qty_comparison_qty[reg_qty[REGNO (op0)]] = -1; 5882: qty_comparison_const[reg_qty[REGNO (op0)]] = op1; 5883: } 5884: 5885: return; 5886: } 5887: 1.1.1.6 root 5888: /* If either side is still missing an equivalence, make it now, 5889: then merge the equivalences. */ 1.1 root 5890: 5891: if (op0_elt == 0) 5892: { 1.1.1.6 root 5893: if (insert_regs (op0, NULL_PTR, 0)) 1.1 root 5894: { 5895: rehash_using_reg (op0); 1.1.1.7 ! root 5896: op0_hash = HASH (op0, mode); 1.1 root 5897: } 5898: 1.1.1.7 ! root 5899: op0_elt = insert (op0, NULL_PTR, op0_hash, mode); 1.1 root 5900: op0_elt->in_memory = op0_in_memory; 5901: op0_elt->in_struct = op0_in_struct; 5902: } 5903: 5904: if (op1_elt == 0) 5905: { 1.1.1.6 root 5906: if (insert_regs (op1, NULL_PTR, 0)) 1.1 root 5907: { 5908: rehash_using_reg (op1); 1.1.1.7 ! root 5909: op1_hash = HASH (op1, mode); 1.1 root 5910: } 5911: 1.1.1.7 ! root 5912: op1_elt = insert (op1, NULL_PTR, op1_hash, mode); 1.1 root 5913: op1_elt->in_memory = op1_in_memory; 5914: op1_elt->in_struct = op1_in_struct; 5915: } 1.1.1.6 root 5916: 5917: merge_equiv_classes (op0_elt, op1_elt); 5918: last_jump_equiv_class = op0_elt; 1.1 root 5919: } 5920: 5921: /* CSE processing for one instruction. 5922: First simplify sources and addresses of all assignments 5923: in the instruction, using previously-computed equivalents values. 5924: Then install the new sources and destinations in the table 5925: of available values. 5926: 5927: If IN_LIBCALL_BLOCK is nonzero, don't record any equivalence made in 5928: the insn. */ 5929: 5930: /* Data on one SET contained in the instruction. */ 5931: 5932: struct set 5933: { 5934: /* The SET rtx itself. */ 5935: rtx rtl; 5936: /* The SET_SRC of the rtx (the original value, if it is changing). */ 5937: rtx src; 5938: /* The hash-table element for the SET_SRC of the SET. */ 5939: struct table_elt *src_elt; 1.1.1.7 ! root 5940: /* Hash value for the SET_SRC. */ ! 5941: unsigned src_hash; ! 5942: /* Hash value for the SET_DEST. */ ! 5943: unsigned dest_hash; 1.1 root 5944: /* The SET_DEST, with SUBREG, etc., stripped. */ 5945: rtx inner_dest; 5946: /* Place where the pointer to the INNER_DEST was found. */ 5947: rtx *inner_dest_loc; 5948: /* Nonzero if the SET_SRC is in memory. */ 5949: char src_in_memory; 5950: /* Nonzero if the SET_SRC is in a structure. */ 5951: char src_in_struct; 5952: /* Nonzero if the SET_SRC contains something 5953: whose value cannot be predicted and understood. */ 5954: char src_volatile; 5955: /* Original machine mode, in case it becomes a CONST_INT. */ 5956: enum machine_mode mode; 5957: /* A constant equivalent for SET_SRC, if any. */ 5958: rtx src_const; 1.1.1.7 ! root 5959: /* Hash value of constant equivalent for SET_SRC. */ ! 5960: unsigned src_const_hash; 1.1 root 5961: /* Table entry for constant equivalent for SET_SRC, if any. */ 5962: struct table_elt *src_const_elt; 5963: }; 5964: 5965: static void 5966: cse_insn (insn, in_libcall_block) 5967: rtx insn; 5968: int in_libcall_block; 5969: { 5970: register rtx x = PATTERN (insn); 5971: register int i; 1.1.1.7 ! root 5972: rtx tem; 1.1 root 5973: register int n_sets = 0; 5974: 5975: /* Records what this insn does to set CC0. */ 5976: rtx this_insn_cc0 = 0; 5977: enum machine_mode this_insn_cc0_mode; 5978: struct write_data writes_memory; 5979: static struct write_data init = {0, 0, 0, 0}; 5980: 5981: rtx src_eqv = 0; 5982: struct table_elt *src_eqv_elt = 0; 5983: int src_eqv_volatile; 5984: int src_eqv_in_memory; 5985: int src_eqv_in_struct; 1.1.1.7 ! root 5986: unsigned src_eqv_hash; 1.1 root 5987: 5988: struct set *sets; 5989: 5990: this_insn = insn; 5991: writes_memory = init; 5992: 5993: /* Find all the SETs and CLOBBERs in this instruction. 5994: Record all the SETs in the array `set' and count them. 5995: Also determine whether there is a CLOBBER that invalidates 5996: all memory references, or all references at varying addresses. */ 5997: 1.1.1.7 ! root 5998: if (GET_CODE (insn) == CALL_INSN) ! 5999: { ! 6000: for (tem = CALL_INSN_FUNCTION_USAGE (insn); tem; tem = XEXP (tem, 1)) ! 6001: if (GET_CODE (XEXP (tem, 0)) == CLOBBER) ! 6002: invalidate (SET_DEST (XEXP (tem, 0)), VOIDmode); ! 6003: } ! 6004: 1.1 root 6005: if (GET_CODE (x) == SET) 6006: { 6007: sets = (struct set *) alloca (sizeof (struct set)); 6008: sets[0].rtl = x; 6009: 6010: /* Ignore SETs that are unconditional jumps. 6011: They never need cse processing, so this does not hurt. 6012: The reason is not efficiency but rather 6013: so that we can test at the end for instructions 6014: that have been simplified to unconditional jumps 6015: and not be misled by unchanged instructions 6016: that were unconditional jumps to begin with. */ 6017: if (SET_DEST (x) == pc_rtx 6018: && GET_CODE (SET_SRC (x)) == LABEL_REF) 6019: ; 6020: 6021: /* Don't count call-insns, (set (reg 0) (call ...)), as a set. 6022: The hard function value register is used only once, to copy to 6023: someplace else, so it isn't worth cse'ing (and on 80386 is unsafe)! 6024: Ensure we invalidate the destination register. On the 80386 no 1.1.1.4 root 6025: other code would invalidate it since it is a fixed_reg. 6026: We need not check the return of apply_change_group; see canon_reg. */ 1.1 root 6027: 6028: else if (GET_CODE (SET_SRC (x)) == CALL) 6029: { 6030: canon_reg (SET_SRC (x), insn); 1.1.1.4 root 6031: apply_change_group (); 1.1 root 6032: fold_rtx (SET_SRC (x), insn); 1.1.1.7 ! root 6033: invalidate (SET_DEST (x), VOIDmode); 1.1 root 6034: } 6035: else 6036: n_sets = 1; 6037: } 6038: else if (GET_CODE (x) == PARALLEL) 6039: { 6040: register int lim = XVECLEN (x, 0); 6041: 6042: sets = (struct set *) alloca (lim * sizeof (struct set)); 6043: 6044: /* Find all regs explicitly clobbered in this insn, 6045: and ensure they are not replaced with any other regs 6046: elsewhere in this insn. 6047: When a reg that is clobbered is also used for input, 6048: we should presume that that is for a reason, 6049: and we should not substitute some other register 6050: which is not supposed to be clobbered. 6051: Therefore, this loop cannot be merged into the one below 1.1.1.3 root 6052: because a CALL may precede a CLOBBER and refer to the 1.1 root 6053: value clobbered. We must not let a canonicalization do 6054: anything in that case. */ 6055: for (i = 0; i < lim; i++) 6056: { 6057: register rtx y = XVECEXP (x, 0, i); 1.1.1.6 root 6058: if (GET_CODE (y) == CLOBBER) 6059: { 6060: rtx clobbered = XEXP (y, 0); 6061: 6062: if (GET_CODE (clobbered) == REG 6063: || GET_CODE (clobbered) == SUBREG) 1.1.1.7 ! root 6064: invalidate (clobbered, VOIDmode); 1.1.1.6 root 6065: else if (GET_CODE (clobbered) == STRICT_LOW_PART 6066: || GET_CODE (clobbered) == ZERO_EXTRACT) 1.1.1.7 ! root 6067: invalidate (XEXP (clobbered, 0), GET_MODE (clobbered)); 1.1.1.6 root 6068: } 1.1 root 6069: } 6070: 6071: for (i = 0; i < lim; i++) 6072: { 6073: register rtx y = XVECEXP (x, 0, i); 6074: if (GET_CODE (y) == SET) 6075: { 1.1.1.4 root 6076: /* As above, we ignore unconditional jumps and call-insns and 6077: ignore the result of apply_change_group. */ 1.1 root 6078: if (GET_CODE (SET_SRC (y)) == CALL) 6079: { 6080: canon_reg (SET_SRC (y), insn); 1.1.1.4 root 6081: apply_change_group (); 1.1 root 6082: fold_rtx (SET_SRC (y), insn); 1.1.1.7 ! root 6083: invalidate (SET_DEST (y), VOIDmode); 1.1 root 6084: } 6085: else if (SET_DEST (y) == pc_rtx 6086: && GET_CODE (SET_SRC (y)) == LABEL_REF) 6087: ; 6088: else 6089: sets[n_sets++].rtl = y; 6090: } 6091: else if (GET_CODE (y) == CLOBBER) 6092: { 6093: /* If we clobber memory, take note of that, 6094: and canon the address. 6095: This does nothing when a register is clobbered 6096: because we have already invalidated the reg. */ 6097: if (GET_CODE (XEXP (y, 0)) == MEM) 6098: { 1.1.1.4 root 6099: canon_reg (XEXP (y, 0), NULL_RTX); 1.1 root 6100: note_mem_written (XEXP (y, 0), &writes_memory); 6101: } 6102: } 6103: else if (GET_CODE (y) == USE 6104: && ! (GET_CODE (XEXP (y, 0)) == REG 6105: && REGNO (XEXP (y, 0)) < FIRST_PSEUDO_REGISTER)) 1.1.1.4 root 6106: canon_reg (y, NULL_RTX); 1.1 root 6107: else if (GET_CODE (y) == CALL) 6108: { 1.1.1.4 root 6109: /* The result of apply_change_group can be ignored; see 6110: canon_reg. */ 1.1 root 6111: canon_reg (y, insn); 1.1.1.4 root 6112: apply_change_group (); 1.1 root 6113: fold_rtx (y, insn); 6114: } 6115: } 6116: } 6117: else if (GET_CODE (x) == CLOBBER) 6118: { 6119: if (GET_CODE (XEXP (x, 0)) == MEM) 6120: { 1.1.1.4 root 6121: canon_reg (XEXP (x, 0), NULL_RTX); 1.1 root 6122: note_mem_written (XEXP (x, 0), &writes_memory); 6123: } 6124: } 6125: 6126: /* Canonicalize a USE of a pseudo register or memory location. */ 6127: else if (GET_CODE (x) == USE 6128: && ! (GET_CODE (XEXP (x, 0)) == REG 6129: && REGNO (XEXP (x, 0)) < FIRST_PSEUDO_REGISTER)) 1.1.1.4 root 6130: canon_reg (XEXP (x, 0), NULL_RTX); 1.1 root 6131: else if (GET_CODE (x) == CALL) 6132: { 1.1.1.4 root 6133: /* The result of apply_change_group can be ignored; see canon_reg. */ 1.1 root 6134: canon_reg (x, insn); 1.1.1.4 root 6135: apply_change_group (); 1.1 root 6136: fold_rtx (x, insn); 6137: } 6138: 1.1.1.7 ! root 6139: /* Store the equivalent value in SRC_EQV, if different, or if the DEST ! 6140: is a STRICT_LOW_PART. The latter condition is necessary because SRC_EQV ! 6141: is handled specially for this case, and if it isn't set, then there will ! 6142: be no equivalence for the destinatation. */ ! 6143: if (n_sets == 1 && REG_NOTES (insn) != 0 ! 6144: && (tem = find_reg_note (insn, REG_EQUAL, NULL_RTX)) != 0 ! 6145: && (! rtx_equal_p (XEXP (tem, 0), SET_SRC (sets[0].rtl)) ! 6146: || GET_CODE (SET_DEST (sets[0].rtl)) == STRICT_LOW_PART)) ! 6147: src_eqv = canon_reg (XEXP (tem, 0), NULL_RTX); 1.1 root 6148: 6149: /* Canonicalize sources and addresses of destinations. 6150: We do this in a separate pass to avoid problems when a MATCH_DUP is 6151: present in the insn pattern. In that case, we want to ensure that 6152: we don't break the duplicate nature of the pattern. So we will replace 6153: both operands at the same time. Otherwise, we would fail to find an 6154: equivalent substitution in the loop calling validate_change below. 6155: 6156: We used to suppress canonicalization of DEST if it appears in SRC, 1.1.1.4 root 6157: but we don't do this any more. */ 1.1 root 6158: 6159: for (i = 0; i < n_sets; i++) 6160: { 6161: rtx dest = SET_DEST (sets[i].rtl); 6162: rtx src = SET_SRC (sets[i].rtl); 6163: rtx new = canon_reg (src, insn); 6164: 1.1.1.4 root 6165: if ((GET_CODE (new) == REG && GET_CODE (src) == REG 6166: && ((REGNO (new) < FIRST_PSEUDO_REGISTER) 6167: != (REGNO (src) < FIRST_PSEUDO_REGISTER))) 6168: || insn_n_dups[recog_memoized (insn)] > 0) 6169: validate_change (insn, &SET_SRC (sets[i].rtl), new, 1); 1.1 root 6170: else 6171: SET_SRC (sets[i].rtl) = new; 6172: 6173: if (GET_CODE (dest) == ZERO_EXTRACT || GET_CODE (dest) == SIGN_EXTRACT) 6174: { 6175: validate_change (insn, &XEXP (dest, 1), 1.1.1.4 root 6176: canon_reg (XEXP (dest, 1), insn), 1); 1.1 root 6177: validate_change (insn, &XEXP (dest, 2), 1.1.1.4 root 6178: canon_reg (XEXP (dest, 2), insn), 1); 1.1 root 6179: } 6180: 6181: while (GET_CODE (dest) == SUBREG || GET_CODE (dest) == STRICT_LOW_PART 6182: || GET_CODE (dest) == ZERO_EXTRACT 6183: || GET_CODE (dest) == SIGN_EXTRACT) 6184: dest = XEXP (dest, 0); 6185: 6186: if (GET_CODE (dest) == MEM) 6187: canon_reg (dest, insn); 6188: } 6189: 1.1.1.4 root 6190: /* Now that we have done all the replacements, we can apply the change 6191: group and see if they all work. Note that this will cause some 6192: canonicalizations that would have worked individually not to be applied 6193: because some other canonicalization didn't work, but this should not 6194: occur often. 6195: 6196: The result of apply_change_group can be ignored; see canon_reg. */ 6197: 6198: apply_change_group (); 6199: 1.1 root 6200: /* Set sets[i].src_elt to the class each source belongs to. 6201: Detect assignments from or to volatile things 6202: and set set[i] to zero so they will be ignored 6203: in the rest of this function. 6204: 6205: Nothing in this loop changes the hash table or the register chains. */ 6206: 6207: for (i = 0; i < n_sets; i++) 6208: { 6209: register rtx src, dest; 6210: register rtx src_folded; 6211: register struct table_elt *elt = 0, *p; 6212: enum machine_mode mode; 6213: rtx src_eqv_here; 6214: rtx src_const = 0; 6215: rtx src_related = 0; 6216: struct table_elt *src_const_elt = 0; 6217: int src_cost = 10000, src_eqv_cost = 10000, src_folded_cost = 10000; 6218: int src_related_cost = 10000, src_elt_cost = 10000; 6219: /* Set non-zero if we need to call force_const_mem on with the 6220: contents of src_folded before using it. */ 6221: int src_folded_force_flag = 0; 6222: 6223: dest = SET_DEST (sets[i].rtl); 6224: src = SET_SRC (sets[i].rtl); 6225: 6226: /* If SRC is a constant that has no machine mode, 6227: hash it with the destination's machine mode. 6228: This way we can keep different modes separate. */ 6229: 6230: mode = GET_MODE (src) == VOIDmode ? GET_MODE (dest) : GET_MODE (src); 6231: sets[i].mode = mode; 6232: 6233: if (src_eqv) 6234: { 6235: enum machine_mode eqvmode = mode; 6236: if (GET_CODE (dest) == STRICT_LOW_PART) 6237: eqvmode = GET_MODE (SUBREG_REG (XEXP (dest, 0))); 6238: do_not_record = 0; 6239: hash_arg_in_memory = 0; 6240: hash_arg_in_struct = 0; 6241: src_eqv = fold_rtx (src_eqv, insn); 1.1.1.7 ! root 6242: src_eqv_hash = HASH (src_eqv, eqvmode); 1.1 root 6243: 6244: /* Find the equivalence class for the equivalent expression. */ 6245: 6246: if (!do_not_record) 1.1.1.7 ! root 6247: src_eqv_elt = lookup (src_eqv, src_eqv_hash, eqvmode); 1.1 root 6248: 6249: src_eqv_volatile = do_not_record; 6250: src_eqv_in_memory = hash_arg_in_memory; 6251: src_eqv_in_struct = hash_arg_in_struct; 6252: } 6253: 6254: /* If this is a STRICT_LOW_PART assignment, src_eqv corresponds to the 6255: value of the INNER register, not the destination. So it is not 6256: a legal substitution for the source. But save it for later. */ 6257: if (GET_CODE (dest) == STRICT_LOW_PART) 6258: src_eqv_here = 0; 6259: else 6260: src_eqv_here = src_eqv; 6261: 6262: /* Simplify and foldable subexpressions in SRC. Then get the fully- 6263: simplified result, which may not necessarily be valid. */ 6264: src_folded = fold_rtx (src, insn); 6265: 6266: /* If storing a constant in a bitfield, pre-truncate the constant 6267: so we will be able to record it later. */ 6268: if (GET_CODE (SET_DEST (sets[i].rtl)) == ZERO_EXTRACT 6269: || GET_CODE (SET_DEST (sets[i].rtl)) == SIGN_EXTRACT) 6270: { 6271: rtx width = XEXP (SET_DEST (sets[i].rtl), 1); 6272: 6273: if (GET_CODE (src) == CONST_INT 6274: && GET_CODE (width) == CONST_INT 1.1.1.4 root 6275: && INTVAL (width) < HOST_BITS_PER_WIDE_INT 6276: && (INTVAL (src) & ((HOST_WIDE_INT) (-1) << INTVAL (width)))) 6277: src_folded 6278: = GEN_INT (INTVAL (src) & (((HOST_WIDE_INT) 1 6279: << INTVAL (width)) - 1)); 1.1 root 6280: } 6281: 6282: /* Compute SRC's hash code, and also notice if it 6283: should not be recorded at all. In that case, 6284: prevent any further processing of this assignment. */ 6285: do_not_record = 0; 6286: hash_arg_in_memory = 0; 6287: hash_arg_in_struct = 0; 6288: 6289: sets[i].src = src; 1.1.1.7 ! root 6290: sets[i].src_hash = HASH (src, mode); 1.1 root 6291: sets[i].src_volatile = do_not_record; 6292: sets[i].src_in_memory = hash_arg_in_memory; 6293: sets[i].src_in_struct = hash_arg_in_struct; 6294: 1.1.1.4 root 6295: #if 0 6296: /* It is no longer clear why we used to do this, but it doesn't 6297: appear to still be needed. So let's try without it since this 6298: code hurts cse'ing widened ops. */ 1.1 root 6299: /* If source is a perverse subreg (such as QI treated as an SI), 6300: treat it as volatile. It may do the work of an SI in one context 6301: where the extra bits are not being used, but cannot replace an SI 6302: in general. */ 6303: if (GET_CODE (src) == SUBREG 6304: && (GET_MODE_SIZE (GET_MODE (src)) 6305: > GET_MODE_SIZE (GET_MODE (SUBREG_REG (src))))) 6306: sets[i].src_volatile = 1; 1.1.1.4 root 6307: #endif 1.1 root 6308: 6309: /* Locate all possible equivalent forms for SRC. Try to replace 6310: SRC in the insn with each cheaper equivalent. 6311: 6312: We have the following types of equivalents: SRC itself, a folded 6313: version, a value given in a REG_EQUAL note, or a value related 6314: to a constant. 6315: 6316: Each of these equivalents may be part of an additional class 6317: of equivalents (if more than one is in the table, they must be in 6318: the same class; we check for this). 6319: 6320: If the source is volatile, we don't do any table lookups. 6321: 6322: We note any constant equivalent for possible later use in a 6323: REG_NOTE. */ 6324: 6325: if (!sets[i].src_volatile) 1.1.1.7 ! root 6326: elt = lookup (src, sets[i].src_hash, mode); 1.1 root 6327: 6328: sets[i].src_elt = elt; 6329: 6330: if (elt && src_eqv_here && src_eqv_elt) 6331: { 6332: if (elt->first_same_value != src_eqv_elt->first_same_value) 6333: { 6334: /* The REG_EQUAL is indicating that two formerly distinct 6335: classes are now equivalent. So merge them. */ 6336: merge_equiv_classes (elt, src_eqv_elt); 1.1.1.7 ! root 6337: src_eqv_hash = HASH (src_eqv, elt->mode); ! 6338: src_eqv_elt = lookup (src_eqv, src_eqv_hash, elt->mode); 1.1 root 6339: } 6340: 6341: src_eqv_here = 0; 6342: } 6343: 6344: else if (src_eqv_elt) 6345: elt = src_eqv_elt; 6346: 6347: /* Try to find a constant somewhere and record it in `src_const'. 6348: Record its table element, if any, in `src_const_elt'. Look in 6349: any known equivalences first. (If the constant is not in the 1.1.1.7 ! root 6350: table, also set `sets[i].src_const_hash'). */ 1.1 root 6351: if (elt) 6352: for (p = elt->first_same_value; p; p = p->next_same_value) 6353: if (p->is_const) 6354: { 6355: src_const = p->exp; 6356: src_const_elt = elt; 6357: break; 6358: } 6359: 6360: if (src_const == 0 6361: && (CONSTANT_P (src_folded) 6362: /* Consider (minus (label_ref L1) (label_ref L2)) as 6363: "constant" here so we will record it. This allows us 6364: to fold switch statements when an ADDR_DIFF_VEC is used. */ 6365: || (GET_CODE (src_folded) == MINUS 6366: && GET_CODE (XEXP (src_folded, 0)) == LABEL_REF 6367: && GET_CODE (XEXP (src_folded, 1)) == LABEL_REF))) 6368: src_const = src_folded, src_const_elt = elt; 6369: else if (src_const == 0 && src_eqv_here && CONSTANT_P (src_eqv_here)) 6370: src_const = src_eqv_here, src_const_elt = src_eqv_elt; 6371: 6372: /* If we don't know if the constant is in the table, get its 6373: hash code and look it up. */ 6374: if (src_const && src_const_elt == 0) 6375: { 1.1.1.7 ! root 6376: sets[i].src_const_hash = HASH (src_const, mode); ! 6377: src_const_elt = lookup (src_const, sets[i].src_const_hash, mode); 1.1 root 6378: } 6379: 6380: sets[i].src_const = src_const; 6381: sets[i].src_const_elt = src_const_elt; 6382: 6383: /* If the constant and our source are both in the table, mark them as 6384: equivalent. Otherwise, if a constant is in the table but the source 6385: isn't, set ELT to it. */ 6386: if (src_const_elt && elt 6387: && src_const_elt->first_same_value != elt->first_same_value) 6388: merge_equiv_classes (elt, src_const_elt); 6389: else if (src_const_elt && elt == 0) 6390: elt = src_const_elt; 6391: 6392: /* See if there is a register linearly related to a constant 6393: equivalent of SRC. */ 6394: if (src_const 6395: && (GET_CODE (src_const) == CONST 6396: || (src_const_elt && src_const_elt->related_value != 0))) 6397: { 6398: src_related = use_related_value (src_const, src_const_elt); 6399: if (src_related) 6400: { 6401: struct table_elt *src_related_elt 6402: = lookup (src_related, HASH (src_related, mode), mode); 6403: if (src_related_elt && elt) 6404: { 6405: if (elt->first_same_value 6406: != src_related_elt->first_same_value) 6407: /* This can occur when we previously saw a CONST 6408: involving a SYMBOL_REF and then see the SYMBOL_REF 6409: twice. Merge the involved classes. */ 6410: merge_equiv_classes (elt, src_related_elt); 6411: 6412: src_related = 0; 6413: src_related_elt = 0; 6414: } 6415: else if (src_related_elt && elt == 0) 6416: elt = src_related_elt; 6417: } 6418: } 6419: 1.1.1.4 root 6420: /* See if we have a CONST_INT that is already in a register in a 6421: wider mode. */ 6422: 6423: if (src_const && src_related == 0 && GET_CODE (src_const) == CONST_INT 6424: && GET_MODE_CLASS (mode) == MODE_INT 6425: && GET_MODE_BITSIZE (mode) < BITS_PER_WORD) 6426: { 6427: enum machine_mode wider_mode; 6428: 6429: for (wider_mode = GET_MODE_WIDER_MODE (mode); 6430: GET_MODE_BITSIZE (wider_mode) <= BITS_PER_WORD 6431: && src_related == 0; 6432: wider_mode = GET_MODE_WIDER_MODE (wider_mode)) 6433: { 6434: struct table_elt *const_elt 6435: = lookup (src_const, HASH (src_const, wider_mode), wider_mode); 6436: 6437: if (const_elt == 0) 6438: continue; 6439: 6440: for (const_elt = const_elt->first_same_value; 6441: const_elt; const_elt = const_elt->next_same_value) 6442: if (GET_CODE (const_elt->exp) == REG) 6443: { 6444: src_related = gen_lowpart_if_possible (mode, 6445: const_elt->exp); 6446: break; 6447: } 6448: } 6449: } 6450: 1.1.1.2 root 6451: /* Another possibility is that we have an AND with a constant in 6452: a mode narrower than a word. If so, it might have been generated 6453: as part of an "if" which would narrow the AND. If we already 6454: have done the AND in a wider mode, we can use a SUBREG of that 6455: value. */ 6456: 6457: if (flag_expensive_optimizations && ! src_related 6458: && GET_CODE (src) == AND && GET_CODE (XEXP (src, 1)) == CONST_INT 6459: && GET_MODE_SIZE (mode) < UNITS_PER_WORD) 6460: { 6461: enum machine_mode tmode; 1.1.1.4 root 6462: rtx new_and = gen_rtx (AND, VOIDmode, NULL_RTX, XEXP (src, 1)); 1.1.1.2 root 6463: 6464: for (tmode = GET_MODE_WIDER_MODE (mode); 6465: GET_MODE_SIZE (tmode) <= UNITS_PER_WORD; 6466: tmode = GET_MODE_WIDER_MODE (tmode)) 6467: { 6468: rtx inner = gen_lowpart_if_possible (tmode, XEXP (src, 0)); 6469: struct table_elt *larger_elt; 6470: 6471: if (inner) 6472: { 6473: PUT_MODE (new_and, tmode); 6474: XEXP (new_and, 0) = inner; 6475: larger_elt = lookup (new_and, HASH (new_and, tmode), tmode); 6476: if (larger_elt == 0) 6477: continue; 6478: 6479: for (larger_elt = larger_elt->first_same_value; 6480: larger_elt; larger_elt = larger_elt->next_same_value) 6481: if (GET_CODE (larger_elt->exp) == REG) 6482: { 6483: src_related 6484: = gen_lowpart_if_possible (mode, larger_elt->exp); 6485: break; 6486: } 6487: 6488: if (src_related) 6489: break; 6490: } 6491: } 6492: } 1.1.1.7 ! root 6493: ! 6494: #ifdef LOAD_EXTEND_OP ! 6495: /* See if a MEM has already been loaded with a widening operation; ! 6496: if it has, we can use a subreg of that. Many CISC machines ! 6497: also have such operations, but this is only likely to be ! 6498: beneficial these machines. */ ! 6499: ! 6500: if (flag_expensive_optimizations && src_related == 0 ! 6501: && (GET_MODE_SIZE (mode) < UNITS_PER_WORD) ! 6502: && GET_MODE_CLASS (mode) == MODE_INT ! 6503: && GET_CODE (src) == MEM && ! do_not_record ! 6504: && LOAD_EXTEND_OP (mode) != NIL) ! 6505: { ! 6506: enum machine_mode tmode; ! 6507: ! 6508: /* Set what we are trying to extend and the operation it might ! 6509: have been extended with. */ ! 6510: PUT_CODE (memory_extend_rtx, LOAD_EXTEND_OP (mode)); ! 6511: XEXP (memory_extend_rtx, 0) = src; ! 6512: ! 6513: for (tmode = GET_MODE_WIDER_MODE (mode); ! 6514: GET_MODE_SIZE (tmode) <= UNITS_PER_WORD; ! 6515: tmode = GET_MODE_WIDER_MODE (tmode)) ! 6516: { ! 6517: struct table_elt *larger_elt; ! 6518: ! 6519: PUT_MODE (memory_extend_rtx, tmode); ! 6520: larger_elt = lookup (memory_extend_rtx, ! 6521: HASH (memory_extend_rtx, tmode), tmode); ! 6522: if (larger_elt == 0) ! 6523: continue; ! 6524: ! 6525: for (larger_elt = larger_elt->first_same_value; ! 6526: larger_elt; larger_elt = larger_elt->next_same_value) ! 6527: if (GET_CODE (larger_elt->exp) == REG) ! 6528: { ! 6529: src_related = gen_lowpart_if_possible (mode, ! 6530: larger_elt->exp); ! 6531: break; ! 6532: } ! 6533: ! 6534: if (src_related) ! 6535: break; ! 6536: } ! 6537: } ! 6538: #endif /* LOAD_EXTEND_OP */ ! 6539: 1.1 root 6540: if (src == src_folded) 6541: src_folded = 0; 6542: 6543: /* At this point, ELT, if non-zero, points to a class of expressions 6544: equivalent to the source of this SET and SRC, SRC_EQV, SRC_FOLDED, 6545: and SRC_RELATED, if non-zero, each contain additional equivalent 6546: expressions. Prune these latter expressions by deleting expressions 6547: already in the equivalence class. 6548: 6549: Check for an equivalent identical to the destination. If found, 6550: this is the preferred equivalent since it will likely lead to 6551: elimination of the insn. Indicate this by placing it in 6552: `src_related'. */ 6553: 6554: if (elt) elt = elt->first_same_value; 6555: for (p = elt; p; p = p->next_same_value) 6556: { 6557: enum rtx_code code = GET_CODE (p->exp); 6558: 6559: /* If the expression is not valid, ignore it. Then we do not 6560: have to check for validity below. In most cases, we can use 6561: `rtx_equal_p', since canonicalization has already been done. */ 6562: if (code != REG && ! exp_equiv_p (p->exp, p->exp, 1, 0)) 6563: continue; 6564: 6565: if (src && GET_CODE (src) == code && rtx_equal_p (src, p->exp)) 6566: src = 0; 6567: else if (src_folded && GET_CODE (src_folded) == code 6568: && rtx_equal_p (src_folded, p->exp)) 6569: src_folded = 0; 6570: else if (src_eqv_here && GET_CODE (src_eqv_here) == code 6571: && rtx_equal_p (src_eqv_here, p->exp)) 6572: src_eqv_here = 0; 6573: else if (src_related && GET_CODE (src_related) == code 6574: && rtx_equal_p (src_related, p->exp)) 6575: src_related = 0; 6576: 6577: /* This is the same as the destination of the insns, we want 6578: to prefer it. Copy it to src_related. The code below will 6579: then give it a negative cost. */ 6580: if (GET_CODE (dest) == code && rtx_equal_p (p->exp, dest)) 6581: src_related = dest; 6582: 6583: } 6584: 6585: /* Find the cheapest valid equivalent, trying all the available 6586: possibilities. Prefer items not in the hash table to ones 6587: that are when they are equal cost. Note that we can never 6588: worsen an insn as the current contents will also succeed. 1.1.1.3 root 6589: If we find an equivalent identical to the destination, use it as best, 1.1 root 6590: since this insn will probably be eliminated in that case. */ 6591: if (src) 6592: { 6593: if (rtx_equal_p (src, dest)) 6594: src_cost = -1; 6595: else 6596: src_cost = COST (src); 6597: } 6598: 6599: if (src_eqv_here) 6600: { 6601: if (rtx_equal_p (src_eqv_here, dest)) 6602: src_eqv_cost = -1; 6603: else 6604: src_eqv_cost = COST (src_eqv_here); 6605: } 6606: 6607: if (src_folded) 6608: { 6609: if (rtx_equal_p (src_folded, dest)) 6610: src_folded_cost = -1; 6611: else 6612: src_folded_cost = COST (src_folded); 6613: } 6614: 6615: if (src_related) 6616: { 6617: if (rtx_equal_p (src_related, dest)) 6618: src_related_cost = -1; 6619: else 6620: src_related_cost = COST (src_related); 6621: } 6622: 6623: /* If this was an indirect jump insn, a known label will really be 6624: cheaper even though it looks more expensive. */ 6625: if (dest == pc_rtx && src_const && GET_CODE (src_const) == LABEL_REF) 6626: src_folded = src_const, src_folded_cost = -1; 6627: 6628: /* Terminate loop when replacement made. This must terminate since 6629: the current contents will be tested and will always be valid. */ 6630: while (1) 6631: { 6632: rtx trial; 6633: 6634: /* Skip invalid entries. */ 6635: while (elt && GET_CODE (elt->exp) != REG 6636: && ! exp_equiv_p (elt->exp, elt->exp, 1, 0)) 6637: elt = elt->next_same_value; 6638: 6639: if (elt) src_elt_cost = elt->cost; 6640: 6641: /* Find cheapest and skip it for the next time. For items 6642: of equal cost, use this order: 6643: src_folded, src, src_eqv, src_related and hash table entry. */ 6644: if (src_folded_cost <= src_cost 6645: && src_folded_cost <= src_eqv_cost 6646: && src_folded_cost <= src_related_cost 6647: && src_folded_cost <= src_elt_cost) 6648: { 6649: trial = src_folded, src_folded_cost = 10000; 6650: if (src_folded_force_flag) 6651: trial = force_const_mem (mode, trial); 6652: } 6653: else if (src_cost <= src_eqv_cost 6654: && src_cost <= src_related_cost 6655: && src_cost <= src_elt_cost) 6656: trial = src, src_cost = 10000; 6657: else if (src_eqv_cost <= src_related_cost 6658: && src_eqv_cost <= src_elt_cost) 1.1.1.6 root 6659: trial = copy_rtx (src_eqv_here), src_eqv_cost = 10000; 1.1 root 6660: else if (src_related_cost <= src_elt_cost) 1.1.1.6 root 6661: trial = copy_rtx (src_related), src_related_cost = 10000; 1.1 root 6662: else 6663: { 1.1.1.3 root 6664: trial = copy_rtx (elt->exp); 1.1 root 6665: elt = elt->next_same_value; 6666: src_elt_cost = 10000; 6667: } 6668: 6669: /* We don't normally have an insn matching (set (pc) (pc)), so 6670: check for this separately here. We will delete such an 6671: insn below. 6672: 6673: Tablejump insns contain a USE of the table, so simply replacing 6674: the operand with the constant won't match. This is simply an 6675: unconditional branch, however, and is therefore valid. Just 6676: insert the substitution here and we will delete and re-emit 6677: the insn later. */ 6678: 6679: if (n_sets == 1 && dest == pc_rtx 6680: && (trial == pc_rtx 6681: || (GET_CODE (trial) == LABEL_REF 6682: && ! condjump_p (insn)))) 6683: { 6684: /* If TRIAL is a label in front of a jump table, we are 6685: really falling through the switch (this is how casesi 6686: insns work), so we must branch around the table. */ 6687: if (GET_CODE (trial) == CODE_LABEL 6688: && NEXT_INSN (trial) != 0 6689: && GET_CODE (NEXT_INSN (trial)) == JUMP_INSN 6690: && (GET_CODE (PATTERN (NEXT_INSN (trial))) == ADDR_DIFF_VEC 6691: || GET_CODE (PATTERN (NEXT_INSN (trial))) == ADDR_VEC)) 6692: 6693: trial = gen_rtx (LABEL_REF, Pmode, get_label_after (trial)); 6694: 6695: SET_SRC (sets[i].rtl) = trial; 1.1.1.7 ! root 6696: cse_jumps_altered = 1; 1.1 root 6697: break; 6698: } 6699: 6700: /* Look for a substitution that makes a valid insn. */ 6701: else if (validate_change (insn, &SET_SRC (sets[i].rtl), trial, 0)) 1.1.1.3 root 6702: { 1.1.1.4 root 6703: /* The result of apply_change_group can be ignored; see 6704: canon_reg. */ 6705: 6706: validate_change (insn, &SET_SRC (sets[i].rtl), 6707: canon_reg (SET_SRC (sets[i].rtl), insn), 6708: 1); 6709: apply_change_group (); 1.1.1.3 root 6710: break; 6711: } 1.1 root 6712: 6713: /* If we previously found constant pool entries for 6714: constants and this is a constant, try making a 6715: pool entry. Put it in src_folded unless we already have done 6716: this since that is where it likely came from. */ 6717: 6718: else if (constant_pool_entries_cost 6719: && CONSTANT_P (trial) 1.1.1.7 ! root 6720: && ! (GET_CODE (trial) == CONST ! 6721: && GET_CODE (XEXP (trial, 0)) == TRUNCATE) ! 6722: && (src_folded == 0 ! 6723: || (GET_CODE (src_folded) != MEM ! 6724: && ! src_folded_force_flag)) 1.1 root 6725: && GET_MODE_CLASS (mode) != MODE_CC) 6726: { 6727: src_folded_force_flag = 1; 6728: src_folded = trial; 6729: src_folded_cost = constant_pool_entries_cost; 6730: } 6731: } 6732: 6733: src = SET_SRC (sets[i].rtl); 6734: 6735: /* In general, it is good to have a SET with SET_SRC == SET_DEST. 6736: However, there is an important exception: If both are registers 6737: that are not the head of their equivalence class, replace SET_SRC 6738: with the head of the class. If we do not do this, we will have 6739: both registers live over a portion of the basic block. This way, 6740: their lifetimes will likely abut instead of overlapping. */ 6741: if (GET_CODE (dest) == REG 6742: && REGNO_QTY_VALID_P (REGNO (dest)) 6743: && qty_mode[reg_qty[REGNO (dest)]] == GET_MODE (dest) 6744: && qty_first_reg[reg_qty[REGNO (dest)]] != REGNO (dest) 6745: && GET_CODE (src) == REG && REGNO (src) == REGNO (dest) 6746: /* Don't do this if the original insn had a hard reg as 6747: SET_SRC. */ 6748: && (GET_CODE (sets[i].src) != REG 6749: || REGNO (sets[i].src) >= FIRST_PSEUDO_REGISTER)) 6750: /* We can't call canon_reg here because it won't do anything if 6751: SRC is a hard register. */ 6752: { 6753: int first = qty_first_reg[reg_qty[REGNO (src)]]; 6754: 6755: src = SET_SRC (sets[i].rtl) 6756: = first >= FIRST_PSEUDO_REGISTER ? regno_reg_rtx[first] 6757: : gen_rtx (REG, GET_MODE (src), first); 6758: 6759: /* If we had a constant that is cheaper than what we are now 6760: setting SRC to, use that constant. We ignored it when we 6761: thought we could make this into a no-op. */ 6762: if (src_const && COST (src_const) < COST (src) 6763: && validate_change (insn, &SET_SRC (sets[i].rtl), src_const, 0)) 6764: src = src_const; 6765: } 6766: 6767: /* If we made a change, recompute SRC values. */ 6768: if (src != sets[i].src) 6769: { 6770: do_not_record = 0; 6771: hash_arg_in_memory = 0; 6772: hash_arg_in_struct = 0; 6773: sets[i].src = src; 1.1.1.7 ! root 6774: sets[i].src_hash = HASH (src, mode); 1.1 root 6775: sets[i].src_volatile = do_not_record; 6776: sets[i].src_in_memory = hash_arg_in_memory; 6777: sets[i].src_in_struct = hash_arg_in_struct; 1.1.1.7 ! root 6778: sets[i].src_elt = lookup (src, sets[i].src_hash, mode); 1.1 root 6779: } 6780: 6781: /* If this is a single SET, we are setting a register, and we have an 6782: equivalent constant, we want to add a REG_NOTE. We don't want 6783: to write a REG_EQUAL note for a constant pseudo since verifying that 1.1.1.2 root 6784: that pseudo hasn't been eliminated is a pain. Such a note also 1.1 root 6785: won't help anything. */ 6786: if (n_sets == 1 && src_const && GET_CODE (dest) == REG 6787: && GET_CODE (src_const) != REG) 6788: { 1.1.1.7 ! root 6789: tem = find_reg_note (insn, REG_EQUAL, NULL_RTX); 1.1 root 6790: 6791: /* Record the actual constant value in a REG_EQUAL note, making 6792: a new one if one does not already exist. */ 6793: if (tem) 6794: XEXP (tem, 0) = src_const; 6795: else 6796: REG_NOTES (insn) = gen_rtx (EXPR_LIST, REG_EQUAL, 6797: src_const, REG_NOTES (insn)); 6798: 6799: /* If storing a constant value in a register that 6800: previously held the constant value 0, 6801: record this fact with a REG_WAS_0 note on this insn. 6802: 6803: Note that the *register* is required to have previously held 0, 6804: not just any register in the quantity and we must point to the 6805: insn that set that register to zero. 6806: 6807: Rather than track each register individually, we just see if 6808: the last set for this quantity was for this register. */ 6809: 6810: if (REGNO_QTY_VALID_P (REGNO (dest)) 6811: && qty_const[reg_qty[REGNO (dest)]] == const0_rtx) 6812: { 6813: /* See if we previously had a REG_WAS_0 note. */ 1.1.1.4 root 6814: rtx note = find_reg_note (insn, REG_WAS_0, NULL_RTX); 1.1 root 6815: rtx const_insn = qty_const_insn[reg_qty[REGNO (dest)]]; 6816: 6817: if ((tem = single_set (const_insn)) != 0 6818: && rtx_equal_p (SET_DEST (tem), dest)) 6819: { 6820: if (note) 6821: XEXP (note, 0) = const_insn; 6822: else 6823: REG_NOTES (insn) = gen_rtx (INSN_LIST, REG_WAS_0, 6824: const_insn, REG_NOTES (insn)); 6825: } 6826: } 6827: } 6828: 6829: /* Now deal with the destination. */ 6830: do_not_record = 0; 6831: sets[i].inner_dest_loc = &SET_DEST (sets[0].rtl); 6832: 6833: /* Look within any SIGN_EXTRACT or ZERO_EXTRACT 6834: to the MEM or REG within it. */ 6835: while (GET_CODE (dest) == SIGN_EXTRACT 6836: || GET_CODE (dest) == ZERO_EXTRACT 6837: || GET_CODE (dest) == SUBREG 6838: || GET_CODE (dest) == STRICT_LOW_PART) 6839: { 6840: sets[i].inner_dest_loc = &XEXP (dest, 0); 6841: dest = XEXP (dest, 0); 6842: } 6843: 6844: sets[i].inner_dest = dest; 6845: 6846: if (GET_CODE (dest) == MEM) 6847: { 6848: dest = fold_rtx (dest, insn); 6849: 6850: /* Decide whether we invalidate everything in memory, 6851: or just things at non-fixed places. 6852: Writing a large aggregate must invalidate everything 6853: because we don't know how long it is. */ 6854: note_mem_written (dest, &writes_memory); 6855: } 6856: 6857: /* Compute the hash code of the destination now, 6858: before the effects of this instruction are recorded, 6859: since the register values used in the address computation 6860: are those before this instruction. */ 1.1.1.7 ! root 6861: sets[i].dest_hash = HASH (dest, mode); 1.1 root 6862: 6863: /* Don't enter a bit-field in the hash table 6864: because the value in it after the store 6865: may not equal what was stored, due to truncation. */ 6866: 6867: if (GET_CODE (SET_DEST (sets[i].rtl)) == ZERO_EXTRACT 6868: || GET_CODE (SET_DEST (sets[i].rtl)) == SIGN_EXTRACT) 6869: { 6870: rtx width = XEXP (SET_DEST (sets[i].rtl), 1); 6871: 6872: if (src_const != 0 && GET_CODE (src_const) == CONST_INT 6873: && GET_CODE (width) == CONST_INT 1.1.1.4 root 6874: && INTVAL (width) < HOST_BITS_PER_WIDE_INT 6875: && ! (INTVAL (src_const) 6876: & ((HOST_WIDE_INT) (-1) << INTVAL (width)))) 1.1 root 6877: /* Exception: if the value is constant, 6878: and it won't be truncated, record it. */ 6879: ; 6880: else 6881: { 6882: /* This is chosen so that the destination will be invalidated 6883: but no new value will be recorded. 6884: We must invalidate because sometimes constant 6885: values can be recorded for bitfields. */ 6886: sets[i].src_elt = 0; 6887: sets[i].src_volatile = 1; 6888: src_eqv = 0; 6889: src_eqv_elt = 0; 6890: } 6891: } 6892: 6893: /* If only one set in a JUMP_INSN and it is now a no-op, we can delete 6894: the insn. */ 6895: else if (n_sets == 1 && dest == pc_rtx && src == pc_rtx) 6896: { 6897: PUT_CODE (insn, NOTE); 6898: NOTE_LINE_NUMBER (insn) = NOTE_INSN_DELETED; 6899: NOTE_SOURCE_FILE (insn) = 0; 6900: cse_jumps_altered = 1; 6901: /* One less use of the label this insn used to jump to. */ 6902: --LABEL_NUSES (JUMP_LABEL (insn)); 6903: /* No more processing for this set. */ 6904: sets[i].rtl = 0; 6905: } 6906: 6907: /* If this SET is now setting PC to a label, we know it used to 6908: be a conditional or computed branch. So we see if we can follow 6909: it. If it was a computed branch, delete it and re-emit. */ 6910: else if (dest == pc_rtx && GET_CODE (src) == LABEL_REF) 6911: { 6912: rtx p; 6913: 6914: /* If this is not in the format for a simple branch and 6915: we are the only SET in it, re-emit it. */ 6916: if (! simplejump_p (insn) && n_sets == 1) 6917: { 6918: rtx new = emit_jump_insn_before (gen_jump (XEXP (src, 0)), insn); 6919: JUMP_LABEL (new) = XEXP (src, 0); 6920: LABEL_NUSES (XEXP (src, 0))++; 6921: delete_insn (insn); 6922: insn = new; 6923: } 1.1.1.5 root 6924: else 6925: /* Otherwise, force rerecognition, since it probably had 6926: a different pattern before. 6927: This shouldn't really be necessary, since whatever 6928: changed the source value above should have done this. 6929: Until the right place is found, might as well do this here. */ 6930: INSN_CODE (insn) = -1; 1.1 root 6931: 6932: /* Now that we've converted this jump to an unconditional jump, 6933: there is dead code after it. Delete the dead code until we 6934: reach a BARRIER, the end of the function, or a label. Do 6935: not delete NOTEs except for NOTE_INSN_DELETED since later 6936: phases assume these notes are retained. */ 6937: 6938: p = insn; 6939: 6940: while (NEXT_INSN (p) != 0 6941: && GET_CODE (NEXT_INSN (p)) != BARRIER 6942: && GET_CODE (NEXT_INSN (p)) != CODE_LABEL) 6943: { 6944: if (GET_CODE (NEXT_INSN (p)) != NOTE 6945: || NOTE_LINE_NUMBER (NEXT_INSN (p)) == NOTE_INSN_DELETED) 6946: delete_insn (NEXT_INSN (p)); 6947: else 6948: p = NEXT_INSN (p); 6949: } 6950: 6951: /* If we don't have a BARRIER immediately after INSN, put one there. 6952: Much code assumes that there are no NOTEs between a JUMP_INSN and 6953: BARRIER. */ 6954: 6955: if (NEXT_INSN (insn) == 0 6956: || GET_CODE (NEXT_INSN (insn)) != BARRIER) 6957: emit_barrier_after (insn); 6958: 6959: /* We might have two BARRIERs separated by notes. Delete the second 6960: one if so. */ 6961: 1.1.1.2 root 6962: if (p != insn && NEXT_INSN (p) != 0 6963: && GET_CODE (NEXT_INSN (p)) == BARRIER) 1.1 root 6964: delete_insn (NEXT_INSN (p)); 6965: 6966: cse_jumps_altered = 1; 6967: sets[i].rtl = 0; 6968: } 6969: 1.1.1.3 root 6970: /* If destination is volatile, invalidate it and then do no further 6971: processing for this assignment. */ 1.1 root 6972: 6973: else if (do_not_record) 1.1.1.3 root 6974: { 6975: if (GET_CODE (dest) == REG || GET_CODE (dest) == SUBREG 6976: || GET_CODE (dest) == MEM) 1.1.1.7 ! root 6977: invalidate (dest, VOIDmode); 1.1.1.6 root 6978: else if (GET_CODE (dest) == STRICT_LOW_PART 6979: || GET_CODE (dest) == ZERO_EXTRACT) 1.1.1.7 ! root 6980: invalidate (XEXP (dest, 0), GET_MODE (dest)); 1.1.1.3 root 6981: sets[i].rtl = 0; 6982: } 1.1 root 6983: 6984: if (sets[i].rtl != 0 && dest != SET_DEST (sets[i].rtl)) 1.1.1.7 ! root 6985: sets[i].dest_hash = HASH (SET_DEST (sets[i].rtl), mode); 1.1 root 6986: 6987: #ifdef HAVE_cc0 6988: /* If setting CC0, record what it was set to, or a constant, if it 6989: is equivalent to a constant. If it is being set to a floating-point 6990: value, make a COMPARE with the appropriate constant of 0. If we 6991: don't do this, later code can interpret this as a test against 6992: const0_rtx, which can cause problems if we try to put it into an 6993: insn as a floating-point operand. */ 6994: if (dest == cc0_rtx) 6995: { 6996: this_insn_cc0 = src_const && mode != VOIDmode ? src_const : src; 6997: this_insn_cc0_mode = mode; 1.1.1.6 root 6998: if (FLOAT_MODE_P (mode)) 1.1 root 6999: this_insn_cc0 = gen_rtx (COMPARE, VOIDmode, this_insn_cc0, 7000: CONST0_RTX (mode)); 7001: } 7002: #endif 7003: } 7004: 7005: /* Now enter all non-volatile source expressions in the hash table 7006: if they are not already present. 7007: Record their equivalence classes in src_elt. 7008: This way we can insert the corresponding destinations into 7009: the same classes even if the actual sources are no longer in them 7010: (having been invalidated). */ 7011: 7012: if (src_eqv && src_eqv_elt == 0 && sets[0].rtl != 0 && ! src_eqv_volatile 7013: && ! rtx_equal_p (src_eqv, SET_DEST (sets[0].rtl))) 7014: { 7015: register struct table_elt *elt; 7016: register struct table_elt *classp = sets[0].src_elt; 7017: rtx dest = SET_DEST (sets[0].rtl); 7018: enum machine_mode eqvmode = GET_MODE (dest); 7019: 7020: if (GET_CODE (dest) == STRICT_LOW_PART) 7021: { 7022: eqvmode = GET_MODE (SUBREG_REG (XEXP (dest, 0))); 7023: classp = 0; 7024: } 7025: if (insert_regs (src_eqv, classp, 0)) 1.1.1.7 ! root 7026: { ! 7027: rehash_using_reg (src_eqv); ! 7028: src_eqv_hash = HASH (src_eqv, eqvmode); ! 7029: } ! 7030: elt = insert (src_eqv, classp, src_eqv_hash, eqvmode); 1.1 root 7031: elt->in_memory = src_eqv_in_memory; 7032: elt->in_struct = src_eqv_in_struct; 7033: src_eqv_elt = elt; 1.1.1.6 root 7034: 7035: /* Check to see if src_eqv_elt is the same as a set source which 7036: does not yet have an elt, and if so set the elt of the set source 7037: to src_eqv_elt. */ 7038: for (i = 0; i < n_sets; i++) 7039: if (sets[i].rtl && sets[i].src_elt == 0 7040: && rtx_equal_p (SET_SRC (sets[i].rtl), src_eqv)) 7041: sets[i].src_elt = src_eqv_elt; 1.1 root 7042: } 7043: 7044: for (i = 0; i < n_sets; i++) 7045: if (sets[i].rtl && ! sets[i].src_volatile 7046: && ! rtx_equal_p (SET_SRC (sets[i].rtl), SET_DEST (sets[i].rtl))) 7047: { 7048: if (GET_CODE (SET_DEST (sets[i].rtl)) == STRICT_LOW_PART) 7049: { 7050: /* REG_EQUAL in setting a STRICT_LOW_PART 7051: gives an equivalent for the entire destination register, 7052: not just for the subreg being stored in now. 7053: This is a more interesting equivalence, so we arrange later 7054: to treat the entire reg as the destination. */ 7055: sets[i].src_elt = src_eqv_elt; 1.1.1.7 ! root 7056: sets[i].src_hash = src_eqv_hash; 1.1 root 7057: } 7058: else 7059: { 7060: /* Insert source and constant equivalent into hash table, if not 7061: already present. */ 7062: register struct table_elt *classp = src_eqv_elt; 7063: register rtx src = sets[i].src; 7064: register rtx dest = SET_DEST (sets[i].rtl); 7065: enum machine_mode mode 7066: = GET_MODE (src) == VOIDmode ? GET_MODE (dest) : GET_MODE (src); 7067: 7068: if (sets[i].src_elt == 0) 7069: { 7070: register struct table_elt *elt; 7071: 7072: /* Note that these insert_regs calls cannot remove 7073: any of the src_elt's, because they would have failed to 7074: match if not still valid. */ 7075: if (insert_regs (src, classp, 0)) 1.1.1.7 ! root 7076: { ! 7077: rehash_using_reg (src); ! 7078: sets[i].src_hash = HASH (src, mode); ! 7079: } ! 7080: elt = insert (src, classp, sets[i].src_hash, mode); 1.1 root 7081: elt->in_memory = sets[i].src_in_memory; 7082: elt->in_struct = sets[i].src_in_struct; 7083: sets[i].src_elt = classp = elt; 7084: } 7085: 7086: if (sets[i].src_const && sets[i].src_const_elt == 0 7087: && src != sets[i].src_const 7088: && ! rtx_equal_p (sets[i].src_const, src)) 7089: sets[i].src_elt = insert (sets[i].src_const, classp, 1.1.1.7 ! root 7090: sets[i].src_const_hash, mode); 1.1 root 7091: } 7092: } 7093: else if (sets[i].src_elt == 0) 7094: /* If we did not insert the source into the hash table (e.g., it was 7095: volatile), note the equivalence class for the REG_EQUAL value, if any, 7096: so that the destination goes into that class. */ 7097: sets[i].src_elt = src_eqv_elt; 7098: 7099: invalidate_from_clobbers (&writes_memory, x); 1.1.1.4 root 7100: 7101: /* Some registers are invalidated by subroutine calls. Memory is 7102: invalidated by non-constant calls. */ 7103: 1.1 root 7104: if (GET_CODE (insn) == CALL_INSN) 7105: { 7106: static struct write_data everything = {0, 1, 1, 1}; 1.1.1.4 root 7107: 7108: if (! CONST_CALL_P (insn)) 7109: invalidate_memory (&everything); 1.1 root 7110: invalidate_for_call (); 7111: } 7112: 7113: /* Now invalidate everything set by this instruction. 7114: If a SUBREG or other funny destination is being set, 7115: sets[i].rtl is still nonzero, so here we invalidate the reg 7116: a part of which is being set. */ 7117: 7118: for (i = 0; i < n_sets; i++) 7119: if (sets[i].rtl) 7120: { 1.1.1.7 ! root 7121: /* We can't use the inner dest, because the mode associated with ! 7122: a ZERO_EXTRACT is significant. */ ! 7123: register rtx dest = SET_DEST (sets[i].rtl); 1.1 root 7124: 7125: /* Needed for registers to remove the register from its 7126: previous quantity's chain. 7127: Needed for memory if this is a nonvarying address, unless 7128: we have just done an invalidate_memory that covers even those. */ 7129: if (GET_CODE (dest) == REG || GET_CODE (dest) == SUBREG 1.1.1.7 ! root 7130: || (GET_CODE (dest) == MEM && ! writes_memory.all ! 7131: && ! cse_rtx_addr_varies_p (dest))) ! 7132: invalidate (dest, VOIDmode); 1.1.1.6 root 7133: else if (GET_CODE (dest) == STRICT_LOW_PART 7134: || GET_CODE (dest) == ZERO_EXTRACT) 1.1.1.7 ! root 7135: invalidate (XEXP (dest, 0), GET_MODE (dest)); 1.1 root 7136: } 7137: 7138: /* Make sure registers mentioned in destinations 7139: are safe for use in an expression to be inserted. 7140: This removes from the hash table 7141: any invalid entry that refers to one of these registers. 7142: 7143: We don't care about the return value from mention_regs because 7144: we are going to hash the SET_DEST values unconditionally. */ 7145: 7146: for (i = 0; i < n_sets; i++) 7147: if (sets[i].rtl && GET_CODE (SET_DEST (sets[i].rtl)) != REG) 7148: mention_regs (SET_DEST (sets[i].rtl)); 7149: 7150: /* We may have just removed some of the src_elt's from the hash table. 7151: So replace each one with the current head of the same class. */ 7152: 7153: for (i = 0; i < n_sets; i++) 7154: if (sets[i].rtl) 7155: { 7156: if (sets[i].src_elt && sets[i].src_elt->first_same_value == 0) 7157: /* If elt was removed, find current head of same class, 7158: or 0 if nothing remains of that class. */ 7159: { 7160: register struct table_elt *elt = sets[i].src_elt; 7161: 7162: while (elt && elt->prev_same_value) 7163: elt = elt->prev_same_value; 7164: 7165: while (elt && elt->first_same_value == 0) 7166: elt = elt->next_same_value; 7167: sets[i].src_elt = elt ? elt->first_same_value : 0; 7168: } 7169: } 7170: 7171: /* Now insert the destinations into their equivalence classes. */ 7172: 7173: for (i = 0; i < n_sets; i++) 7174: if (sets[i].rtl) 7175: { 7176: register rtx dest = SET_DEST (sets[i].rtl); 7177: register struct table_elt *elt; 7178: 7179: /* Don't record value if we are not supposed to risk allocating 7180: floating-point values in registers that might be wider than 7181: memory. */ 7182: if ((flag_float_store 7183: && GET_CODE (dest) == MEM 1.1.1.6 root 7184: && FLOAT_MODE_P (GET_MODE (dest))) 1.1 root 7185: /* Don't record values of destinations set inside a libcall block 7186: since we might delete the libcall. Things should have been set 7187: up so we won't want to reuse such a value, but we play it safe 7188: here. */ 7189: || in_libcall_block 7190: /* If we didn't put a REG_EQUAL value or a source into the hash 7191: table, there is no point is recording DEST. */ 1.1.1.7 ! root 7192: || sets[i].src_elt == 0 ! 7193: /* If DEST is a paradoxical SUBREG and SRC is a ZERO_EXTEND ! 7194: or SIGN_EXTEND, don't record DEST since it can cause ! 7195: some tracking to be wrong. ! 7196: ! 7197: ??? Think about this more later. */ ! 7198: || (GET_CODE (dest) == SUBREG ! 7199: && (GET_MODE_SIZE (GET_MODE (dest)) ! 7200: > GET_MODE_SIZE (GET_MODE (SUBREG_REG (dest)))) ! 7201: && (GET_CODE (sets[i].src) == SIGN_EXTEND ! 7202: || GET_CODE (sets[i].src) == ZERO_EXTEND))) 1.1 root 7203: continue; 7204: 7205: /* STRICT_LOW_PART isn't part of the value BEING set, 7206: and neither is the SUBREG inside it. 7207: Note that in this case SETS[I].SRC_ELT is really SRC_EQV_ELT. */ 7208: if (GET_CODE (dest) == STRICT_LOW_PART) 7209: dest = SUBREG_REG (XEXP (dest, 0)); 7210: 1.1.1.4 root 7211: if (GET_CODE (dest) == REG || GET_CODE (dest) == SUBREG) 1.1 root 7212: /* Registers must also be inserted into chains for quantities. */ 7213: if (insert_regs (dest, sets[i].src_elt, 1)) 1.1.1.7 ! root 7214: { ! 7215: /* If `insert_regs' changes something, the hash code must be ! 7216: recalculated. */ ! 7217: rehash_using_reg (dest); ! 7218: sets[i].dest_hash = HASH (dest, GET_MODE (dest)); ! 7219: } 1.1 root 7220: 7221: elt = insert (dest, sets[i].src_elt, 1.1.1.7 ! root 7222: sets[i].dest_hash, GET_MODE (dest)); 1.1 root 7223: elt->in_memory = GET_CODE (sets[i].inner_dest) == MEM; 7224: if (elt->in_memory) 7225: { 7226: /* This implicitly assumes a whole struct 7227: need not have MEM_IN_STRUCT_P. 7228: But a whole struct is *supposed* to have MEM_IN_STRUCT_P. */ 7229: elt->in_struct = (MEM_IN_STRUCT_P (sets[i].inner_dest) 7230: || sets[i].inner_dest != SET_DEST (sets[i].rtl)); 7231: } 7232: 1.1.1.3 root 7233: /* If we have (set (subreg:m1 (reg:m2 foo) 0) (bar:m1)), M1 is no 7234: narrower than M2, and both M1 and M2 are the same number of words, 7235: we are also doing (set (reg:m2 foo) (subreg:m2 (bar:m1) 0)) so 7236: make that equivalence as well. 1.1 root 7237: 7238: However, BAR may have equivalences for which gen_lowpart_if_possible 7239: will produce a simpler value than gen_lowpart_if_possible applied to 7240: BAR (e.g., if BAR was ZERO_EXTENDed from M2), so we will scan all 7241: BAR's equivalences. If we don't get a simplified form, make 7242: the SUBREG. It will not be used in an equivalence, but will 7243: cause two similar assignments to be detected. 7244: 7245: Note the loop below will find SUBREG_REG (DEST) since we have 7246: already entered SRC and DEST of the SET in the table. */ 7247: 7248: if (GET_CODE (dest) == SUBREG 1.1.1.7 ! root 7249: && (((GET_MODE_SIZE (GET_MODE (SUBREG_REG (dest))) - 1) ! 7250: / UNITS_PER_WORD) ! 7251: == (GET_MODE_SIZE (GET_MODE (dest)) - 1)/ UNITS_PER_WORD) 1.1 root 7252: && (GET_MODE_SIZE (GET_MODE (dest)) 7253: >= GET_MODE_SIZE (GET_MODE (SUBREG_REG (dest)))) 7254: && sets[i].src_elt != 0) 7255: { 7256: enum machine_mode new_mode = GET_MODE (SUBREG_REG (dest)); 7257: struct table_elt *elt, *classp = 0; 7258: 7259: for (elt = sets[i].src_elt->first_same_value; elt; 7260: elt = elt->next_same_value) 7261: { 7262: rtx new_src = 0; 1.1.1.7 ! root 7263: unsigned src_hash; 1.1 root 7264: struct table_elt *src_elt; 7265: 7266: /* Ignore invalid entries. */ 7267: if (GET_CODE (elt->exp) != REG 7268: && ! exp_equiv_p (elt->exp, elt->exp, 1, 0)) 7269: continue; 7270: 7271: new_src = gen_lowpart_if_possible (new_mode, elt->exp); 7272: if (new_src == 0) 7273: new_src = gen_rtx (SUBREG, new_mode, elt->exp, 0); 7274: 7275: src_hash = HASH (new_src, new_mode); 7276: src_elt = lookup (new_src, src_hash, new_mode); 7277: 7278: /* Put the new source in the hash table is if isn't 7279: already. */ 7280: if (src_elt == 0) 7281: { 7282: if (insert_regs (new_src, classp, 0)) 1.1.1.7 ! root 7283: { ! 7284: rehash_using_reg (new_src); ! 7285: src_hash = HASH (new_src, new_mode); ! 7286: } 1.1 root 7287: src_elt = insert (new_src, classp, src_hash, new_mode); 7288: src_elt->in_memory = elt->in_memory; 7289: src_elt->in_struct = elt->in_struct; 7290: } 7291: else if (classp && classp != src_elt->first_same_value) 7292: /* Show that two things that we've seen before are 7293: actually the same. */ 7294: merge_equiv_classes (src_elt, classp); 7295: 7296: classp = src_elt->first_same_value; 7297: } 7298: } 7299: } 7300: 7301: /* Special handling for (set REG0 REG1) 7302: where REG0 is the "cheapest", cheaper than REG1. 7303: After cse, REG1 will probably not be used in the sequel, 7304: so (if easily done) change this insn to (set REG1 REG0) and 7305: replace REG1 with REG0 in the previous insn that computed their value. 7306: Then REG1 will become a dead store and won't cloud the situation 7307: for later optimizations. 7308: 7309: Do not make this change if REG1 is a hard register, because it will 7310: then be used in the sequel and we may be changing a two-operand insn 7311: into a three-operand insn. 7312: 7313: Also do not do this if we are operating on a copy of INSN. */ 7314: 7315: if (n_sets == 1 && sets[0].rtl && GET_CODE (SET_DEST (sets[0].rtl)) == REG 7316: && NEXT_INSN (PREV_INSN (insn)) == insn 7317: && GET_CODE (SET_SRC (sets[0].rtl)) == REG 7318: && REGNO (SET_SRC (sets[0].rtl)) >= FIRST_PSEUDO_REGISTER 7319: && REGNO_QTY_VALID_P (REGNO (SET_SRC (sets[0].rtl))) 7320: && (qty_first_reg[reg_qty[REGNO (SET_SRC (sets[0].rtl))]] 7321: == REGNO (SET_DEST (sets[0].rtl)))) 7322: { 7323: rtx prev = PREV_INSN (insn); 7324: while (prev && GET_CODE (prev) == NOTE) 7325: prev = PREV_INSN (prev); 7326: 7327: if (prev && GET_CODE (prev) == INSN && GET_CODE (PATTERN (prev)) == SET 7328: && SET_DEST (PATTERN (prev)) == SET_SRC (sets[0].rtl)) 7329: { 7330: rtx dest = SET_DEST (sets[0].rtl); 1.1.1.4 root 7331: rtx note = find_reg_note (prev, REG_EQUIV, NULL_RTX); 1.1 root 7332: 7333: validate_change (prev, & SET_DEST (PATTERN (prev)), dest, 1); 7334: validate_change (insn, & SET_DEST (sets[0].rtl), 7335: SET_SRC (sets[0].rtl), 1); 7336: validate_change (insn, & SET_SRC (sets[0].rtl), dest, 1); 7337: apply_change_group (); 7338: 7339: /* If REG1 was equivalent to a constant, REG0 is not. */ 7340: if (note) 7341: PUT_REG_NOTE_KIND (note, REG_EQUAL); 7342: 7343: /* If there was a REG_WAS_0 note on PREV, remove it. Move 7344: any REG_WAS_0 note on INSN to PREV. */ 1.1.1.4 root 7345: note = find_reg_note (prev, REG_WAS_0, NULL_RTX); 1.1 root 7346: if (note) 7347: remove_note (prev, note); 7348: 1.1.1.4 root 7349: note = find_reg_note (insn, REG_WAS_0, NULL_RTX); 1.1 root 7350: if (note) 7351: { 7352: remove_note (insn, note); 7353: XEXP (note, 1) = REG_NOTES (prev); 7354: REG_NOTES (prev) = note; 7355: } 7356: } 7357: } 7358: 7359: /* If this is a conditional jump insn, record any known equivalences due to 7360: the condition being tested. */ 7361: 7362: last_jump_equiv_class = 0; 7363: if (GET_CODE (insn) == JUMP_INSN 7364: && n_sets == 1 && GET_CODE (x) == SET 7365: && GET_CODE (SET_SRC (x)) == IF_THEN_ELSE) 7366: record_jump_equiv (insn, 0); 7367: 7368: #ifdef HAVE_cc0 7369: /* If the previous insn set CC0 and this insn no longer references CC0, 7370: delete the previous insn. Here we use the fact that nothing expects CC0 7371: to be valid over an insn, which is true until the final pass. */ 7372: if (prev_insn && GET_CODE (prev_insn) == INSN 7373: && (tem = single_set (prev_insn)) != 0 7374: && SET_DEST (tem) == cc0_rtx 7375: && ! reg_mentioned_p (cc0_rtx, x)) 7376: { 7377: PUT_CODE (prev_insn, NOTE); 7378: NOTE_LINE_NUMBER (prev_insn) = NOTE_INSN_DELETED; 7379: NOTE_SOURCE_FILE (prev_insn) = 0; 7380: } 7381: 7382: prev_insn_cc0 = this_insn_cc0; 7383: prev_insn_cc0_mode = this_insn_cc0_mode; 7384: #endif 7385: 7386: prev_insn = insn; 7387: } 7388: 7389: /* Store 1 in *WRITES_PTR for those categories of memory ref 7390: that must be invalidated when the expression WRITTEN is stored in. 7391: If WRITTEN is null, say everything must be invalidated. */ 7392: 7393: static void 7394: note_mem_written (written, writes_ptr) 7395: rtx written; 7396: struct write_data *writes_ptr; 7397: { 7398: static struct write_data everything = {0, 1, 1, 1}; 7399: 7400: if (written == 0) 7401: *writes_ptr = everything; 7402: else if (GET_CODE (written) == MEM) 7403: { 7404: /* Pushing or popping the stack invalidates just the stack pointer. */ 7405: rtx addr = XEXP (written, 0); 7406: if ((GET_CODE (addr) == PRE_DEC || GET_CODE (addr) == PRE_INC 7407: || GET_CODE (addr) == POST_DEC || GET_CODE (addr) == POST_INC) 7408: && GET_CODE (XEXP (addr, 0)) == REG 7409: && REGNO (XEXP (addr, 0)) == STACK_POINTER_REGNUM) 7410: { 7411: writes_ptr->sp = 1; 7412: return; 7413: } 7414: else if (GET_MODE (written) == BLKmode) 7415: *writes_ptr = everything; 1.1.1.6 root 7416: /* (mem (scratch)) means clobber everything. */ 7417: else if (GET_CODE (addr) == SCRATCH) 7418: *writes_ptr = everything; 1.1 root 7419: else if (cse_rtx_addr_varies_p (written)) 7420: { 7421: /* A varying address that is a sum indicates an array element, 7422: and that's just as good as a structure element 1.1.1.5 root 7423: in implying that we need not invalidate scalar variables. 7424: However, we must allow QImode aliasing of scalars, because the 7425: ANSI C standard allows character pointers to alias anything. */ 7426: if (! ((MEM_IN_STRUCT_P (written) 7427: || GET_CODE (XEXP (written, 0)) == PLUS) 7428: && GET_MODE (written) != QImode)) 1.1 root 7429: writes_ptr->all = 1; 7430: writes_ptr->nonscalar = 1; 7431: } 7432: writes_ptr->var = 1; 7433: } 7434: } 7435: 7436: /* Perform invalidation on the basis of everything about an insn 7437: except for invalidating the actual places that are SET in it. 7438: This includes the places CLOBBERed, and anything that might 7439: alias with something that is SET or CLOBBERed. 7440: 7441: W points to the writes_memory for this insn, a struct write_data 7442: saying which kinds of memory references must be invalidated. 7443: X is the pattern of the insn. */ 7444: 7445: static void 7446: invalidate_from_clobbers (w, x) 7447: struct write_data *w; 7448: rtx x; 7449: { 7450: /* If W->var is not set, W specifies no action. 7451: If W->all is set, this step gets all memory refs 7452: so they can be ignored in the rest of this function. */ 7453: if (w->var) 7454: invalidate_memory (w); 7455: 7456: if (w->sp) 7457: { 7458: if (reg_tick[STACK_POINTER_REGNUM] >= 0) 7459: reg_tick[STACK_POINTER_REGNUM]++; 7460: 7461: /* This should be *very* rare. */ 7462: if (TEST_HARD_REG_BIT (hard_regs_in_table, STACK_POINTER_REGNUM)) 1.1.1.7 ! root 7463: invalidate (stack_pointer_rtx, VOIDmode); 1.1 root 7464: } 7465: 7466: if (GET_CODE (x) == CLOBBER) 7467: { 7468: rtx ref = XEXP (x, 0); 1.1.1.6 root 7469: if (ref) 7470: { 7471: if (GET_CODE (ref) == REG || GET_CODE (ref) == SUBREG 7472: || (GET_CODE (ref) == MEM && ! w->all)) 1.1.1.7 ! root 7473: invalidate (ref, VOIDmode); 1.1.1.6 root 7474: else if (GET_CODE (ref) == STRICT_LOW_PART 7475: || GET_CODE (ref) == ZERO_EXTRACT) 1.1.1.7 ! root 7476: invalidate (XEXP (ref, 0), GET_MODE (ref)); 1.1.1.6 root 7477: } 1.1 root 7478: } 7479: else if (GET_CODE (x) == PARALLEL) 7480: { 7481: register int i; 7482: for (i = XVECLEN (x, 0) - 1; i >= 0; i--) 7483: { 7484: register rtx y = XVECEXP (x, 0, i); 7485: if (GET_CODE (y) == CLOBBER) 7486: { 7487: rtx ref = XEXP (y, 0); 1.1.1.6 root 7488: if (ref) 7489: { 7490: if (GET_CODE (ref) == REG || GET_CODE (ref) == SUBREG 7491: || (GET_CODE (ref) == MEM && !w->all)) 1.1.1.7 ! root 7492: invalidate (ref, VOIDmode); 1.1.1.6 root 7493: else if (GET_CODE (ref) == STRICT_LOW_PART 7494: || GET_CODE (ref) == ZERO_EXTRACT) 1.1.1.7 ! root 7495: invalidate (XEXP (ref, 0), GET_MODE (ref)); 1.1.1.6 root 7496: } 1.1 root 7497: } 7498: } 7499: } 7500: } 7501: 7502: /* Process X, part of the REG_NOTES of an insn. Look at any REG_EQUAL notes 7503: and replace any registers in them with either an equivalent constant 7504: or the canonical form of the register. If we are inside an address, 7505: only do this if the address remains valid. 7506: 7507: OBJECT is 0 except when within a MEM in which case it is the MEM. 7508: 7509: Return the replacement for X. */ 7510: 7511: static rtx 7512: cse_process_notes (x, object) 7513: rtx x; 7514: rtx object; 7515: { 7516: enum rtx_code code = GET_CODE (x); 7517: char *fmt = GET_RTX_FORMAT (code); 7518: int i; 7519: 7520: switch (code) 7521: { 7522: case CONST_INT: 7523: case CONST: 7524: case SYMBOL_REF: 7525: case LABEL_REF: 7526: case CONST_DOUBLE: 7527: case PC: 7528: case CC0: 7529: case LO_SUM: 7530: return x; 7531: 7532: case MEM: 7533: XEXP (x, 0) = cse_process_notes (XEXP (x, 0), x); 7534: return x; 7535: 7536: case EXPR_LIST: 7537: case INSN_LIST: 7538: if (REG_NOTE_KIND (x) == REG_EQUAL) 1.1.1.4 root 7539: XEXP (x, 0) = cse_process_notes (XEXP (x, 0), NULL_RTX); 1.1 root 7540: if (XEXP (x, 1)) 1.1.1.4 root 7541: XEXP (x, 1) = cse_process_notes (XEXP (x, 1), NULL_RTX); 1.1 root 7542: return x; 7543: 1.1.1.3 root 7544: case SIGN_EXTEND: 7545: case ZERO_EXTEND: 7546: { 7547: rtx new = cse_process_notes (XEXP (x, 0), object); 7548: /* We don't substitute VOIDmode constants into these rtx, 7549: since they would impede folding. */ 7550: if (GET_MODE (new) != VOIDmode) 7551: validate_change (object, &XEXP (x, 0), new, 0); 7552: return x; 7553: } 7554: 1.1 root 7555: case REG: 7556: i = reg_qty[REGNO (x)]; 7557: 7558: /* Return a constant or a constant register. */ 7559: if (REGNO_QTY_VALID_P (REGNO (x)) 7560: && qty_const[i] != 0 7561: && (CONSTANT_P (qty_const[i]) 7562: || GET_CODE (qty_const[i]) == REG)) 7563: { 7564: rtx new = gen_lowpart_if_possible (GET_MODE (x), qty_const[i]); 7565: if (new) 7566: return new; 7567: } 7568: 7569: /* Otherwise, canonicalize this register. */ 1.1.1.4 root 7570: return canon_reg (x, NULL_RTX); 1.1 root 7571: } 7572: 7573: for (i = 0; i < GET_RTX_LENGTH (code); i++) 7574: if (fmt[i] == 'e') 7575: validate_change (object, &XEXP (x, i), 1.1.1.5 root 7576: cse_process_notes (XEXP (x, i), object), 0); 1.1 root 7577: 7578: return x; 7579: } 7580: 7581: /* Find common subexpressions between the end test of a loop and the beginning 7582: of the loop. LOOP_START is the CODE_LABEL at the start of a loop. 7583: 7584: Often we have a loop where an expression in the exit test is used 7585: in the body of the loop. For example "while (*p) *q++ = *p++;". 7586: Because of the way we duplicate the loop exit test in front of the loop, 7587: however, we don't detect that common subexpression. This will be caught 7588: when global cse is implemented, but this is a quite common case. 7589: 7590: This function handles the most common cases of these common expressions. 7591: It is called after we have processed the basic block ending with the 7592: NOTE_INSN_LOOP_END note that ends a loop and the previous JUMP_INSN 7593: jumps to a label used only once. */ 7594: 7595: static void 7596: cse_around_loop (loop_start) 7597: rtx loop_start; 7598: { 7599: rtx insn; 7600: int i; 7601: struct table_elt *p; 7602: 7603: /* If the jump at the end of the loop doesn't go to the start, we don't 7604: do anything. */ 7605: for (insn = PREV_INSN (loop_start); 7606: insn && (GET_CODE (insn) == NOTE && NOTE_LINE_NUMBER (insn) >= 0); 7607: insn = PREV_INSN (insn)) 7608: ; 7609: 7610: if (insn == 0 7611: || GET_CODE (insn) != NOTE 7612: || NOTE_LINE_NUMBER (insn) != NOTE_INSN_LOOP_BEG) 7613: return; 7614: 7615: /* If the last insn of the loop (the end test) was an NE comparison, 7616: we will interpret it as an EQ comparison, since we fell through 1.1.1.4 root 7617: the loop. Any equivalences resulting from that comparison are 1.1 root 7618: therefore not valid and must be invalidated. */ 7619: if (last_jump_equiv_class) 7620: for (p = last_jump_equiv_class->first_same_value; p; 7621: p = p->next_same_value) 7622: if (GET_CODE (p->exp) == MEM || GET_CODE (p->exp) == REG 1.1.1.7 ! root 7623: || (GET_CODE (p->exp) == SUBREG ! 7624: && GET_CODE (SUBREG_REG (p->exp)) == REG)) ! 7625: invalidate (p->exp, VOIDmode); 1.1.1.6 root 7626: else if (GET_CODE (p->exp) == STRICT_LOW_PART 7627: || GET_CODE (p->exp) == ZERO_EXTRACT) 1.1.1.7 ! root 7628: invalidate (XEXP (p->exp, 0), GET_MODE (p->exp)); 1.1 root 7629: 7630: /* Process insns starting after LOOP_START until we hit a CALL_INSN or 7631: a CODE_LABEL (we could handle a CALL_INSN, but it isn't worth it). 7632: 7633: The only thing we do with SET_DEST is invalidate entries, so we 7634: can safely process each SET in order. It is slightly less efficient 7635: to do so, but we only want to handle the most common cases. */ 7636: 7637: for (insn = NEXT_INSN (loop_start); 7638: GET_CODE (insn) != CALL_INSN && GET_CODE (insn) != CODE_LABEL 7639: && ! (GET_CODE (insn) == NOTE 7640: && NOTE_LINE_NUMBER (insn) == NOTE_INSN_LOOP_END); 7641: insn = NEXT_INSN (insn)) 7642: { 7643: if (GET_RTX_CLASS (GET_CODE (insn)) == 'i' 7644: && (GET_CODE (PATTERN (insn)) == SET 7645: || GET_CODE (PATTERN (insn)) == CLOBBER)) 7646: cse_set_around_loop (PATTERN (insn), insn, loop_start); 7647: else if (GET_RTX_CLASS (GET_CODE (insn)) == 'i' 7648: && GET_CODE (PATTERN (insn)) == PARALLEL) 7649: for (i = XVECLEN (PATTERN (insn), 0) - 1; i >= 0; i--) 7650: if (GET_CODE (XVECEXP (PATTERN (insn), 0, i)) == SET 7651: || GET_CODE (XVECEXP (PATTERN (insn), 0, i)) == CLOBBER) 7652: cse_set_around_loop (XVECEXP (PATTERN (insn), 0, i), insn, 7653: loop_start); 7654: } 7655: } 7656: 1.1.1.3 root 7657: /* Variable used for communications between the next two routines. */ 7658: 7659: static struct write_data skipped_writes_memory; 7660: 7661: /* Process one SET of an insn that was skipped. We ignore CLOBBERs 7662: since they are done elsewhere. This function is called via note_stores. */ 7663: 7664: static void 7665: invalidate_skipped_set (dest, set) 7666: rtx set; 7667: rtx dest; 7668: { 7669: if (GET_CODE (set) == CLOBBER 7670: #ifdef HAVE_cc0 7671: || dest == cc0_rtx 7672: #endif 7673: || dest == pc_rtx) 7674: return; 7675: 7676: if (GET_CODE (dest) == MEM) 7677: note_mem_written (dest, &skipped_writes_memory); 7678: 1.1.1.5 root 7679: /* There are times when an address can appear varying and be a PLUS 7680: during this scan when it would be a fixed address were we to know 7681: the proper equivalences. So promote "nonscalar" to be "all". */ 7682: if (skipped_writes_memory.nonscalar) 7683: skipped_writes_memory.all = 1; 7684: 1.1.1.3 root 7685: if (GET_CODE (dest) == REG || GET_CODE (dest) == SUBREG 7686: || (! skipped_writes_memory.all && ! cse_rtx_addr_varies_p (dest))) 1.1.1.7 ! root 7687: invalidate (dest, VOIDmode); 1.1.1.6 root 7688: else if (GET_CODE (dest) == STRICT_LOW_PART 7689: || GET_CODE (dest) == ZERO_EXTRACT) 1.1.1.7 ! root 7690: invalidate (XEXP (dest, 0), GET_MODE (dest)); 1.1.1.3 root 7691: } 7692: 7693: /* Invalidate all insns from START up to the end of the function or the 7694: next label. This called when we wish to CSE around a block that is 7695: conditionally executed. */ 7696: 7697: static void 7698: invalidate_skipped_block (start) 7699: rtx start; 7700: { 7701: rtx insn; 7702: static struct write_data init = {0, 0, 0, 0}; 7703: static struct write_data everything = {0, 1, 1, 1}; 7704: 7705: for (insn = start; insn && GET_CODE (insn) != CODE_LABEL; 7706: insn = NEXT_INSN (insn)) 7707: { 7708: if (GET_RTX_CLASS (GET_CODE (insn)) != 'i') 7709: continue; 7710: 7711: skipped_writes_memory = init; 7712: 7713: if (GET_CODE (insn) == CALL_INSN) 7714: { 7715: invalidate_for_call (); 7716: skipped_writes_memory = everything; 7717: } 7718: 7719: note_stores (PATTERN (insn), invalidate_skipped_set); 7720: invalidate_from_clobbers (&skipped_writes_memory, PATTERN (insn)); 7721: } 7722: } 7723: 1.1 root 7724: /* Used for communication between the following two routines; contains a 7725: value to be checked for modification. */ 7726: 7727: static rtx cse_check_loop_start_value; 7728: 7729: /* If modifying X will modify the value in CSE_CHECK_LOOP_START_VALUE, 7730: indicate that fact by setting CSE_CHECK_LOOP_START_VALUE to 0. */ 7731: 7732: static void 7733: cse_check_loop_start (x, set) 7734: rtx x; 7735: rtx set; 7736: { 7737: if (cse_check_loop_start_value == 0 7738: || GET_CODE (x) == CC0 || GET_CODE (x) == PC) 7739: return; 7740: 7741: if ((GET_CODE (x) == MEM && GET_CODE (cse_check_loop_start_value) == MEM) 7742: || reg_overlap_mentioned_p (x, cse_check_loop_start_value)) 7743: cse_check_loop_start_value = 0; 7744: } 7745: 7746: /* X is a SET or CLOBBER contained in INSN that was found near the start of 7747: a loop that starts with the label at LOOP_START. 7748: 7749: If X is a SET, we see if its SET_SRC is currently in our hash table. 7750: If so, we see if it has a value equal to some register used only in the 7751: loop exit code (as marked by jump.c). 7752: 7753: If those two conditions are true, we search backwards from the start of 7754: the loop to see if that same value was loaded into a register that still 7755: retains its value at the start of the loop. 7756: 7757: If so, we insert an insn after the load to copy the destination of that 7758: load into the equivalent register and (try to) replace our SET_SRC with that 7759: register. 7760: 7761: In any event, we invalidate whatever this SET or CLOBBER modifies. */ 7762: 7763: static void 7764: cse_set_around_loop (x, insn, loop_start) 7765: rtx x; 7766: rtx insn; 7767: rtx loop_start; 7768: { 7769: struct table_elt *src_elt; 7770: static struct write_data init = {0, 0, 0, 0}; 7771: struct write_data writes_memory; 7772: 7773: writes_memory = init; 7774: 7775: /* If this is a SET, see if we can replace SET_SRC, but ignore SETs that 7776: are setting PC or CC0 or whose SET_SRC is already a register. */ 7777: if (GET_CODE (x) == SET 7778: && GET_CODE (SET_DEST (x)) != PC && GET_CODE (SET_DEST (x)) != CC0 7779: && GET_CODE (SET_SRC (x)) != REG) 7780: { 7781: src_elt = lookup (SET_SRC (x), 7782: HASH (SET_SRC (x), GET_MODE (SET_DEST (x))), 7783: GET_MODE (SET_DEST (x))); 7784: 7785: if (src_elt) 7786: for (src_elt = src_elt->first_same_value; src_elt; 7787: src_elt = src_elt->next_same_value) 7788: if (GET_CODE (src_elt->exp) == REG && REG_LOOP_TEST_P (src_elt->exp) 7789: && COST (src_elt->exp) < COST (SET_SRC (x))) 7790: { 7791: rtx p, set; 7792: 7793: /* Look for an insn in front of LOOP_START that sets 7794: something in the desired mode to SET_SRC (x) before we hit 7795: a label or CALL_INSN. */ 7796: 7797: for (p = prev_nonnote_insn (loop_start); 7798: p && GET_CODE (p) != CALL_INSN 7799: && GET_CODE (p) != CODE_LABEL; 7800: p = prev_nonnote_insn (p)) 7801: if ((set = single_set (p)) != 0 7802: && GET_CODE (SET_DEST (set)) == REG 7803: && GET_MODE (SET_DEST (set)) == src_elt->mode 7804: && rtx_equal_p (SET_SRC (set), SET_SRC (x))) 7805: { 7806: /* We now have to ensure that nothing between P 7807: and LOOP_START modified anything referenced in 7808: SET_SRC (x). We know that nothing within the loop 7809: can modify it, or we would have invalidated it in 7810: the hash table. */ 7811: rtx q; 7812: 7813: cse_check_loop_start_value = SET_SRC (x); 7814: for (q = p; q != loop_start; q = NEXT_INSN (q)) 7815: if (GET_RTX_CLASS (GET_CODE (q)) == 'i') 7816: note_stores (PATTERN (q), cse_check_loop_start); 7817: 7818: /* If nothing was changed and we can replace our 7819: SET_SRC, add an insn after P to copy its destination 7820: to what we will be replacing SET_SRC with. */ 7821: if (cse_check_loop_start_value 7822: && validate_change (insn, &SET_SRC (x), 7823: src_elt->exp, 0)) 7824: emit_insn_after (gen_move_insn (src_elt->exp, 7825: SET_DEST (set)), 7826: p); 7827: break; 7828: } 7829: } 7830: } 7831: 7832: /* Now invalidate anything modified by X. */ 7833: note_mem_written (SET_DEST (x), &writes_memory); 7834: 7835: if (writes_memory.var) 7836: invalidate_memory (&writes_memory); 7837: 7838: /* See comment on similar code in cse_insn for explanation of these tests. */ 7839: if (GET_CODE (SET_DEST (x)) == REG || GET_CODE (SET_DEST (x)) == SUBREG 7840: || (GET_CODE (SET_DEST (x)) == MEM && ! writes_memory.all 7841: && ! cse_rtx_addr_varies_p (SET_DEST (x)))) 1.1.1.7 ! root 7842: invalidate (SET_DEST (x), VOIDmode); 1.1.1.6 root 7843: else if (GET_CODE (SET_DEST (x)) == STRICT_LOW_PART 7844: || GET_CODE (SET_DEST (x)) == ZERO_EXTRACT) 1.1.1.7 ! root 7845: invalidate (XEXP (SET_DEST (x), 0), GET_MODE (SET_DEST (x))); 1.1 root 7846: } 7847: 7848: /* Find the end of INSN's basic block and return its range, 7849: the total number of SETs in all the insns of the block, the last insn of the 7850: block, and the branch path. 7851: 7852: The branch path indicates which branches should be followed. If a non-zero 7853: path size is specified, the block should be rescanned and a different set 7854: of branches will be taken. The branch path is only used if 1.1.1.3 root 7855: FLAG_CSE_FOLLOW_JUMPS or FLAG_CSE_SKIP_BLOCKS is non-zero. 1.1 root 7856: 7857: DATA is a pointer to a struct cse_basic_block_data, defined below, that is 7858: used to describe the block. It is filled in with the information about 7859: the current block. The incoming structure's branch path, if any, is used 7860: to construct the output branch path. */ 7861: 7862: void 1.1.1.3 root 7863: cse_end_of_basic_block (insn, data, follow_jumps, after_loop, skip_blocks) 1.1 root 7864: rtx insn; 7865: struct cse_basic_block_data *data; 7866: int follow_jumps; 7867: int after_loop; 1.1.1.3 root 7868: int skip_blocks; 1.1 root 7869: { 7870: rtx p = insn, q; 7871: int nsets = 0; 7872: int low_cuid = INSN_CUID (insn), high_cuid = INSN_CUID (insn); 1.1.1.3 root 7873: rtx next = GET_RTX_CLASS (GET_CODE (insn)) == 'i' ? insn : next_real_insn (insn); 1.1 root 7874: int path_size = data->path_size; 7875: int path_entry = 0; 7876: int i; 7877: 7878: /* Update the previous branch path, if any. If the last branch was 7879: previously TAKEN, mark it NOT_TAKEN. If it was previously NOT_TAKEN, 7880: shorten the path by one and look at the previous branch. We know that 7881: at least one branch must have been taken if PATH_SIZE is non-zero. */ 7882: while (path_size > 0) 7883: { 1.1.1.3 root 7884: if (data->path[path_size - 1].status != NOT_TAKEN) 1.1 root 7885: { 7886: data->path[path_size - 1].status = NOT_TAKEN; 7887: break; 7888: } 7889: else 7890: path_size--; 7891: } 7892: 7893: /* Scan to end of this basic block. */ 7894: while (p && GET_CODE (p) != CODE_LABEL) 7895: { 7896: /* Don't cse out the end of a loop. This makes a difference 7897: only for the unusual loops that always execute at least once; 7898: all other loops have labels there so we will stop in any case. 7899: Cse'ing out the end of the loop is dangerous because it 7900: might cause an invariant expression inside the loop 7901: to be reused after the end of the loop. This would make it 7902: hard to move the expression out of the loop in loop.c, 7903: especially if it is one of several equivalent expressions 7904: and loop.c would like to eliminate it. 7905: 7906: If we are running after loop.c has finished, we can ignore 7907: the NOTE_INSN_LOOP_END. */ 7908: 7909: if (! after_loop && GET_CODE (p) == NOTE 7910: && NOTE_LINE_NUMBER (p) == NOTE_INSN_LOOP_END) 7911: break; 7912: 7913: /* Don't cse over a call to setjmp; on some machines (eg vax) 7914: the regs restored by the longjmp come from 7915: a later time than the setjmp. */ 7916: if (GET_CODE (p) == NOTE 7917: && NOTE_LINE_NUMBER (p) == NOTE_INSN_SETJMP) 7918: break; 7919: 7920: /* A PARALLEL can have lots of SETs in it, 7921: especially if it is really an ASM_OPERANDS. */ 7922: if (GET_RTX_CLASS (GET_CODE (p)) == 'i' 7923: && GET_CODE (PATTERN (p)) == PARALLEL) 7924: nsets += XVECLEN (PATTERN (p), 0); 7925: else if (GET_CODE (p) != NOTE) 7926: nsets += 1; 7927: 1.1.1.4 root 7928: /* Ignore insns made by CSE; they cannot affect the boundaries of 7929: the basic block. */ 7930: 7931: if (INSN_UID (p) <= max_uid && INSN_CUID (p) > high_cuid) 1.1.1.3 root 7932: high_cuid = INSN_CUID (p); 1.1.1.4 root 7933: if (INSN_UID (p) <= max_uid && INSN_CUID (p) < low_cuid) 7934: low_cuid = INSN_CUID (p); 1.1 root 7935: 7936: /* See if this insn is in our branch path. If it is and we are to 7937: take it, do so. */ 7938: if (path_entry < path_size && data->path[path_entry].branch == p) 7939: { 1.1.1.3 root 7940: if (data->path[path_entry].status != NOT_TAKEN) 1.1 root 7941: p = JUMP_LABEL (p); 7942: 7943: /* Point to next entry in path, if any. */ 7944: path_entry++; 7945: } 7946: 7947: /* If this is a conditional jump, we can follow it if -fcse-follow-jumps 7948: was specified, we haven't reached our maximum path length, there are 7949: insns following the target of the jump, this is the only use of the 1.1.1.3 root 7950: jump label, and the target label is preceded by a BARRIER. 7951: 7952: Alternatively, we can follow the jump if it branches around a 7953: block of code and there are no other branches into the block. 7954: In this case invalidate_skipped_block will be called to invalidate any 7955: registers set in the block when following the jump. */ 7956: 7957: else if ((follow_jumps || skip_blocks) && path_size < PATHLENGTH - 1 1.1 root 7958: && GET_CODE (p) == JUMP_INSN 7959: && GET_CODE (PATTERN (p)) == SET 7960: && GET_CODE (SET_SRC (PATTERN (p))) == IF_THEN_ELSE 7961: && LABEL_NUSES (JUMP_LABEL (p)) == 1 7962: && NEXT_INSN (JUMP_LABEL (p)) != 0) 7963: { 7964: for (q = PREV_INSN (JUMP_LABEL (p)); q; q = PREV_INSN (q)) 7965: if ((GET_CODE (q) != NOTE 7966: || NOTE_LINE_NUMBER (q) == NOTE_INSN_LOOP_END 7967: || NOTE_LINE_NUMBER (q) == NOTE_INSN_SETJMP) 7968: && (GET_CODE (q) != CODE_LABEL || LABEL_NUSES (q) != 0)) 7969: break; 7970: 7971: /* If we ran into a BARRIER, this code is an extension of the 7972: basic block when the branch is taken. */ 1.1.1.3 root 7973: if (follow_jumps && q != 0 && GET_CODE (q) == BARRIER) 1.1 root 7974: { 7975: /* Don't allow ourself to keep walking around an 7976: always-executed loop. */ 1.1.1.3 root 7977: if (next_real_insn (q) == next) 7978: { 7979: p = NEXT_INSN (p); 7980: continue; 7981: } 1.1 root 7982: 7983: /* Similarly, don't put a branch in our path more than once. */ 7984: for (i = 0; i < path_entry; i++) 7985: if (data->path[i].branch == p) 7986: break; 7987: 7988: if (i != path_entry) 7989: break; 7990: 7991: data->path[path_entry].branch = p; 7992: data->path[path_entry++].status = TAKEN; 7993: 7994: /* This branch now ends our path. It was possible that we 7995: didn't see this branch the last time around (when the 7996: insn in front of the target was a JUMP_INSN that was 7997: turned into a no-op). */ 7998: path_size = path_entry; 7999: 8000: p = JUMP_LABEL (p); 8001: /* Mark block so we won't scan it again later. */ 8002: PUT_MODE (NEXT_INSN (p), QImode); 8003: } 1.1.1.3 root 8004: /* Detect a branch around a block of code. */ 8005: else if (skip_blocks && q != 0 && GET_CODE (q) != CODE_LABEL) 8006: { 8007: register rtx tmp; 8008: 8009: if (next_real_insn (q) == next) 8010: { 8011: p = NEXT_INSN (p); 8012: continue; 8013: } 8014: 8015: for (i = 0; i < path_entry; i++) 8016: if (data->path[i].branch == p) 8017: break; 8018: 8019: if (i != path_entry) 8020: break; 8021: 8022: /* This is no_labels_between_p (p, q) with an added check for 8023: reaching the end of a function (in case Q precedes P). */ 8024: for (tmp = NEXT_INSN (p); tmp && tmp != q; tmp = NEXT_INSN (tmp)) 8025: if (GET_CODE (tmp) == CODE_LABEL) 8026: break; 8027: 8028: if (tmp == q) 8029: { 8030: data->path[path_entry].branch = p; 8031: data->path[path_entry++].status = AROUND; 8032: 8033: path_size = path_entry; 8034: 8035: p = JUMP_LABEL (p); 8036: /* Mark block so we won't scan it again later. */ 8037: PUT_MODE (NEXT_INSN (p), QImode); 8038: } 8039: } 1.1 root 8040: } 8041: p = NEXT_INSN (p); 8042: } 8043: 8044: data->low_cuid = low_cuid; 8045: data->high_cuid = high_cuid; 8046: data->nsets = nsets; 8047: data->last = p; 8048: 8049: /* If all jumps in the path are not taken, set our path length to zero 8050: so a rescan won't be done. */ 8051: for (i = path_size - 1; i >= 0; i--) 1.1.1.3 root 8052: if (data->path[i].status != NOT_TAKEN) 1.1 root 8053: break; 8054: 8055: if (i == -1) 8056: data->path_size = 0; 8057: else 8058: data->path_size = path_size; 8059: 8060: /* End the current branch path. */ 8061: data->path[path_size].branch = 0; 8062: } 8063: 8064: /* Perform cse on the instructions of a function. 8065: F is the first instruction. 8066: NREGS is one plus the highest pseudo-reg number used in the instruction. 8067: 8068: AFTER_LOOP is 1 if this is the cse call done after loop optimization 8069: (only if -frerun-cse-after-loop). 8070: 8071: Returns 1 if jump_optimize should be redone due to simplifications 8072: in conditional jump instructions. */ 8073: 8074: int 8075: cse_main (f, nregs, after_loop, file) 8076: rtx f; 8077: int nregs; 8078: int after_loop; 8079: FILE *file; 8080: { 8081: struct cse_basic_block_data val; 8082: register rtx insn = f; 8083: register int i; 8084: 8085: cse_jumps_altered = 0; 8086: constant_pool_entries_cost = 0; 8087: val.path_size = 0; 8088: 8089: init_recog (); 8090: 8091: max_reg = nregs; 8092: 8093: all_minus_one = (int *) alloca (nregs * sizeof (int)); 8094: consec_ints = (int *) alloca (nregs * sizeof (int)); 8095: 8096: for (i = 0; i < nregs; i++) 8097: { 8098: all_minus_one[i] = -1; 8099: consec_ints[i] = i; 8100: } 8101: 8102: reg_next_eqv = (int *) alloca (nregs * sizeof (int)); 8103: reg_prev_eqv = (int *) alloca (nregs * sizeof (int)); 8104: reg_qty = (int *) alloca (nregs * sizeof (int)); 8105: reg_in_table = (int *) alloca (nregs * sizeof (int)); 8106: reg_tick = (int *) alloca (nregs * sizeof (int)); 8107: 1.1.1.7 ! root 8108: #ifdef LOAD_EXTEND_OP ! 8109: ! 8110: /* Allocate scratch rtl here. cse_insn will fill in the memory reference ! 8111: and change the code and mode as appropriate. */ ! 8112: memory_extend_rtx = gen_rtx (ZERO_EXTEND, VOIDmode, 0); ! 8113: #endif ! 8114: 1.1 root 8115: /* Discard all the free elements of the previous function 8116: since they are allocated in the temporarily obstack. */ 1.1.1.7 ! root 8117: bzero ((char *) table, sizeof table); 1.1 root 8118: free_element_chain = 0; 8119: n_elements_made = 0; 8120: 8121: /* Find the largest uid. */ 8122: 1.1.1.4 root 8123: max_uid = get_max_uid (); 8124: uid_cuid = (int *) alloca ((max_uid + 1) * sizeof (int)); 1.1.1.7 ! root 8125: bzero ((char *) uid_cuid, (max_uid + 1) * sizeof (int)); 1.1 root 8126: 8127: /* Compute the mapping from uids to cuids. 8128: CUIDs are numbers assigned to insns, like uids, 8129: except that cuids increase monotonically through the code. 8130: Don't assign cuids to line-number NOTEs, so that the distance in cuids 8131: between two insns is not affected by -g. */ 8132: 8133: for (insn = f, i = 0; insn; insn = NEXT_INSN (insn)) 8134: { 8135: if (GET_CODE (insn) != NOTE 8136: || NOTE_LINE_NUMBER (insn) < 0) 8137: INSN_CUID (insn) = ++i; 8138: else 8139: /* Give a line number note the same cuid as preceding insn. */ 8140: INSN_CUID (insn) = i; 8141: } 8142: 8143: /* Initialize which registers are clobbered by calls. */ 8144: 8145: CLEAR_HARD_REG_SET (regs_invalidated_by_call); 8146: 8147: for (i = 0; i < FIRST_PSEUDO_REGISTER; i++) 8148: if ((call_used_regs[i] 8149: /* Used to check !fixed_regs[i] here, but that isn't safe; 8150: fixed regs are still call-clobbered, and sched can get 8151: confused if they can "live across calls". 8152: 8153: The frame pointer is always preserved across calls. The arg 8154: pointer is if it is fixed. The stack pointer usually is, unless 8155: RETURN_POPS_ARGS, in which case an explicit CLOBBER 8156: will be present. If we are generating PIC code, the PIC offset 8157: table register is preserved across calls. */ 8158: 8159: && i != STACK_POINTER_REGNUM 8160: && i != FRAME_POINTER_REGNUM 1.1.1.6 root 8161: #if HARD_FRAME_POINTER_REGNUM != FRAME_POINTER_REGNUM 8162: && i != HARD_FRAME_POINTER_REGNUM 8163: #endif 1.1 root 8164: #if ARG_POINTER_REGNUM != FRAME_POINTER_REGNUM 8165: && ! (i == ARG_POINTER_REGNUM && fixed_regs[i]) 8166: #endif 1.1.1.7 ! root 8167: #if defined (PIC_OFFSET_TABLE_REGNUM) && !defined (PIC_OFFSET_TABLE_REG_CALL_CLOBBERED) 1.1 root 8168: && ! (i == PIC_OFFSET_TABLE_REGNUM && flag_pic) 8169: #endif 8170: ) 8171: || global_regs[i]) 8172: SET_HARD_REG_BIT (regs_invalidated_by_call, i); 8173: 8174: /* Loop over basic blocks. 8175: Compute the maximum number of qty's needed for each basic block 8176: (which is 2 for each SET). */ 8177: insn = f; 8178: while (insn) 8179: { 1.1.1.3 root 8180: cse_end_of_basic_block (insn, &val, flag_cse_follow_jumps, after_loop, 8181: flag_cse_skip_blocks); 1.1 root 8182: 8183: /* If this basic block was already processed or has no sets, skip it. */ 8184: if (val.nsets == 0 || GET_MODE (insn) == QImode) 8185: { 8186: PUT_MODE (insn, VOIDmode); 8187: insn = (val.last ? NEXT_INSN (val.last) : 0); 8188: val.path_size = 0; 8189: continue; 8190: } 8191: 8192: cse_basic_block_start = val.low_cuid; 8193: cse_basic_block_end = val.high_cuid; 8194: max_qty = val.nsets * 2; 8195: 8196: if (file) 8197: fprintf (file, ";; Processing block from %d to %d, %d sets.\n", 8198: INSN_UID (insn), val.last ? INSN_UID (val.last) : 0, 8199: val.nsets); 8200: 8201: /* Make MAX_QTY bigger to give us room to optimize 8202: past the end of this basic block, if that should prove useful. */ 8203: if (max_qty < 500) 8204: max_qty = 500; 8205: 8206: max_qty += max_reg; 8207: 8208: /* If this basic block is being extended by following certain jumps, 8209: (see `cse_end_of_basic_block'), we reprocess the code from the start. 8210: Otherwise, we start after this basic block. */ 8211: if (val.path_size > 0) 8212: cse_basic_block (insn, val.last, val.path, 0); 8213: else 8214: { 8215: int old_cse_jumps_altered = cse_jumps_altered; 8216: rtx temp; 8217: 8218: /* When cse changes a conditional jump to an unconditional 8219: jump, we want to reprocess the block, since it will give 8220: us a new branch path to investigate. */ 8221: cse_jumps_altered = 0; 8222: temp = cse_basic_block (insn, val.last, val.path, ! after_loop); 1.1.1.3 root 8223: if (cse_jumps_altered == 0 8224: || (flag_cse_follow_jumps == 0 && flag_cse_skip_blocks == 0)) 1.1 root 8225: insn = temp; 8226: 8227: cse_jumps_altered |= old_cse_jumps_altered; 8228: } 8229: 8230: #ifdef USE_C_ALLOCA 8231: alloca (0); 8232: #endif 8233: } 8234: 8235: /* Tell refers_to_mem_p that qty_const info is not available. */ 8236: qty_const = 0; 8237: 8238: if (max_elements_made < n_elements_made) 8239: max_elements_made = n_elements_made; 8240: 8241: return cse_jumps_altered; 8242: } 8243: 8244: /* Process a single basic block. FROM and TO and the limits of the basic 8245: block. NEXT_BRANCH points to the branch path when following jumps or 8246: a null path when not following jumps. 8247: 8248: AROUND_LOOP is non-zero if we are to try to cse around to the start of a 8249: loop. This is true when we are being called for the last time on a 8250: block and this CSE pass is before loop.c. */ 8251: 8252: static rtx 8253: cse_basic_block (from, to, next_branch, around_loop) 8254: register rtx from, to; 8255: struct branch_path *next_branch; 8256: int around_loop; 8257: { 8258: register rtx insn; 8259: int to_usage = 0; 8260: int in_libcall_block = 0; 8261: 8262: /* Each of these arrays is undefined before max_reg, so only allocate 8263: the space actually needed and adjust the start below. */ 8264: 8265: qty_first_reg = (int *) alloca ((max_qty - max_reg) * sizeof (int)); 8266: qty_last_reg = (int *) alloca ((max_qty - max_reg) * sizeof (int)); 8267: qty_mode= (enum machine_mode *) alloca ((max_qty - max_reg) * sizeof (enum machine_mode)); 8268: qty_const = (rtx *) alloca ((max_qty - max_reg) * sizeof (rtx)); 8269: qty_const_insn = (rtx *) alloca ((max_qty - max_reg) * sizeof (rtx)); 8270: qty_comparison_code 8271: = (enum rtx_code *) alloca ((max_qty - max_reg) * sizeof (enum rtx_code)); 8272: qty_comparison_qty = (int *) alloca ((max_qty - max_reg) * sizeof (int)); 8273: qty_comparison_const = (rtx *) alloca ((max_qty - max_reg) * sizeof (rtx)); 8274: 8275: qty_first_reg -= max_reg; 8276: qty_last_reg -= max_reg; 8277: qty_mode -= max_reg; 8278: qty_const -= max_reg; 8279: qty_const_insn -= max_reg; 8280: qty_comparison_code -= max_reg; 8281: qty_comparison_qty -= max_reg; 8282: qty_comparison_const -= max_reg; 8283: 8284: new_basic_block (); 8285: 8286: /* TO might be a label. If so, protect it from being deleted. */ 8287: if (to != 0 && GET_CODE (to) == CODE_LABEL) 8288: ++LABEL_NUSES (to); 8289: 8290: for (insn = from; insn != to; insn = NEXT_INSN (insn)) 8291: { 8292: register enum rtx_code code; 8293: 8294: /* See if this is a branch that is part of the path. If so, and it is 8295: to be taken, do so. */ 8296: if (next_branch->branch == insn) 8297: { 1.1.1.3 root 8298: enum taken status = next_branch++->status; 8299: if (status != NOT_TAKEN) 1.1 root 8300: { 1.1.1.3 root 8301: if (status == TAKEN) 8302: record_jump_equiv (insn, 1); 8303: else 8304: invalidate_skipped_block (NEXT_INSN (insn)); 8305: 1.1 root 8306: /* Set the last insn as the jump insn; it doesn't affect cc0. 8307: Then follow this branch. */ 8308: #ifdef HAVE_cc0 8309: prev_insn_cc0 = 0; 8310: #endif 8311: prev_insn = insn; 8312: insn = JUMP_LABEL (insn); 8313: continue; 8314: } 8315: } 8316: 8317: code = GET_CODE (insn); 8318: if (GET_MODE (insn) == QImode) 8319: PUT_MODE (insn, VOIDmode); 8320: 8321: if (GET_RTX_CLASS (code) == 'i') 8322: { 8323: /* Process notes first so we have all notes in canonical forms when 8324: looking for duplicate operations. */ 8325: 8326: if (REG_NOTES (insn)) 1.1.1.4 root 8327: REG_NOTES (insn) = cse_process_notes (REG_NOTES (insn), NULL_RTX); 1.1 root 8328: 8329: /* Track when we are inside in LIBCALL block. Inside such a block, 8330: we do not want to record destinations. The last insn of a 8331: LIBCALL block is not considered to be part of the block, since 1.1.1.3 root 8332: its destination is the result of the block and hence should be 1.1 root 8333: recorded. */ 8334: 1.1.1.4 root 8335: if (find_reg_note (insn, REG_LIBCALL, NULL_RTX)) 1.1 root 8336: in_libcall_block = 1; 1.1.1.4 root 8337: else if (find_reg_note (insn, REG_RETVAL, NULL_RTX)) 1.1 root 8338: in_libcall_block = 0; 8339: 8340: cse_insn (insn, in_libcall_block); 8341: } 8342: 8343: /* If INSN is now an unconditional jump, skip to the end of our 8344: basic block by pretending that we just did the last insn in the 8345: basic block. If we are jumping to the end of our block, show 8346: that we can have one usage of TO. */ 8347: 8348: if (simplejump_p (insn)) 8349: { 8350: if (to == 0) 8351: return 0; 8352: 8353: if (JUMP_LABEL (insn) == to) 8354: to_usage = 1; 8355: 1.1.1.3 root 8356: /* Maybe TO was deleted because the jump is unconditional. 8357: If so, there is nothing left in this basic block. */ 8358: /* ??? Perhaps it would be smarter to set TO 8359: to whatever follows this insn, 8360: and pretend the basic block had always ended here. */ 8361: if (INSN_DELETED_P (to)) 8362: break; 8363: 1.1 root 8364: insn = PREV_INSN (to); 8365: } 8366: 8367: /* See if it is ok to keep on going past the label 8368: which used to end our basic block. Remember that we incremented 1.1.1.2 root 8369: the count of that label, so we decrement it here. If we made 1.1 root 8370: a jump unconditional, TO_USAGE will be one; in that case, we don't 8371: want to count the use in that jump. */ 8372: 8373: if (to != 0 && NEXT_INSN (insn) == to 8374: && GET_CODE (to) == CODE_LABEL && --LABEL_NUSES (to) == to_usage) 8375: { 8376: struct cse_basic_block_data val; 8377: 8378: insn = NEXT_INSN (to); 8379: 8380: if (LABEL_NUSES (to) == 0) 8381: delete_insn (to); 8382: 8383: /* Find the end of the following block. Note that we won't be 8384: following branches in this case. If TO was the last insn 8385: in the function, we are done. Similarly, if we deleted the 1.1.1.2 root 8386: insn after TO, it must have been because it was preceded by 1.1 root 8387: a BARRIER. In that case, we are done with this block because it 8388: has no continuation. */ 8389: 8390: if (insn == 0 || INSN_DELETED_P (insn)) 8391: return 0; 8392: 8393: to_usage = 0; 8394: val.path_size = 0; 1.1.1.3 root 8395: cse_end_of_basic_block (insn, &val, 0, 0, 0); 1.1 root 8396: 8397: /* If the tables we allocated have enough space left 8398: to handle all the SETs in the next basic block, 8399: continue through it. Otherwise, return, 8400: and that block will be scanned individually. */ 8401: if (val.nsets * 2 + next_qty > max_qty) 8402: break; 8403: 8404: cse_basic_block_start = val.low_cuid; 8405: cse_basic_block_end = val.high_cuid; 8406: to = val.last; 8407: 8408: /* Prevent TO from being deleted if it is a label. */ 8409: if (to != 0 && GET_CODE (to) == CODE_LABEL) 8410: ++LABEL_NUSES (to); 8411: 8412: /* Back up so we process the first insn in the extension. */ 8413: insn = PREV_INSN (insn); 8414: } 8415: } 8416: 8417: if (next_qty > max_qty) 8418: abort (); 8419: 8420: /* If we are running before loop.c, we stopped on a NOTE_INSN_LOOP_END, and 8421: the previous insn is the only insn that branches to the head of a loop, 8422: we can cse into the loop. Don't do this if we changed the jump 8423: structure of a loop unless we aren't going to be following jumps. */ 8424: 1.1.1.3 root 8425: if ((cse_jumps_altered == 0 8426: || (flag_cse_follow_jumps == 0 && flag_cse_skip_blocks == 0)) 1.1 root 8427: && around_loop && to != 0 8428: && GET_CODE (to) == NOTE && NOTE_LINE_NUMBER (to) == NOTE_INSN_LOOP_END 8429: && GET_CODE (PREV_INSN (to)) == JUMP_INSN 8430: && JUMP_LABEL (PREV_INSN (to)) != 0 8431: && LABEL_NUSES (JUMP_LABEL (PREV_INSN (to))) == 1) 8432: cse_around_loop (JUMP_LABEL (PREV_INSN (to))); 8433: 8434: return to ? NEXT_INSN (to) : 0; 8435: } 8436: 8437: /* Count the number of times registers are used (not set) in X. 8438: COUNTS is an array in which we accumulate the count, INCR is how much 1.1.1.7 ! root 8439: we count each register usage. ! 8440: ! 8441: Don't count a usage of DEST, which is the SET_DEST of a SET which ! 8442: contains X in its SET_SRC. This is because such a SET does not ! 8443: modify the liveness of DEST. */ 1.1 root 8444: 8445: static void 1.1.1.7 ! root 8446: count_reg_usage (x, counts, dest, incr) 1.1 root 8447: rtx x; 8448: int *counts; 1.1.1.7 ! root 8449: rtx dest; 1.1 root 8450: int incr; 8451: { 1.1.1.7 ! root 8452: enum rtx_code code; 1.1 root 8453: char *fmt; 8454: int i, j; 8455: 1.1.1.7 ! root 8456: if (x == 0) ! 8457: return; ! 8458: ! 8459: switch (code = GET_CODE (x)) 1.1 root 8460: { 8461: case REG: 1.1.1.7 ! root 8462: if (x != dest) ! 8463: counts[REGNO (x)] += incr; 1.1 root 8464: return; 8465: 8466: case PC: 8467: case CC0: 8468: case CONST: 8469: case CONST_INT: 8470: case CONST_DOUBLE: 8471: case SYMBOL_REF: 8472: case LABEL_REF: 8473: case CLOBBER: 8474: return; 8475: 8476: case SET: 8477: /* Unless we are setting a REG, count everything in SET_DEST. */ 8478: if (GET_CODE (SET_DEST (x)) != REG) 1.1.1.7 ! root 8479: count_reg_usage (SET_DEST (x), counts, NULL_RTX, incr); ! 8480: ! 8481: /* If SRC has side-effects, then we can't delete this insn, so the ! 8482: usage of SET_DEST inside SRC counts. ! 8483: ! 8484: ??? Strictly-speaking, we might be preserving this insn ! 8485: because some other SET has side-effects, but that's hard ! 8486: to do and can't happen now. */ ! 8487: count_reg_usage (SET_SRC (x), counts, ! 8488: side_effects_p (SET_SRC (x)) ? NULL_RTX : SET_DEST (x), ! 8489: incr); 1.1 root 8490: return; 8491: 1.1.1.7 ! root 8492: case CALL_INSN: ! 8493: count_reg_usage (CALL_INSN_FUNCTION_USAGE (x), counts, NULL_RTX, incr); ! 8494: ! 8495: /* ... falls through ... */ 1.1 root 8496: case INSN: 8497: case JUMP_INSN: 1.1.1.7 ! root 8498: count_reg_usage (PATTERN (x), counts, NULL_RTX, incr); 1.1 root 8499: 8500: /* Things used in a REG_EQUAL note aren't dead since loop may try to 8501: use them. */ 8502: 1.1.1.7 ! root 8503: count_reg_usage (REG_NOTES (x), counts, NULL_RTX, incr); 1.1 root 8504: return; 8505: 8506: case EXPR_LIST: 8507: case INSN_LIST: 1.1.1.7 ! root 8508: if (REG_NOTE_KIND (x) == REG_EQUAL ! 8509: || GET_CODE (XEXP (x,0)) == USE) ! 8510: count_reg_usage (XEXP (x, 0), counts, NULL_RTX, incr); ! 8511: count_reg_usage (XEXP (x, 1), counts, NULL_RTX, incr); 1.1 root 8512: return; 8513: } 8514: 8515: fmt = GET_RTX_FORMAT (code); 8516: for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--) 8517: { 8518: if (fmt[i] == 'e') 1.1.1.7 ! root 8519: count_reg_usage (XEXP (x, i), counts, dest, incr); 1.1 root 8520: else if (fmt[i] == 'E') 8521: for (j = XVECLEN (x, i) - 1; j >= 0; j--) 1.1.1.7 ! root 8522: count_reg_usage (XVECEXP (x, i, j), counts, dest, incr); 1.1 root 8523: } 8524: } 8525: 8526: /* Scan all the insns and delete any that are dead; i.e., they store a register 8527: that is never used or they copy a register to itself. 8528: 8529: This is used to remove insns made obviously dead by cse. It improves the 8530: heuristics in loop since it won't try to move dead invariants out of loops 8531: or make givs for dead quantities. The remaining passes of the compilation 8532: are also sped up. */ 8533: 8534: void 8535: delete_dead_from_cse (insns, nreg) 8536: rtx insns; 8537: int nreg; 8538: { 8539: int *counts = (int *) alloca (nreg * sizeof (int)); 1.1.1.4 root 8540: rtx insn, prev; 1.1.1.2 root 8541: rtx tem; 1.1 root 8542: int i; 1.1.1.3 root 8543: int in_libcall = 0; 1.1 root 8544: 8545: /* First count the number of times each register is used. */ 1.1.1.7 ! root 8546: bzero ((char *) counts, sizeof (int) * nreg); 1.1 root 8547: for (insn = next_real_insn (insns); insn; insn = next_real_insn (insn)) 1.1.1.7 ! root 8548: count_reg_usage (insn, counts, NULL_RTX, 1); 1.1 root 8549: 8550: /* Go from the last insn to the first and delete insns that only set unused 8551: registers or copy a register to itself. As we delete an insn, remove 8552: usage counts for registers it uses. */ 1.1.1.4 root 8553: for (insn = prev_real_insn (get_last_insn ()); insn; insn = prev) 1.1 root 8554: { 8555: int live_insn = 0; 8556: 1.1.1.4 root 8557: prev = prev_real_insn (insn); 8558: 1.1.1.3 root 8559: /* Don't delete any insns that are part of a libcall block. 1.1.1.4 root 8560: Flow or loop might get confused if we did that. Remember 8561: that we are scanning backwards. */ 8562: if (find_reg_note (insn, REG_RETVAL, NULL_RTX)) 1.1.1.3 root 8563: in_libcall = 1; 8564: 8565: if (in_libcall) 8566: live_insn = 1; 8567: else if (GET_CODE (PATTERN (insn)) == SET) 1.1 root 8568: { 8569: if (GET_CODE (SET_DEST (PATTERN (insn))) == REG 8570: && SET_DEST (PATTERN (insn)) == SET_SRC (PATTERN (insn))) 8571: ; 8572: 1.1.1.2 root 8573: #ifdef HAVE_cc0 8574: else if (GET_CODE (SET_DEST (PATTERN (insn))) == CC0 8575: && ! side_effects_p (SET_SRC (PATTERN (insn))) 8576: && ((tem = next_nonnote_insn (insn)) == 0 8577: || GET_RTX_CLASS (GET_CODE (tem)) != 'i' 8578: || ! reg_referenced_p (cc0_rtx, PATTERN (tem)))) 8579: ; 8580: #endif 1.1 root 8581: else if (GET_CODE (SET_DEST (PATTERN (insn))) != REG 8582: || REGNO (SET_DEST (PATTERN (insn))) < FIRST_PSEUDO_REGISTER 8583: || counts[REGNO (SET_DEST (PATTERN (insn)))] != 0 8584: || side_effects_p (SET_SRC (PATTERN (insn)))) 8585: live_insn = 1; 8586: } 8587: else if (GET_CODE (PATTERN (insn)) == PARALLEL) 8588: for (i = XVECLEN (PATTERN (insn), 0) - 1; i >= 0; i--) 8589: { 8590: rtx elt = XVECEXP (PATTERN (insn), 0, i); 8591: 8592: if (GET_CODE (elt) == SET) 8593: { 8594: if (GET_CODE (SET_DEST (elt)) == REG 8595: && SET_DEST (elt) == SET_SRC (elt)) 8596: ; 8597: 1.1.1.2 root 8598: #ifdef HAVE_cc0 8599: else if (GET_CODE (SET_DEST (elt)) == CC0 8600: && ! side_effects_p (SET_SRC (elt)) 8601: && ((tem = next_nonnote_insn (insn)) == 0 8602: || GET_RTX_CLASS (GET_CODE (tem)) != 'i' 8603: || ! reg_referenced_p (cc0_rtx, PATTERN (tem)))) 8604: ; 8605: #endif 1.1 root 8606: else if (GET_CODE (SET_DEST (elt)) != REG 8607: || REGNO (SET_DEST (elt)) < FIRST_PSEUDO_REGISTER 8608: || counts[REGNO (SET_DEST (elt))] != 0 8609: || side_effects_p (SET_SRC (elt))) 8610: live_insn = 1; 8611: } 8612: else if (GET_CODE (elt) != CLOBBER && GET_CODE (elt) != USE) 8613: live_insn = 1; 8614: } 8615: else 8616: live_insn = 1; 8617: 8618: /* If this is a dead insn, delete it and show registers in it aren't 1.1.1.3 root 8619: being used. */ 1.1 root 8620: 1.1.1.3 root 8621: if (! live_insn) 1.1 root 8622: { 1.1.1.7 ! root 8623: count_reg_usage (insn, counts, NULL_RTX, -1); 1.1.1.4 root 8624: delete_insn (insn); 1.1 root 8625: } 1.1.1.3 root 8626: 1.1.1.4 root 8627: if (find_reg_note (insn, REG_LIBCALL, NULL_RTX)) 1.1.1.3 root 8628: in_libcall = 0; 1.1 root 8629: } 8630: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.