Branch data Line data Source code
1 : : /* Common subexpression elimination for GNU compiler.
2 : : Copyright (C) 1987-2024 Free Software Foundation, Inc.
3 : :
4 : : This file is part of GCC.
5 : :
6 : : GCC is free software; you can redistribute it and/or modify it under
7 : : the terms of the GNU General Public License as published by the Free
8 : : Software Foundation; either version 3, or (at your option) any later
9 : : version.
10 : :
11 : : GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12 : : WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 : : FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 : : for more details.
15 : :
16 : : You should have received a copy of the GNU General Public License
17 : : along with GCC; see the file COPYING3. If not see
18 : : <http://www.gnu.org/licenses/>. */
19 : :
20 : : #include "config.h"
21 : : #include "system.h"
22 : : #include "coretypes.h"
23 : : #include "backend.h"
24 : : #include "target.h"
25 : : #include "rtl.h"
26 : : #include "tree.h"
27 : : #include "cfghooks.h"
28 : : #include "df.h"
29 : : #include "memmodel.h"
30 : : #include "tm_p.h"
31 : : #include "insn-config.h"
32 : : #include "regs.h"
33 : : #include "emit-rtl.h"
34 : : #include "recog.h"
35 : : #include "cfgrtl.h"
36 : : #include "cfganal.h"
37 : : #include "cfgcleanup.h"
38 : : #include "alias.h"
39 : : #include "toplev.h"
40 : : #include "rtlhooks-def.h"
41 : : #include "tree-pass.h"
42 : : #include "dbgcnt.h"
43 : : #include "rtl-iter.h"
44 : : #include "regs.h"
45 : : #include "function-abi.h"
46 : : #include "rtlanal.h"
47 : : #include "expr.h"
48 : :
49 : : /* The basic idea of common subexpression elimination is to go
50 : : through the code, keeping a record of expressions that would
51 : : have the same value at the current scan point, and replacing
52 : : expressions encountered with the cheapest equivalent expression.
53 : :
54 : : It is too complicated to keep track of the different possibilities
55 : : when control paths merge in this code; so, at each label, we forget all
56 : : that is known and start fresh. This can be described as processing each
57 : : extended basic block separately. We have a separate pass to perform
58 : : global CSE.
59 : :
60 : : Note CSE can turn a conditional or computed jump into a nop or
61 : : an unconditional jump. When this occurs we arrange to run the jump
62 : : optimizer after CSE to delete the unreachable code.
63 : :
64 : : We use two data structures to record the equivalent expressions:
65 : : a hash table for most expressions, and a vector of "quantity
66 : : numbers" to record equivalent (pseudo) registers.
67 : :
68 : : The use of the special data structure for registers is desirable
69 : : because it is faster. It is possible because registers references
70 : : contain a fairly small number, the register number, taken from
71 : : a contiguously allocated series, and two register references are
72 : : identical if they have the same number. General expressions
73 : : do not have any such thing, so the only way to retrieve the
74 : : information recorded on an expression other than a register
75 : : is to keep it in a hash table.
76 : :
77 : : Registers and "quantity numbers":
78 : :
79 : : At the start of each basic block, all of the (hardware and pseudo)
80 : : registers used in the function are given distinct quantity
81 : : numbers to indicate their contents. During scan, when the code
82 : : copies one register into another, we copy the quantity number.
83 : : When a register is loaded in any other way, we allocate a new
84 : : quantity number to describe the value generated by this operation.
85 : : `REG_QTY (N)' records what quantity register N is currently thought
86 : : of as containing.
87 : :
88 : : All real quantity numbers are greater than or equal to zero.
89 : : If register N has not been assigned a quantity, `REG_QTY (N)' will
90 : : equal -N - 1, which is always negative.
91 : :
92 : : Quantity numbers below zero do not exist and none of the `qty_table'
93 : : entries should be referenced with a negative index.
94 : :
95 : : We also maintain a bidirectional chain of registers for each
96 : : quantity number. The `qty_table` members `first_reg' and `last_reg',
97 : : and `reg_eqv_table' members `next' and `prev' hold these chains.
98 : :
99 : : The first register in a chain is the one whose lifespan is least local.
100 : : Among equals, it is the one that was seen first.
101 : : We replace any equivalent register with that one.
102 : :
103 : : If two registers have the same quantity number, it must be true that
104 : : REG expressions with qty_table `mode' must be in the hash table for both
105 : : registers and must be in the same class.
106 : :
107 : : The converse is not true. Since hard registers may be referenced in
108 : : any mode, two REG expressions might be equivalent in the hash table
109 : : but not have the same quantity number if the quantity number of one
110 : : of the registers is not the same mode as those expressions.
111 : :
112 : : Constants and quantity numbers
113 : :
114 : : When a quantity has a known constant value, that value is stored
115 : : in the appropriate qty_table `const_rtx'. This is in addition to
116 : : putting the constant in the hash table as is usual for non-regs.
117 : :
118 : : Whether a reg or a constant is preferred is determined by the configuration
119 : : macro CONST_COSTS and will often depend on the constant value. In any
120 : : event, expressions containing constants can be simplified, by fold_rtx.
121 : :
122 : : When a quantity has a known nearly constant value (such as an address
123 : : of a stack slot), that value is stored in the appropriate qty_table
124 : : `const_rtx'.
125 : :
126 : : Integer constants don't have a machine mode. However, cse
127 : : determines the intended machine mode from the destination
128 : : of the instruction that moves the constant. The machine mode
129 : : is recorded in the hash table along with the actual RTL
130 : : constant expression so that different modes are kept separate.
131 : :
132 : : Other expressions:
133 : :
134 : : To record known equivalences among expressions in general
135 : : we use a hash table called `table'. It has a fixed number of buckets
136 : : that contain chains of `struct table_elt' elements for expressions.
137 : : These chains connect the elements whose expressions have the same
138 : : hash codes.
139 : :
140 : : Other chains through the same elements connect the elements which
141 : : currently have equivalent values.
142 : :
143 : : Register references in an expression are canonicalized before hashing
144 : : the expression. This is done using `reg_qty' and qty_table `first_reg'.
145 : : The hash code of a register reference is computed using the quantity
146 : : number, not the register number.
147 : :
148 : : When the value of an expression changes, it is necessary to remove from the
149 : : hash table not just that expression but all expressions whose values
150 : : could be different as a result.
151 : :
152 : : 1. If the value changing is in memory, except in special cases
153 : : ANYTHING referring to memory could be changed. That is because
154 : : nobody knows where a pointer does not point.
155 : : The function `invalidate_memory' removes what is necessary.
156 : :
157 : : The special cases are when the address is constant or is
158 : : a constant plus a fixed register such as the frame pointer
159 : : or a static chain pointer. When such addresses are stored in,
160 : : we can tell exactly which other such addresses must be invalidated
161 : : due to overlap. `invalidate' does this.
162 : : All expressions that refer to non-constant
163 : : memory addresses are also invalidated. `invalidate_memory' does this.
164 : :
165 : : 2. If the value changing is a register, all expressions
166 : : containing references to that register, and only those,
167 : : must be removed.
168 : :
169 : : Because searching the entire hash table for expressions that contain
170 : : a register is very slow, we try to figure out when it isn't necessary.
171 : : Precisely, this is necessary only when expressions have been
172 : : entered in the hash table using this register, and then the value has
173 : : changed, and then another expression wants to be added to refer to
174 : : the register's new value. This sequence of circumstances is rare
175 : : within any one basic block.
176 : :
177 : : `REG_TICK' and `REG_IN_TABLE', accessors for members of
178 : : cse_reg_info, are used to detect this case. REG_TICK (i) is
179 : : incremented whenever a value is stored in register i.
180 : : REG_IN_TABLE (i) holds -1 if no references to register i have been
181 : : entered in the table; otherwise, it contains the value REG_TICK (i)
182 : : had when the references were entered. If we want to enter a
183 : : reference and REG_IN_TABLE (i) != REG_TICK (i), we must scan and
184 : : remove old references. Until we want to enter a new entry, the
185 : : mere fact that the two vectors don't match makes the entries be
186 : : ignored if anyone tries to match them.
187 : :
188 : : Registers themselves are entered in the hash table as well as in
189 : : the equivalent-register chains. However, `REG_TICK' and
190 : : `REG_IN_TABLE' do not apply to expressions which are simple
191 : : register references. These expressions are removed from the table
192 : : immediately when they become invalid, and this can be done even if
193 : : we do not immediately search for all the expressions that refer to
194 : : the register.
195 : :
196 : : A CLOBBER rtx in an instruction invalidates its operand for further
197 : : reuse. A CLOBBER or SET rtx whose operand is a MEM:BLK
198 : : invalidates everything that resides in memory.
199 : :
200 : : Related expressions:
201 : :
202 : : Constant expressions that differ only by an additive integer
203 : : are called related. When a constant expression is put in
204 : : the table, the related expression with no constant term
205 : : is also entered. These are made to point at each other
206 : : so that it is possible to find out if there exists any
207 : : register equivalent to an expression related to a given expression. */
208 : :
209 : : /* Length of qty_table vector. We know in advance we will not need
210 : : a quantity number this big. */
211 : :
212 : : static int max_qty;
213 : :
214 : : /* Next quantity number to be allocated.
215 : : This is 1 + the largest number needed so far. */
216 : :
217 : : static int next_qty;
218 : :
219 : : /* Per-qty information tracking.
220 : :
221 : : `first_reg' and `last_reg' track the head and tail of the
222 : : chain of registers which currently contain this quantity.
223 : :
224 : : `mode' contains the machine mode of this quantity.
225 : :
226 : : `const_rtx' holds the rtx of the constant value of this
227 : : quantity, if known. A summations of the frame/arg pointer
228 : : and a constant can also be entered here. When this holds
229 : : a known value, `const_insn' is the insn which stored the
230 : : constant value.
231 : :
232 : : `comparison_{code,const,qty}' are used to track when a
233 : : comparison between a quantity and some constant or register has
234 : : been passed. In such a case, we know the results of the comparison
235 : : in case we see it again. These members record a comparison that
236 : : is known to be true. `comparison_code' holds the rtx code of such
237 : : a comparison, else it is set to UNKNOWN and the other two
238 : : comparison members are undefined. `comparison_const' holds
239 : : the constant being compared against, or zero if the comparison
240 : : is not against a constant. `comparison_qty' holds the quantity
241 : : being compared against when the result is known. If the comparison
242 : : is not with a register, `comparison_qty' is INT_MIN. */
243 : :
244 : : struct qty_table_elem
245 : : {
246 : : rtx const_rtx;
247 : : rtx_insn *const_insn;
248 : : rtx comparison_const;
249 : : int comparison_qty;
250 : : unsigned int first_reg, last_reg;
251 : : ENUM_BITFIELD(machine_mode) mode : MACHINE_MODE_BITSIZE;
252 : : ENUM_BITFIELD(rtx_code) comparison_code : RTX_CODE_BITSIZE;
253 : : };
254 : :
255 : : /* The table of all qtys, indexed by qty number. */
256 : : static struct qty_table_elem *qty_table;
257 : :
258 : : /* Insn being scanned. */
259 : :
260 : : static rtx_insn *this_insn;
261 : : static bool optimize_this_for_speed_p;
262 : :
263 : : /* Index by register number, gives the number of the next (or
264 : : previous) register in the chain of registers sharing the same
265 : : value.
266 : :
267 : : Or -1 if this register is at the end of the chain.
268 : :
269 : : If REG_QTY (N) == -N - 1, reg_eqv_table[N].next is undefined. */
270 : :
271 : : /* Per-register equivalence chain. */
272 : : struct reg_eqv_elem
273 : : {
274 : : int next, prev;
275 : : };
276 : :
277 : : /* The table of all register equivalence chains. */
278 : : static struct reg_eqv_elem *reg_eqv_table;
279 : :
280 : : struct cse_reg_info
281 : : {
282 : : /* The timestamp at which this register is initialized. */
283 : : unsigned int timestamp;
284 : :
285 : : /* The quantity number of the register's current contents. */
286 : : int reg_qty;
287 : :
288 : : /* The number of times the register has been altered in the current
289 : : basic block. */
290 : : int reg_tick;
291 : :
292 : : /* The REG_TICK value at which rtx's containing this register are
293 : : valid in the hash table. If this does not equal the current
294 : : reg_tick value, such expressions existing in the hash table are
295 : : invalid. */
296 : : int reg_in_table;
297 : :
298 : : /* The SUBREG that was set when REG_TICK was last incremented. Set
299 : : to -1 if the last store was to the whole register, not a subreg. */
300 : : unsigned int subreg_ticked;
301 : : };
302 : :
303 : : /* A table of cse_reg_info indexed by register numbers. */
304 : : static struct cse_reg_info *cse_reg_info_table;
305 : :
306 : : /* The size of the above table. */
307 : : static unsigned int cse_reg_info_table_size;
308 : :
309 : : /* The index of the first entry that has not been initialized. */
310 : : static unsigned int cse_reg_info_table_first_uninitialized;
311 : :
312 : : /* The timestamp at the beginning of the current run of
313 : : cse_extended_basic_block. We increment this variable at the beginning of
314 : : the current run of cse_extended_basic_block. The timestamp field of a
315 : : cse_reg_info entry matches the value of this variable if and only
316 : : if the entry has been initialized during the current run of
317 : : cse_extended_basic_block. */
318 : : static unsigned int cse_reg_info_timestamp;
319 : :
320 : : /* A HARD_REG_SET containing all the hard registers for which there is
321 : : currently a REG expression in the hash table. Note the difference
322 : : from the above variables, which indicate if the REG is mentioned in some
323 : : expression in the table. */
324 : :
325 : : static HARD_REG_SET hard_regs_in_table;
326 : :
327 : : /* True if CSE has altered the CFG. */
328 : : static bool cse_cfg_altered;
329 : :
330 : : /* True if CSE has altered conditional jump insns in such a way
331 : : that jump optimization should be redone. */
332 : : static bool cse_jumps_altered;
333 : :
334 : : /* True if we put a LABEL_REF into the hash table for an INSN
335 : : without a REG_LABEL_OPERAND, we have to rerun jump after CSE
336 : : to put in the note. */
337 : : static bool recorded_label_ref;
338 : :
339 : : /* canon_hash stores 1 in do_not_record if it notices a reference to PC or
340 : : some other volatile subexpression. */
341 : :
342 : : static int do_not_record;
343 : :
344 : : /* canon_hash stores 1 in hash_arg_in_memory
345 : : if it notices a reference to memory within the expression being hashed. */
346 : :
347 : : static int hash_arg_in_memory;
348 : :
349 : : /* The hash table contains buckets which are chains of `struct table_elt's,
350 : : each recording one expression's information.
351 : : That expression is in the `exp' field.
352 : :
353 : : The canon_exp field contains a canonical (from the point of view of
354 : : alias analysis) version of the `exp' field.
355 : :
356 : : Those elements with the same hash code are chained in both directions
357 : : through the `next_same_hash' and `prev_same_hash' fields.
358 : :
359 : : Each set of expressions with equivalent values
360 : : are on a two-way chain through the `next_same_value'
361 : : and `prev_same_value' fields, and all point with
362 : : the `first_same_value' field at the first element in
363 : : that chain. The chain is in order of increasing cost.
364 : : Each element's cost value is in its `cost' field.
365 : :
366 : : The `in_memory' field is nonzero for elements that
367 : : involve any reference to memory. These elements are removed
368 : : whenever a write is done to an unidentified location in memory.
369 : : To be safe, we assume that a memory address is unidentified unless
370 : : the address is either a symbol constant or a constant plus
371 : : the frame pointer or argument pointer.
372 : :
373 : : The `related_value' field is used to connect related expressions
374 : : (that differ by adding an integer).
375 : : The related expressions are chained in a circular fashion.
376 : : `related_value' is zero for expressions for which this
377 : : chain is not useful.
378 : :
379 : : The `cost' field stores the cost of this element's expression.
380 : : The `regcost' field stores the value returned by approx_reg_cost for
381 : : this element's expression.
382 : :
383 : : The `is_const' flag is set if the element is a constant (including
384 : : a fixed address).
385 : :
386 : : The `flag' field is used as a temporary during some search routines.
387 : :
388 : : The `mode' field is usually the same as GET_MODE (`exp'), but
389 : : if `exp' is a CONST_INT and has no machine mode then the `mode'
390 : : field is the mode it was being used as. Each constant is
391 : : recorded separately for each mode it is used with. */
392 : :
393 : : struct table_elt
394 : : {
395 : : rtx exp;
396 : : rtx canon_exp;
397 : : struct table_elt *next_same_hash;
398 : : struct table_elt *prev_same_hash;
399 : : struct table_elt *next_same_value;
400 : : struct table_elt *prev_same_value;
401 : : struct table_elt *first_same_value;
402 : : struct table_elt *related_value;
403 : : int cost;
404 : : int regcost;
405 : : ENUM_BITFIELD(machine_mode) mode : MACHINE_MODE_BITSIZE;
406 : : char in_memory;
407 : : char is_const;
408 : : char flag;
409 : : };
410 : :
411 : : /* We don't want a lot of buckets, because we rarely have very many
412 : : things stored in the hash table, and a lot of buckets slows
413 : : down a lot of loops that happen frequently. */
414 : : #define HASH_SHIFT 5
415 : : #define HASH_SIZE (1 << HASH_SHIFT)
416 : : #define HASH_MASK (HASH_SIZE - 1)
417 : :
418 : : /* Determine whether register number N is considered a fixed register for the
419 : : purpose of approximating register costs.
420 : : It is desirable to replace other regs with fixed regs, to reduce need for
421 : : non-fixed hard regs.
422 : : A reg wins if it is either the frame pointer or designated as fixed. */
423 : : #define FIXED_REGNO_P(N) \
424 : : ((N) == FRAME_POINTER_REGNUM || (N) == HARD_FRAME_POINTER_REGNUM \
425 : : || fixed_regs[N] || global_regs[N])
426 : :
427 : : /* Compute cost of X, as stored in the `cost' field of a table_elt. Fixed
428 : : hard registers and pointers into the frame are the cheapest with a cost
429 : : of 0. Next come pseudos with a cost of one and other hard registers with
430 : : a cost of 2. Aside from these special cases, call `rtx_cost'. */
431 : :
432 : : #define CHEAP_REGNO(N) \
433 : : (REGNO_PTR_FRAME_P (N) \
434 : : || (HARD_REGISTER_NUM_P (N) \
435 : : && FIXED_REGNO_P (N) && REGNO_REG_CLASS (N) != NO_REGS))
436 : :
437 : : #define COST(X, MODE) \
438 : : (REG_P (X) ? 0 : notreg_cost (X, MODE, SET, 1))
439 : : #define COST_IN(X, MODE, OUTER, OPNO) \
440 : : (REG_P (X) ? 0 : notreg_cost (X, MODE, OUTER, OPNO))
441 : :
442 : : /* Get the number of times this register has been updated in this
443 : : basic block. */
444 : :
445 : : #define REG_TICK(N) (get_cse_reg_info (N)->reg_tick)
446 : :
447 : : /* Get the point at which REG was recorded in the table. */
448 : :
449 : : #define REG_IN_TABLE(N) (get_cse_reg_info (N)->reg_in_table)
450 : :
451 : : /* Get the SUBREG set at the last increment to REG_TICK (-1 if not a
452 : : SUBREG). */
453 : :
454 : : #define SUBREG_TICKED(N) (get_cse_reg_info (N)->subreg_ticked)
455 : :
456 : : /* Get the quantity number for REG. */
457 : :
458 : : #define REG_QTY(N) (get_cse_reg_info (N)->reg_qty)
459 : :
460 : : /* Determine if the quantity number for register X represents a valid index
461 : : into the qty_table. */
462 : :
463 : : #define REGNO_QTY_VALID_P(N) (REG_QTY (N) >= 0)
464 : :
465 : : /* Compare table_elt X and Y and return true iff X is cheaper than Y. */
466 : :
467 : : #define CHEAPER(X, Y) \
468 : : (preferable ((X)->cost, (X)->regcost, (Y)->cost, (Y)->regcost) < 0)
469 : :
470 : : static struct table_elt *table[HASH_SIZE];
471 : :
472 : : /* Chain of `struct table_elt's made so far for this function
473 : : but currently removed from the table. */
474 : :
475 : : static struct table_elt *free_element_chain;
476 : :
477 : : /* Trace a patch through the CFG. */
478 : :
479 : : struct branch_path
480 : : {
481 : : /* The basic block for this path entry. */
482 : : basic_block bb;
483 : : };
484 : :
485 : : /* This data describes a block that will be processed by
486 : : cse_extended_basic_block. */
487 : :
488 : : struct cse_basic_block_data
489 : : {
490 : : /* Total number of SETs in block. */
491 : : int nsets;
492 : : /* Size of current branch path, if any. */
493 : : int path_size;
494 : : /* Current path, indicating which basic_blocks will be processed. */
495 : : struct branch_path *path;
496 : : };
497 : :
498 : :
499 : : /* Pointers to the live in/live out bitmaps for the boundaries of the
500 : : current EBB. */
501 : : static bitmap cse_ebb_live_in, cse_ebb_live_out;
502 : :
503 : : /* A simple bitmap to track which basic blocks have been visited
504 : : already as part of an already processed extended basic block. */
505 : : static sbitmap cse_visited_basic_blocks;
506 : :
507 : : static bool fixed_base_plus_p (rtx x);
508 : : static int notreg_cost (rtx, machine_mode, enum rtx_code, int);
509 : : static int preferable (int, int, int, int);
510 : : static void new_basic_block (void);
511 : : static void make_new_qty (unsigned int, machine_mode);
512 : : static void make_regs_eqv (unsigned int, unsigned int);
513 : : static void delete_reg_equiv (unsigned int);
514 : : static bool mention_regs (rtx);
515 : : static bool insert_regs (rtx, struct table_elt *, bool);
516 : : static void remove_from_table (struct table_elt *, unsigned);
517 : : static void remove_pseudo_from_table (rtx, unsigned);
518 : : static struct table_elt *lookup (rtx, unsigned, machine_mode);
519 : : static struct table_elt *lookup_for_remove (rtx, unsigned, machine_mode);
520 : : static rtx lookup_as_function (rtx, enum rtx_code);
521 : : static struct table_elt *insert_with_costs (rtx, struct table_elt *, unsigned,
522 : : machine_mode, int, int);
523 : : static struct table_elt *insert (rtx, struct table_elt *, unsigned,
524 : : machine_mode);
525 : : static void merge_equiv_classes (struct table_elt *, struct table_elt *);
526 : : static void invalidate (rtx, machine_mode);
527 : : static void remove_invalid_refs (unsigned int);
528 : : static void remove_invalid_subreg_refs (unsigned int, poly_uint64,
529 : : machine_mode);
530 : : static void rehash_using_reg (rtx);
531 : : static void invalidate_memory (void);
532 : : static rtx use_related_value (rtx, struct table_elt *);
533 : :
534 : : static inline unsigned canon_hash (rtx, machine_mode);
535 : : static inline unsigned safe_hash (rtx, machine_mode);
536 : : static inline unsigned hash_rtx_string (const char *);
537 : :
538 : : static rtx canon_reg (rtx, rtx_insn *);
539 : : static enum rtx_code find_comparison_args (enum rtx_code, rtx *, rtx *,
540 : : machine_mode *,
541 : : machine_mode *);
542 : : static rtx fold_rtx (rtx, rtx_insn *);
543 : : static rtx equiv_constant (rtx);
544 : : static void record_jump_equiv (rtx_insn *, bool);
545 : : static void record_jump_cond (enum rtx_code, machine_mode, rtx, rtx);
546 : : static void cse_insn (rtx_insn *);
547 : : static void cse_prescan_path (struct cse_basic_block_data *);
548 : : static void invalidate_from_clobbers (rtx_insn *);
549 : : static void invalidate_from_sets_and_clobbers (rtx_insn *);
550 : : static void cse_extended_basic_block (struct cse_basic_block_data *);
551 : : extern void dump_class (struct table_elt*);
552 : : static void get_cse_reg_info_1 (unsigned int regno);
553 : : static struct cse_reg_info * get_cse_reg_info (unsigned int regno);
554 : :
555 : : static void flush_hash_table (void);
556 : : static bool insn_live_p (rtx_insn *, int *);
557 : : static bool set_live_p (rtx, int *);
558 : : static void cse_change_cc_mode_insn (rtx_insn *, rtx);
559 : : static void cse_change_cc_mode_insns (rtx_insn *, rtx_insn *, rtx);
560 : : static machine_mode cse_cc_succs (basic_block, basic_block, rtx, rtx,
561 : : bool);
562 : :
563 : :
564 : : #undef RTL_HOOKS_GEN_LOWPART
565 : : #define RTL_HOOKS_GEN_LOWPART gen_lowpart_if_possible
566 : :
567 : : static const struct rtl_hooks cse_rtl_hooks = RTL_HOOKS_INITIALIZER;
568 : :
569 : : /* Compute hash code of X in mode M. Special-case case where X is a pseudo
570 : : register (hard registers may require `do_not_record' to be set). */
571 : :
572 : : static inline unsigned
573 : 783515565 : HASH (rtx x, machine_mode mode)
574 : : {
575 : 509640022 : unsigned h = (REG_P (x) && REGNO (x) >= FIRST_PSEUDO_REGISTER
576 : 1084915866 : ? (((unsigned) REG << 7) + (unsigned) REG_QTY (REGNO (x)))
577 : 482115264 : : canon_hash (x, mode));
578 : 783515565 : return (h ^ (h >> HASH_SHIFT)) & HASH_MASK;
579 : : }
580 : :
581 : : /* Like HASH, but without side-effects. */
582 : :
583 : : static inline unsigned
584 : 214177937 : SAFE_HASH (rtx x, machine_mode mode)
585 : : {
586 : 109498554 : unsigned h = (REG_P (x) && REGNO (x) >= FIRST_PSEUDO_REGISTER
587 : 276225499 : ? (((unsigned) REG << 7) + (unsigned) REG_QTY (REGNO (x)))
588 : 152130375 : : safe_hash (x, mode));
589 : 214177937 : return (h ^ (h >> HASH_SHIFT)) & HASH_MASK;
590 : : }
591 : :
592 : : /* Nonzero if X has the form (PLUS frame-pointer integer). */
593 : :
594 : : static bool
595 : 219336618 : fixed_base_plus_p (rtx x)
596 : : {
597 : 248887441 : switch (GET_CODE (x))
598 : : {
599 : 130089524 : case REG:
600 : 130089524 : if (x == frame_pointer_rtx || x == hard_frame_pointer_rtx)
601 : : return true;
602 : 116747367 : if (x == arg_pointer_rtx && fixed_regs[ARG_POINTER_REGNUM])
603 : 112573 : return true;
604 : : return false;
605 : :
606 : 35082912 : case PLUS:
607 : 35082912 : if (!CONST_INT_P (XEXP (x, 1)))
608 : : return false;
609 : 29550823 : return fixed_base_plus_p (XEXP (x, 0));
610 : :
611 : : default:
612 : : return false;
613 : : }
614 : : }
615 : :
616 : : /* Dump the expressions in the equivalence class indicated by CLASSP.
617 : : This function is used only for debugging. */
618 : : DEBUG_FUNCTION void
619 : 0 : dump_class (struct table_elt *classp)
620 : : {
621 : 0 : struct table_elt *elt;
622 : :
623 : 0 : fprintf (stderr, "Equivalence chain for ");
624 : 0 : print_rtl (stderr, classp->exp);
625 : 0 : fprintf (stderr, ": \n");
626 : :
627 : 0 : for (elt = classp->first_same_value; elt; elt = elt->next_same_value)
628 : : {
629 : 0 : print_rtl (stderr, elt->exp);
630 : 0 : fprintf (stderr, "\n");
631 : : }
632 : 0 : }
633 : :
634 : : /* Return an estimate of the cost of the registers used in an rtx.
635 : : This is mostly the number of different REG expressions in the rtx;
636 : : however for some exceptions like fixed registers we use a cost of
637 : : 0. If any other hard register reference occurs, return MAX_COST. */
638 : :
639 : : static int
640 : 403958880 : approx_reg_cost (const_rtx x)
641 : : {
642 : 403958880 : int cost = 0;
643 : 403958880 : subrtx_iterator::array_type array;
644 : 1271249985 : FOR_EACH_SUBRTX (iter, array, x, NONCONST)
645 : : {
646 : 920091553 : const_rtx x = *iter;
647 : 920091553 : if (REG_P (x))
648 : : {
649 : 380570996 : unsigned int regno = REGNO (x);
650 : 380570996 : if (!CHEAP_REGNO (regno))
651 : : {
652 : 52800448 : if (regno < FIRST_PSEUDO_REGISTER)
653 : : {
654 : 52800448 : if (targetm.small_register_classes_for_mode_p (GET_MODE (x)))
655 : 52800448 : return MAX_COST;
656 : 0 : cost += 2;
657 : : }
658 : : else
659 : 267374036 : cost += 1;
660 : : }
661 : : }
662 : : }
663 : 351158432 : return cost;
664 : 403958880 : }
665 : :
666 : : /* Return a negative value if an rtx A, whose costs are given by COST_A
667 : : and REGCOST_A, is more desirable than an rtx B.
668 : : Return a positive value if A is less desirable, or 0 if the two are
669 : : equally good. */
670 : : static int
671 : 617498868 : preferable (int cost_a, int regcost_a, int cost_b, int regcost_b)
672 : : {
673 : : /* First, get rid of cases involving expressions that are entirely
674 : : unwanted. */
675 : 617498868 : if (cost_a != cost_b)
676 : : {
677 : 577242305 : if (cost_a == MAX_COST)
678 : : return 1;
679 : 575772895 : if (cost_b == MAX_COST)
680 : : return -1;
681 : : }
682 : :
683 : : /* Avoid extending lifetimes of hardregs. */
684 : 159852704 : if (regcost_a != regcost_b)
685 : : {
686 : 87867010 : if (regcost_a == MAX_COST)
687 : : return 1;
688 : 68176268 : if (regcost_b == MAX_COST)
689 : : return -1;
690 : : }
691 : :
692 : : /* Normal operation costs take precedence. */
693 : 138264972 : if (cost_a != cost_b)
694 : 98104578 : return cost_a - cost_b;
695 : : /* Only if these are identical consider effects on register pressure. */
696 : 40160394 : if (regcost_a != regcost_b)
697 : 40160394 : return regcost_a - regcost_b;
698 : : return 0;
699 : : }
700 : :
701 : : /* Internal function, to compute cost when X is not a register; called
702 : : from COST macro to keep it simple. */
703 : :
704 : : static int
705 : 284700953 : notreg_cost (rtx x, machine_mode mode, enum rtx_code outer, int opno)
706 : : {
707 : 284700953 : scalar_int_mode int_mode, inner_mode;
708 : 284700953 : return ((GET_CODE (x) == SUBREG
709 : 5199668 : && REG_P (SUBREG_REG (x))
710 : 286613948 : && is_int_mode (mode, &int_mode)
711 : 285931504 : && is_int_mode (GET_MODE (SUBREG_REG (x)), &inner_mode)
712 : 7871334 : && GET_MODE_SIZE (int_mode) < GET_MODE_SIZE (inner_mode)
713 : 3886580 : && subreg_lowpart_p (x)
714 : 2705116 : && TRULY_NOOP_TRUNCATION_MODES_P (int_mode, inner_mode))
715 : 566696790 : ? 0
716 : 281995837 : : rtx_cost (x, mode, outer, opno, optimize_this_for_speed_p) * 2);
717 : : }
718 : :
719 : :
720 : : /* Initialize CSE_REG_INFO_TABLE. */
721 : :
722 : : static void
723 : 2201041 : init_cse_reg_info (unsigned int nregs)
724 : : {
725 : : /* Do we need to grow the table? */
726 : 2201041 : if (nregs > cse_reg_info_table_size)
727 : : {
728 : 167770 : unsigned int new_size;
729 : :
730 : 167770 : if (cse_reg_info_table_size < 2048)
731 : : {
732 : : /* Compute a new size that is a power of 2 and no smaller
733 : : than the large of NREGS and 64. */
734 : 167242 : new_size = (cse_reg_info_table_size
735 : 167242 : ? cse_reg_info_table_size : 64);
736 : :
737 : 371440 : while (new_size < nregs)
738 : 204198 : new_size *= 2;
739 : : }
740 : : else
741 : : {
742 : : /* If we need a big table, allocate just enough to hold
743 : : NREGS registers. */
744 : : new_size = nregs;
745 : : }
746 : :
747 : : /* Reallocate the table with NEW_SIZE entries. */
748 : 167770 : free (cse_reg_info_table);
749 : 167770 : cse_reg_info_table = XNEWVEC (struct cse_reg_info, new_size);
750 : 167770 : cse_reg_info_table_size = new_size;
751 : 167770 : cse_reg_info_table_first_uninitialized = 0;
752 : : }
753 : :
754 : : /* Do we have all of the first NREGS entries initialized? */
755 : 2201041 : if (cse_reg_info_table_first_uninitialized < nregs)
756 : : {
757 : 303076 : unsigned int old_timestamp = cse_reg_info_timestamp - 1;
758 : 303076 : unsigned int i;
759 : :
760 : : /* Put the old timestamp on newly allocated entries so that they
761 : : will all be considered out of date. We do not touch those
762 : : entries beyond the first NREGS entries to be nice to the
763 : : virtual memory. */
764 : 31287543 : for (i = cse_reg_info_table_first_uninitialized; i < nregs; i++)
765 : 30984467 : cse_reg_info_table[i].timestamp = old_timestamp;
766 : :
767 : 303076 : cse_reg_info_table_first_uninitialized = nregs;
768 : : }
769 : 2201041 : }
770 : :
771 : : /* Given REGNO, initialize the cse_reg_info entry for REGNO. */
772 : :
773 : : static void
774 : 803501095 : get_cse_reg_info_1 (unsigned int regno)
775 : : {
776 : : /* Set TIMESTAMP field to CSE_REG_INFO_TIMESTAMP so that this
777 : : entry will be considered to have been initialized. */
778 : 803501095 : cse_reg_info_table[regno].timestamp = cse_reg_info_timestamp;
779 : :
780 : : /* Initialize the rest of the entry. */
781 : 803501095 : cse_reg_info_table[regno].reg_tick = 1;
782 : 803501095 : cse_reg_info_table[regno].reg_in_table = -1;
783 : 803501095 : cse_reg_info_table[regno].subreg_ticked = -1;
784 : 803501095 : cse_reg_info_table[regno].reg_qty = -regno - 1;
785 : 803501095 : }
786 : :
787 : : /* Find a cse_reg_info entry for REGNO. */
788 : :
789 : : static inline struct cse_reg_info *
790 : 10510672227 : get_cse_reg_info (unsigned int regno)
791 : : {
792 : 10510672227 : struct cse_reg_info *p = &cse_reg_info_table[regno];
793 : :
794 : : /* If this entry has not been initialized, go ahead and initialize
795 : : it. */
796 : 10510672227 : if (p->timestamp != cse_reg_info_timestamp)
797 : 803501095 : get_cse_reg_info_1 (regno);
798 : :
799 : 10510672227 : return p;
800 : : }
801 : :
802 : : /* Clear the hash table and initialize each register with its own quantity,
803 : : for a new basic block. */
804 : :
805 : : static void
806 : 19149287 : new_basic_block (void)
807 : : {
808 : 19149287 : int i;
809 : :
810 : 19149287 : next_qty = 0;
811 : :
812 : : /* Invalidate cse_reg_info_table. */
813 : 19149287 : cse_reg_info_timestamp++;
814 : :
815 : : /* Clear out hash table state for this pass. */
816 : 19149287 : CLEAR_HARD_REG_SET (hard_regs_in_table);
817 : :
818 : : /* The per-quantity values used to be initialized here, but it is
819 : : much faster to initialize each as it is made in `make_new_qty'. */
820 : :
821 : 631926471 : for (i = 0; i < HASH_SIZE; i++)
822 : : {
823 : 612777184 : struct table_elt *first;
824 : :
825 : 612777184 : first = table[i];
826 : 612777184 : if (first != NULL)
827 : : {
828 : 125655041 : struct table_elt *last = first;
829 : :
830 : 125655041 : table[i] = NULL;
831 : :
832 : 177817252 : while (last->next_same_hash != NULL)
833 : : last = last->next_same_hash;
834 : :
835 : : /* Now relink this hash entire chain into
836 : : the free element list. */
837 : :
838 : 125655041 : last->next_same_hash = free_element_chain;
839 : 125655041 : free_element_chain = first;
840 : : }
841 : : }
842 : 19149287 : }
843 : :
844 : : /* Say that register REG contains a quantity in mode MODE not in any
845 : : register before and initialize that quantity. */
846 : :
847 : : static void
848 : 96652835 : make_new_qty (unsigned int reg, machine_mode mode)
849 : : {
850 : 96652835 : int q;
851 : 96652835 : struct qty_table_elem *ent;
852 : 96652835 : struct reg_eqv_elem *eqv;
853 : :
854 : 96652835 : gcc_assert (next_qty < max_qty);
855 : :
856 : 96652835 : q = REG_QTY (reg) = next_qty++;
857 : 96652835 : ent = &qty_table[q];
858 : 96652835 : ent->first_reg = reg;
859 : 96652835 : ent->last_reg = reg;
860 : 96652835 : ent->mode = mode;
861 : 96652835 : ent->const_rtx = ent->const_insn = NULL;
862 : 96652835 : ent->comparison_code = UNKNOWN;
863 : :
864 : 96652835 : eqv = ®_eqv_table[reg];
865 : 96652835 : eqv->next = eqv->prev = -1;
866 : 96652835 : }
867 : :
868 : : /* Make reg NEW equivalent to reg OLD.
869 : : OLD is not changing; NEW is. */
870 : :
871 : : static void
872 : 10596343 : make_regs_eqv (unsigned int new_reg, unsigned int old_reg)
873 : : {
874 : 10596343 : unsigned int lastr, firstr;
875 : 10596343 : int q = REG_QTY (old_reg);
876 : 10596343 : struct qty_table_elem *ent;
877 : :
878 : 10596343 : ent = &qty_table[q];
879 : :
880 : : /* Nothing should become eqv until it has a "non-invalid" qty number. */
881 : 10596343 : gcc_assert (REGNO_QTY_VALID_P (old_reg));
882 : :
883 : 10596343 : REG_QTY (new_reg) = q;
884 : 10596343 : firstr = ent->first_reg;
885 : 10596343 : lastr = ent->last_reg;
886 : :
887 : : /* Prefer fixed hard registers to anything. Prefer pseudo regs to other
888 : : hard regs. Among pseudos, if NEW will live longer than any other reg
889 : : of the same qty, and that is beyond the current basic block,
890 : : make it the new canonical replacement for this qty. */
891 : 303910 : if (! (firstr < FIRST_PSEUDO_REGISTER && FIXED_REGNO_P (firstr))
892 : : /* Certain fixed registers might be of the class NO_REGS. This means
893 : : that not only can they not be allocated by the compiler, but
894 : : they cannot be used in substitutions or canonicalizations
895 : : either. */
896 : 10292433 : && (new_reg >= FIRST_PSEUDO_REGISTER || REGNO_REG_CLASS (new_reg) != NO_REGS)
897 : 10600816 : && ((new_reg < FIRST_PSEUDO_REGISTER && FIXED_REGNO_P (new_reg))
898 : 10287960 : || (new_reg >= FIRST_PSEUDO_REGISTER
899 : 10287960 : && (firstr < FIRST_PSEUDO_REGISTER
900 : 10287960 : || (bitmap_bit_p (cse_ebb_live_out, new_reg)
901 : 3278192 : && !bitmap_bit_p (cse_ebb_live_out, firstr))
902 : 8415246 : || (bitmap_bit_p (cse_ebb_live_in, new_reg)
903 : 405001 : && !bitmap_bit_p (cse_ebb_live_in, firstr))))))
904 : : {
905 : 1944132 : reg_eqv_table[firstr].prev = new_reg;
906 : 1944132 : reg_eqv_table[new_reg].next = firstr;
907 : 1944132 : reg_eqv_table[new_reg].prev = -1;
908 : 1944132 : ent->first_reg = new_reg;
909 : : }
910 : : else
911 : : {
912 : : /* If NEW is a hard reg (known to be non-fixed), insert at end.
913 : : Otherwise, insert before any non-fixed hard regs that are at the
914 : : end. Registers of class NO_REGS cannot be used as an
915 : : equivalent for anything. */
916 : 287954 : while (lastr < FIRST_PSEUDO_REGISTER && reg_eqv_table[lastr].prev >= 0
917 : 0 : && (REGNO_REG_CLASS (lastr) == NO_REGS || ! FIXED_REGNO_P (lastr))
918 : 8652211 : && new_reg >= FIRST_PSEUDO_REGISTER)
919 : 0 : lastr = reg_eqv_table[lastr].prev;
920 : 8652211 : reg_eqv_table[new_reg].next = reg_eqv_table[lastr].next;
921 : 8652211 : if (reg_eqv_table[lastr].next >= 0)
922 : 0 : reg_eqv_table[reg_eqv_table[lastr].next].prev = new_reg;
923 : : else
924 : 8652211 : qty_table[q].last_reg = new_reg;
925 : 8652211 : reg_eqv_table[lastr].next = new_reg;
926 : 8652211 : reg_eqv_table[new_reg].prev = lastr;
927 : : }
928 : 10596343 : }
929 : :
930 : : /* Remove REG from its equivalence class. */
931 : :
932 : : static void
933 : 1415840246 : delete_reg_equiv (unsigned int reg)
934 : : {
935 : 1415840246 : struct qty_table_elem *ent;
936 : 1415840246 : int q = REG_QTY (reg);
937 : 1415840246 : int p, n;
938 : :
939 : : /* If invalid, do nothing. */
940 : 1415840246 : if (! REGNO_QTY_VALID_P (reg))
941 : : return;
942 : :
943 : 17543008 : ent = &qty_table[q];
944 : :
945 : 17543008 : p = reg_eqv_table[reg].prev;
946 : 17543008 : n = reg_eqv_table[reg].next;
947 : :
948 : 17543008 : if (n != -1)
949 : 636039 : reg_eqv_table[n].prev = p;
950 : : else
951 : 16906969 : ent->last_reg = p;
952 : 17543008 : if (p != -1)
953 : 594789 : reg_eqv_table[p].next = n;
954 : : else
955 : 16948219 : ent->first_reg = n;
956 : :
957 : 17543008 : REG_QTY (reg) = -reg - 1;
958 : : }
959 : :
960 : : /* Remove any invalid expressions from the hash table
961 : : that refer to any of the registers contained in expression X.
962 : :
963 : : Make sure that newly inserted references to those registers
964 : : as subexpressions will be considered valid.
965 : :
966 : : mention_regs is not called when a register itself
967 : : is being stored in the table.
968 : :
969 : : Return true if we have done something that may have changed
970 : : the hash code of X. */
971 : :
972 : : static bool
973 : 427684311 : mention_regs (rtx x)
974 : : {
975 : 427684311 : enum rtx_code code;
976 : 427684311 : int i, j;
977 : 427684311 : const char *fmt;
978 : 427684311 : bool changed = false;
979 : :
980 : 427684311 : if (x == 0)
981 : : return false;
982 : :
983 : 427684311 : code = GET_CODE (x);
984 : 427684311 : if (code == REG)
985 : : {
986 : 128795536 : unsigned int regno = REGNO (x);
987 : 128795536 : unsigned int endregno = END_REGNO (x);
988 : 128795536 : unsigned int i;
989 : :
990 : 257591072 : for (i = regno; i < endregno; i++)
991 : : {
992 : 128795536 : if (REG_IN_TABLE (i) >= 0 && REG_IN_TABLE (i) != REG_TICK (i))
993 : 168189 : remove_invalid_refs (i);
994 : :
995 : 128795536 : REG_IN_TABLE (i) = REG_TICK (i);
996 : 128795536 : SUBREG_TICKED (i) = -1;
997 : : }
998 : :
999 : : return false;
1000 : : }
1001 : :
1002 : : /* If this is a SUBREG, we don't want to discard other SUBREGs of the same
1003 : : pseudo if they don't use overlapping words. We handle only pseudos
1004 : : here for simplicity. */
1005 : 7166142 : if (code == SUBREG && REG_P (SUBREG_REG (x))
1006 : 306048261 : && REGNO (SUBREG_REG (x)) >= FIRST_PSEUDO_REGISTER)
1007 : : {
1008 : 7159373 : unsigned int i = REGNO (SUBREG_REG (x));
1009 : :
1010 : 7159373 : if (REG_IN_TABLE (i) >= 0 && REG_IN_TABLE (i) != REG_TICK (i))
1011 : : {
1012 : : /* If REG_IN_TABLE (i) differs from REG_TICK (i) by one, and
1013 : : the last store to this register really stored into this
1014 : : subreg, then remove the memory of this subreg.
1015 : : Otherwise, remove any memory of the entire register and
1016 : : all its subregs from the table. */
1017 : 343182 : if (REG_TICK (i) - REG_IN_TABLE (i) > 1
1018 : 343182 : || SUBREG_TICKED (i) != REGNO (SUBREG_REG (x)))
1019 : 343182 : remove_invalid_refs (i);
1020 : : else
1021 : 0 : remove_invalid_subreg_refs (i, SUBREG_BYTE (x), GET_MODE (x));
1022 : : }
1023 : :
1024 : 7159373 : REG_IN_TABLE (i) = REG_TICK (i);
1025 : 7159373 : SUBREG_TICKED (i) = REGNO (SUBREG_REG (x));
1026 : 7159373 : return false;
1027 : : }
1028 : :
1029 : : /* If X is a comparison or a COMPARE and either operand is a register
1030 : : that does not have a quantity, give it one. This is so that a later
1031 : : call to record_jump_equiv won't cause X to be assigned a different
1032 : : hash code and not found in the table after that call.
1033 : :
1034 : : It is not necessary to do this here, since rehash_using_reg can
1035 : : fix up the table later, but doing this here eliminates the need to
1036 : : call that expensive function in the most common case where the only
1037 : : use of the register is in the comparison. */
1038 : :
1039 : 291729402 : if (code == COMPARE || COMPARISON_P (x))
1040 : : {
1041 : 21800976 : if (REG_P (XEXP (x, 0))
1042 : 21800976 : && ! REGNO_QTY_VALID_P (REGNO (XEXP (x, 0))))
1043 : 8283280 : if (insert_regs (XEXP (x, 0), NULL, false))
1044 : : {
1045 : 8283280 : rehash_using_reg (XEXP (x, 0));
1046 : 8283280 : changed = true;
1047 : : }
1048 : :
1049 : 21800976 : if (REG_P (XEXP (x, 1))
1050 : 21800976 : && ! REGNO_QTY_VALID_P (REGNO (XEXP (x, 1))))
1051 : 2170292 : if (insert_regs (XEXP (x, 1), NULL, false))
1052 : : {
1053 : 2170292 : rehash_using_reg (XEXP (x, 1));
1054 : 2170292 : changed = true;
1055 : : }
1056 : : }
1057 : :
1058 : 291729402 : fmt = GET_RTX_FORMAT (code);
1059 : 758189468 : for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
1060 : 466460066 : if (fmt[i] == 'e')
1061 : : {
1062 : 275398649 : if (mention_regs (XEXP (x, i)))
1063 : 466460066 : changed = true;
1064 : : }
1065 : 191061417 : else if (fmt[i] == 'E')
1066 : 15407907 : for (j = 0; j < XVECLEN (x, i); j++)
1067 : 11453795 : if (mention_regs (XVECEXP (x, i, j)))
1068 : 357248 : changed = true;
1069 : :
1070 : : return changed;
1071 : : }
1072 : :
1073 : : /* Update the register quantities for inserting X into the hash table
1074 : : with a value equivalent to CLASSP.
1075 : : (If the class does not contain a REG, it is irrelevant.)
1076 : : If MODIFIED is true, X is a destination; it is being modified.
1077 : : Note that delete_reg_equiv should be called on a register
1078 : : before insert_regs is done on that register with MODIFIED != 0.
1079 : :
1080 : : True value means that elements of reg_qty have changed
1081 : : so X's hash code may be different. */
1082 : :
1083 : : static bool
1084 : 233168441 : insert_regs (rtx x, struct table_elt *classp, bool modified)
1085 : : {
1086 : 233168441 : if (REG_P (x))
1087 : : {
1088 : 113378292 : unsigned int regno = REGNO (x);
1089 : 113378292 : int qty_valid;
1090 : :
1091 : : /* If REGNO is in the equivalence table already but is of the
1092 : : wrong mode for that equivalence, don't do anything here. */
1093 : :
1094 : 113378292 : qty_valid = REGNO_QTY_VALID_P (regno);
1095 : 113378292 : if (qty_valid)
1096 : : {
1097 : 6129114 : struct qty_table_elem *ent = &qty_table[REG_QTY (regno)];
1098 : :
1099 : 6129114 : if (ent->mode != GET_MODE (x))
1100 : : return false;
1101 : : }
1102 : :
1103 : 113378292 : if (modified || ! qty_valid)
1104 : : {
1105 : 107249178 : if (classp)
1106 : 86833753 : for (classp = classp->first_same_value;
1107 : 171631836 : classp != 0;
1108 : 84798083 : classp = classp->next_same_value)
1109 : 95394426 : if (REG_P (classp->exp)
1110 : 10596343 : && GET_MODE (classp->exp) == GET_MODE (x))
1111 : : {
1112 : 10596343 : unsigned c_regno = REGNO (classp->exp);
1113 : :
1114 : 10596343 : gcc_assert (REGNO_QTY_VALID_P (c_regno));
1115 : :
1116 : : /* Suppose that 5 is hard reg and 100 and 101 are
1117 : : pseudos. Consider
1118 : :
1119 : : (set (reg:si 100) (reg:si 5))
1120 : : (set (reg:si 5) (reg:si 100))
1121 : : (set (reg:di 101) (reg:di 5))
1122 : :
1123 : : We would now set REG_QTY (101) = REG_QTY (5), but the
1124 : : entry for 5 is in SImode. When we use this later in
1125 : : copy propagation, we get the register in wrong mode. */
1126 : 10596343 : if (qty_table[REG_QTY (c_regno)].mode != GET_MODE (x))
1127 : 0 : continue;
1128 : :
1129 : 10596343 : make_regs_eqv (regno, c_regno);
1130 : 10596343 : return true;
1131 : : }
1132 : :
1133 : : /* Mention_regs for a SUBREG checks if REG_TICK is exactly one larger
1134 : : than REG_IN_TABLE to find out if there was only a single preceding
1135 : : invalidation - for the SUBREG - or another one, which would be
1136 : : for the full register. However, if we find here that REG_TICK
1137 : : indicates that the register is invalid, it means that it has
1138 : : been invalidated in a separate operation. The SUBREG might be used
1139 : : now (then this is a recursive call), or we might use the full REG
1140 : : now and a SUBREG of it later. So bump up REG_TICK so that
1141 : : mention_regs will do the right thing. */
1142 : 96652835 : if (! modified
1143 : 20624402 : && REG_IN_TABLE (regno) >= 0
1144 : 98534366 : && REG_TICK (regno) == REG_IN_TABLE (regno) + 1)
1145 : 383 : REG_TICK (regno)++;
1146 : 96652835 : make_new_qty (regno, GET_MODE (x));
1147 : 96652835 : return true;
1148 : : }
1149 : :
1150 : : return false;
1151 : : }
1152 : :
1153 : : /* If X is a SUBREG, we will likely be inserting the inner register in the
1154 : : table. If that register doesn't have an assigned quantity number at
1155 : : this point but does later, the insertion that we will be doing now will
1156 : : not be accessible because its hash code will have changed. So assign
1157 : : a quantity number now. */
1158 : :
1159 : 3233136 : else if (GET_CODE (x) == SUBREG && REG_P (SUBREG_REG (x))
1160 : 123018986 : && ! REGNO_QTY_VALID_P (REGNO (SUBREG_REG (x))))
1161 : : {
1162 : 1704339 : insert_regs (SUBREG_REG (x), NULL, false);
1163 : 1704339 : mention_regs (x);
1164 : 1704339 : return true;
1165 : : }
1166 : : else
1167 : 118085810 : return mention_regs (x);
1168 : : }
1169 : :
1170 : :
1171 : : /* Compute upper and lower anchors for CST. Also compute the offset of CST
1172 : : from these anchors/bases such that *_BASE + *_OFFS = CST. Return false iff
1173 : : CST is equal to an anchor. */
1174 : :
1175 : : static bool
1176 : 0 : compute_const_anchors (rtx cst,
1177 : : HOST_WIDE_INT *lower_base, HOST_WIDE_INT *lower_offs,
1178 : : HOST_WIDE_INT *upper_base, HOST_WIDE_INT *upper_offs)
1179 : : {
1180 : 0 : unsigned HOST_WIDE_INT n = UINTVAL (cst);
1181 : :
1182 : 0 : *lower_base = n & ~(targetm.const_anchor - 1);
1183 : 0 : if ((unsigned HOST_WIDE_INT) *lower_base == n)
1184 : : return false;
1185 : :
1186 : 0 : *upper_base = ((n + (targetm.const_anchor - 1))
1187 : 0 : & ~(targetm.const_anchor - 1));
1188 : 0 : *upper_offs = n - *upper_base;
1189 : 0 : *lower_offs = n - *lower_base;
1190 : 0 : return true;
1191 : : }
1192 : :
1193 : : /* Insert the equivalence between ANCHOR and (REG + OFF) in mode MODE. */
1194 : :
1195 : : static void
1196 : 0 : insert_const_anchor (HOST_WIDE_INT anchor, rtx reg, HOST_WIDE_INT offs,
1197 : : machine_mode mode)
1198 : : {
1199 : 0 : struct table_elt *elt;
1200 : 0 : unsigned hash;
1201 : 0 : rtx anchor_exp;
1202 : 0 : rtx exp;
1203 : :
1204 : 0 : anchor_exp = gen_int_mode (anchor, mode);
1205 : 0 : hash = HASH (anchor_exp, mode);
1206 : 0 : elt = lookup (anchor_exp, hash, mode);
1207 : 0 : if (!elt)
1208 : 0 : elt = insert (anchor_exp, NULL, hash, mode);
1209 : :
1210 : 0 : exp = plus_constant (mode, reg, offs);
1211 : : /* REG has just been inserted and the hash codes recomputed. */
1212 : 0 : mention_regs (exp);
1213 : 0 : hash = HASH (exp, mode);
1214 : :
1215 : : /* Use the cost of the register rather than the whole expression. When
1216 : : looking up constant anchors we will further offset the corresponding
1217 : : expression therefore it does not make sense to prefer REGs over
1218 : : reg-immediate additions. Prefer instead the oldest expression. Also
1219 : : don't prefer pseudos over hard regs so that we derive constants in
1220 : : argument registers from other argument registers rather than from the
1221 : : original pseudo that was used to synthesize the constant. */
1222 : 0 : insert_with_costs (exp, elt, hash, mode, COST (reg, mode), 1);
1223 : 0 : }
1224 : :
1225 : : /* The constant CST is equivalent to the register REG. Create
1226 : : equivalences between the two anchors of CST and the corresponding
1227 : : register-offset expressions using REG. */
1228 : :
1229 : : static void
1230 : 0 : insert_const_anchors (rtx reg, rtx cst, machine_mode mode)
1231 : : {
1232 : 0 : HOST_WIDE_INT lower_base, lower_offs, upper_base, upper_offs;
1233 : :
1234 : 0 : if (!compute_const_anchors (cst, &lower_base, &lower_offs,
1235 : : &upper_base, &upper_offs))
1236 : 0 : return;
1237 : :
1238 : : /* Ignore anchors of value 0. Constants accessible from zero are
1239 : : simple. */
1240 : 0 : if (lower_base != 0)
1241 : 0 : insert_const_anchor (lower_base, reg, -lower_offs, mode);
1242 : :
1243 : 0 : if (upper_base != 0)
1244 : 0 : insert_const_anchor (upper_base, reg, -upper_offs, mode);
1245 : : }
1246 : :
1247 : : /* We need to express ANCHOR_ELT->exp + OFFS. Walk the equivalence list of
1248 : : ANCHOR_ELT and see if offsetting any of the entries by OFFS would create a
1249 : : valid expression. Return the cheapest and oldest of such expressions. In
1250 : : *OLD, return how old the resulting expression is compared to the other
1251 : : equivalent expressions. */
1252 : :
1253 : : static rtx
1254 : 0 : find_reg_offset_for_const (struct table_elt *anchor_elt, HOST_WIDE_INT offs,
1255 : : unsigned *old)
1256 : : {
1257 : 0 : struct table_elt *elt;
1258 : 0 : unsigned idx;
1259 : 0 : struct table_elt *match_elt;
1260 : 0 : rtx match;
1261 : :
1262 : : /* Find the cheapest and *oldest* expression to maximize the chance of
1263 : : reusing the same pseudo. */
1264 : :
1265 : 0 : match_elt = NULL;
1266 : 0 : match = NULL_RTX;
1267 : 0 : for (elt = anchor_elt->first_same_value, idx = 0;
1268 : 0 : elt;
1269 : 0 : elt = elt->next_same_value, idx++)
1270 : : {
1271 : 0 : if (match_elt && CHEAPER (match_elt, elt))
1272 : : return match;
1273 : :
1274 : 0 : if (REG_P (elt->exp)
1275 : 0 : || (GET_CODE (elt->exp) == PLUS
1276 : 0 : && REG_P (XEXP (elt->exp, 0))
1277 : 0 : && GET_CODE (XEXP (elt->exp, 1)) == CONST_INT))
1278 : : {
1279 : 0 : rtx x;
1280 : :
1281 : : /* Ignore expressions that are no longer valid. */
1282 : 0 : if (!REG_P (elt->exp) && !exp_equiv_p (elt->exp, elt->exp, 1, false))
1283 : 0 : continue;
1284 : :
1285 : 0 : x = plus_constant (GET_MODE (elt->exp), elt->exp, offs);
1286 : 0 : if (REG_P (x)
1287 : 0 : || (GET_CODE (x) == PLUS
1288 : 0 : && IN_RANGE (INTVAL (XEXP (x, 1)),
1289 : : -targetm.const_anchor,
1290 : : targetm.const_anchor - 1)))
1291 : : {
1292 : 0 : match = x;
1293 : 0 : match_elt = elt;
1294 : 0 : *old = idx;
1295 : : }
1296 : : }
1297 : : }
1298 : :
1299 : : return match;
1300 : : }
1301 : :
1302 : : /* Try to express the constant SRC_CONST using a register+offset expression
1303 : : derived from a constant anchor. Return it if successful or NULL_RTX,
1304 : : otherwise. */
1305 : :
1306 : : static rtx
1307 : 0 : try_const_anchors (rtx src_const, machine_mode mode)
1308 : : {
1309 : 0 : struct table_elt *lower_elt, *upper_elt;
1310 : 0 : HOST_WIDE_INT lower_base, lower_offs, upper_base, upper_offs;
1311 : 0 : rtx lower_anchor_rtx, upper_anchor_rtx;
1312 : 0 : rtx lower_exp = NULL_RTX, upper_exp = NULL_RTX;
1313 : 0 : unsigned lower_old, upper_old;
1314 : :
1315 : : /* CONST_INT may be in various modes, avoid non-scalar-int mode. */
1316 : 0 : if (!SCALAR_INT_MODE_P (mode))
1317 : : return NULL_RTX;
1318 : :
1319 : 0 : if (!compute_const_anchors (src_const, &lower_base, &lower_offs,
1320 : : &upper_base, &upper_offs))
1321 : : return NULL_RTX;
1322 : :
1323 : 0 : lower_anchor_rtx = GEN_INT (lower_base);
1324 : 0 : upper_anchor_rtx = GEN_INT (upper_base);
1325 : 0 : lower_elt = lookup (lower_anchor_rtx, HASH (lower_anchor_rtx, mode), mode);
1326 : 0 : upper_elt = lookup (upper_anchor_rtx, HASH (upper_anchor_rtx, mode), mode);
1327 : :
1328 : 0 : if (lower_elt)
1329 : 0 : lower_exp = find_reg_offset_for_const (lower_elt, lower_offs, &lower_old);
1330 : 0 : if (upper_elt)
1331 : 0 : upper_exp = find_reg_offset_for_const (upper_elt, upper_offs, &upper_old);
1332 : :
1333 : 0 : if (!lower_exp)
1334 : : return upper_exp;
1335 : 0 : if (!upper_exp)
1336 : : return lower_exp;
1337 : :
1338 : : /* Return the older expression. */
1339 : 0 : return (upper_old > lower_old ? upper_exp : lower_exp);
1340 : : }
1341 : :
1342 : : /* Look in or update the hash table. */
1343 : :
1344 : : /* Remove table element ELT from use in the table.
1345 : : HASH is its hash code, made using the HASH macro.
1346 : : It's an argument because often that is known in advance
1347 : : and we save much time not recomputing it. */
1348 : :
1349 : : static void
1350 : 64368499 : remove_from_table (struct table_elt *elt, unsigned int hash)
1351 : : {
1352 : 64368499 : if (elt == 0)
1353 : : return;
1354 : :
1355 : : /* Mark this element as removed. See cse_insn. */
1356 : 64368499 : elt->first_same_value = 0;
1357 : :
1358 : : /* Remove the table element from its equivalence class. */
1359 : :
1360 : 64368499 : {
1361 : 64368499 : struct table_elt *prev = elt->prev_same_value;
1362 : 64368499 : struct table_elt *next = elt->next_same_value;
1363 : :
1364 : 64368499 : if (next)
1365 : 7118023 : next->prev_same_value = prev;
1366 : :
1367 : 64368499 : if (prev)
1368 : 41042407 : prev->next_same_value = next;
1369 : : else
1370 : : {
1371 : : struct table_elt *newfirst = next;
1372 : 30072917 : while (next)
1373 : : {
1374 : 6746825 : next->first_same_value = newfirst;
1375 : 6746825 : next = next->next_same_value;
1376 : : }
1377 : : }
1378 : : }
1379 : :
1380 : : /* Remove the table element from its hash bucket. */
1381 : :
1382 : 64368499 : {
1383 : 64368499 : struct table_elt *prev = elt->prev_same_hash;
1384 : 64368499 : struct table_elt *next = elt->next_same_hash;
1385 : :
1386 : 64368499 : if (next)
1387 : 19040863 : next->prev_same_hash = prev;
1388 : :
1389 : 64368499 : if (prev)
1390 : 7950560 : prev->next_same_hash = next;
1391 : 56417939 : else if (table[hash] == elt)
1392 : 56417924 : table[hash] = next;
1393 : : else
1394 : : {
1395 : : /* This entry is not in the proper hash bucket. This can happen
1396 : : when two classes were merged by `merge_equiv_classes'. Search
1397 : : for the hash bucket that it heads. This happens only very
1398 : : rarely, so the cost is acceptable. */
1399 : 495 : for (hash = 0; hash < HASH_SIZE; hash++)
1400 : 480 : if (table[hash] == elt)
1401 : 15 : table[hash] = next;
1402 : : }
1403 : : }
1404 : :
1405 : : /* Remove the table element from its related-value circular chain. */
1406 : :
1407 : 64368499 : if (elt->related_value != 0 && elt->related_value != elt)
1408 : : {
1409 : : struct table_elt *p = elt->related_value;
1410 : :
1411 : 132578 : while (p->related_value != elt)
1412 : : p = p->related_value;
1413 : 25398 : p->related_value = elt->related_value;
1414 : 25398 : if (p->related_value == p)
1415 : 19849 : p->related_value = 0;
1416 : : }
1417 : :
1418 : : /* Now add it to the free element chain. */
1419 : 64368499 : elt->next_same_hash = free_element_chain;
1420 : 64368499 : free_element_chain = elt;
1421 : : }
1422 : :
1423 : : /* Same as above, but X is a pseudo-register. */
1424 : :
1425 : : static void
1426 : 86043058 : remove_pseudo_from_table (rtx x, unsigned int hash)
1427 : : {
1428 : 86043058 : struct table_elt *elt;
1429 : :
1430 : : /* Because a pseudo-register can be referenced in more than one
1431 : : mode, we might have to remove more than one table entry. */
1432 : 90263910 : while ((elt = lookup_for_remove (x, hash, VOIDmode)))
1433 : 4220852 : remove_from_table (elt, hash);
1434 : 86043058 : }
1435 : :
1436 : : /* Look up X in the hash table and return its table element,
1437 : : or 0 if X is not in the table.
1438 : :
1439 : : MODE is the machine-mode of X, or if X is an integer constant
1440 : : with VOIDmode then MODE is the mode with which X will be used.
1441 : :
1442 : : Here we are satisfied to find an expression whose tree structure
1443 : : looks like X. */
1444 : :
1445 : : static struct table_elt *
1446 : 458707361 : lookup (rtx x, unsigned int hash, machine_mode mode)
1447 : : {
1448 : 458707361 : struct table_elt *p;
1449 : :
1450 : 683313371 : for (p = table[hash]; p; p = p->next_same_hash)
1451 : 345173776 : if (mode == p->mode && ((x == p->exp && REG_P (x))
1452 : 136876585 : || exp_equiv_p (x, p->exp, !REG_P (x), false)))
1453 : 120567766 : return p;
1454 : :
1455 : : return 0;
1456 : : }
1457 : :
1458 : : /* Like `lookup' but don't care whether the table element uses invalid regs.
1459 : : Also ignore discrepancies in the machine mode of a register. */
1460 : :
1461 : : static struct table_elt *
1462 : 90263910 : lookup_for_remove (rtx x, unsigned int hash, machine_mode mode)
1463 : : {
1464 : 90263910 : struct table_elt *p;
1465 : :
1466 : 90263910 : if (REG_P (x))
1467 : : {
1468 : 90263910 : unsigned int regno = REGNO (x);
1469 : :
1470 : : /* Don't check the machine mode when comparing registers;
1471 : : invalidating (REG:SI 0) also invalidates (REG:DF 0). */
1472 : 165301913 : for (p = table[hash]; p; p = p->next_same_hash)
1473 : 79258855 : if (REG_P (p->exp)
1474 : 79258855 : && REGNO (p->exp) == regno)
1475 : : return p;
1476 : : }
1477 : : else
1478 : : {
1479 : 0 : for (p = table[hash]; p; p = p->next_same_hash)
1480 : 0 : if (mode == p->mode
1481 : 0 : && (x == p->exp || exp_equiv_p (x, p->exp, 0, false)))
1482 : 0 : return p;
1483 : : }
1484 : :
1485 : : return 0;
1486 : : }
1487 : :
1488 : : /* Look for an expression equivalent to X and with code CODE.
1489 : : If one is found, return that expression. */
1490 : :
1491 : : static rtx
1492 : 55637414 : lookup_as_function (rtx x, enum rtx_code code)
1493 : : {
1494 : 55637414 : struct table_elt *p
1495 : 55637414 : = lookup (x, SAFE_HASH (x, VOIDmode), GET_MODE (x));
1496 : :
1497 : 55637414 : if (p == 0)
1498 : : return 0;
1499 : :
1500 : 36789236 : for (p = p->first_same_value; p; p = p->next_same_value)
1501 : 25530348 : if (GET_CODE (p->exp) == code
1502 : : /* Make sure this is a valid entry in the table. */
1503 : 25530348 : && exp_equiv_p (p->exp, p->exp, 1, false))
1504 : 885516 : return p->exp;
1505 : :
1506 : : return 0;
1507 : : }
1508 : :
1509 : : /* Insert X in the hash table, assuming HASH is its hash code and
1510 : : CLASSP is an element of the class it should go in (or 0 if a new
1511 : : class should be made). COST is the code of X and reg_cost is the
1512 : : cost of registers in X. It is inserted at the proper position to
1513 : : keep the class in the order cheapest first.
1514 : :
1515 : : MODE is the machine-mode of X, or if X is an integer constant
1516 : : with VOIDmode then MODE is the mode with which X will be used.
1517 : :
1518 : : For elements of equal cheapness, the most recent one
1519 : : goes in front, except that the first element in the list
1520 : : remains first unless a cheaper element is added. The order of
1521 : : pseudo-registers does not matter, as canon_reg will be called to
1522 : : find the cheapest when a register is retrieved from the table.
1523 : :
1524 : : The in_memory field in the hash table element is set to 0.
1525 : : The caller must set it nonzero if appropriate.
1526 : :
1527 : : You should call insert_regs (X, CLASSP, MODIFY) before calling here,
1528 : : and if insert_regs returns a nonzero value
1529 : : you must then recompute its hash code before calling here.
1530 : :
1531 : : If necessary, update table showing constant values of quantities. */
1532 : :
1533 : : static struct table_elt *
1534 : 242650256 : insert_with_costs (rtx x, struct table_elt *classp, unsigned int hash,
1535 : : machine_mode mode, int cost, int reg_cost)
1536 : : {
1537 : 242650256 : struct table_elt *elt;
1538 : :
1539 : : /* If X is a register and we haven't made a quantity for it,
1540 : : something is wrong. */
1541 : 242650256 : gcc_assert (!REG_P (x) || REGNO_QTY_VALID_P (REGNO (x)));
1542 : :
1543 : : /* If X is a hard register, show it is being put in the table. */
1544 : 242650256 : if (REG_P (x) && REGNO (x) < FIRST_PSEUDO_REGISTER)
1545 : 20273398 : add_to_hard_reg_set (&hard_regs_in_table, GET_MODE (x), REGNO (x));
1546 : :
1547 : : /* Put an element for X into the right hash bucket. */
1548 : :
1549 : 242650256 : elt = free_element_chain;
1550 : 242650256 : if (elt)
1551 : 237941792 : free_element_chain = elt->next_same_hash;
1552 : : else
1553 : 4708464 : elt = XNEW (struct table_elt);
1554 : :
1555 : 242650256 : elt->exp = x;
1556 : 242650256 : elt->canon_exp = NULL_RTX;
1557 : 242650256 : elt->cost = cost;
1558 : 242650256 : elt->regcost = reg_cost;
1559 : 242650256 : elt->next_same_value = 0;
1560 : 242650256 : elt->prev_same_value = 0;
1561 : 242650256 : elt->next_same_hash = table[hash];
1562 : 242650256 : elt->prev_same_hash = 0;
1563 : 242650256 : elt->related_value = 0;
1564 : 242650256 : elt->in_memory = 0;
1565 : 242650256 : elt->mode = mode;
1566 : 242650256 : elt->is_const = (CONSTANT_P (x) || fixed_base_plus_p (x));
1567 : :
1568 : 242650256 : if (table[hash])
1569 : 76338871 : table[hash]->prev_same_hash = elt;
1570 : 242650256 : table[hash] = elt;
1571 : :
1572 : : /* Put it into the proper value-class. */
1573 : 242650256 : if (classp)
1574 : : {
1575 : 118422773 : classp = classp->first_same_value;
1576 : 118422773 : if (CHEAPER (elt, classp))
1577 : : /* Insert at the head of the class. */
1578 : : {
1579 : 55599347 : struct table_elt *p;
1580 : 55599347 : elt->next_same_value = classp;
1581 : 55599347 : classp->prev_same_value = elt;
1582 : 55599347 : elt->first_same_value = elt;
1583 : :
1584 : 117657862 : for (p = classp; p; p = p->next_same_value)
1585 : 62058515 : p->first_same_value = elt;
1586 : : }
1587 : : else
1588 : : {
1589 : : /* Insert not at head of the class. */
1590 : : /* Put it after the last element cheaper than X. */
1591 : : struct table_elt *p, *next;
1592 : :
1593 : : for (p = classp;
1594 : 136931245 : (next = p->next_same_value) && CHEAPER (next, elt);
1595 : : p = next)
1596 : : ;
1597 : :
1598 : : /* Put it after P and before NEXT. */
1599 : 62823426 : elt->next_same_value = next;
1600 : 62823426 : if (next)
1601 : 15295141 : next->prev_same_value = elt;
1602 : :
1603 : 62823426 : elt->prev_same_value = p;
1604 : 62823426 : p->next_same_value = elt;
1605 : 62823426 : elt->first_same_value = classp;
1606 : : }
1607 : : }
1608 : : else
1609 : 124227483 : elt->first_same_value = elt;
1610 : :
1611 : : /* If this is a constant being set equivalent to a register or a register
1612 : : being set equivalent to a constant, note the constant equivalence.
1613 : :
1614 : : If this is a constant, it cannot be equivalent to a different constant,
1615 : : and a constant is the only thing that can be cheaper than a register. So
1616 : : we know the register is the head of the class (before the constant was
1617 : : inserted).
1618 : :
1619 : : If this is a register that is not already known equivalent to a
1620 : : constant, we must check the entire class.
1621 : :
1622 : : If this is a register that is already known equivalent to an insn,
1623 : : update the qtys `const_insn' to show that `this_insn' is the latest
1624 : : insn making that quantity equivalent to the constant. */
1625 : :
1626 : 242650256 : if (elt->is_const && classp && REG_P (classp->exp)
1627 : 3147598 : && !REG_P (x))
1628 : : {
1629 : 3145343 : int exp_q = REG_QTY (REGNO (classp->exp));
1630 : 3145343 : struct qty_table_elem *exp_ent = &qty_table[exp_q];
1631 : :
1632 : 3145343 : exp_ent->const_rtx = gen_lowpart (exp_ent->mode, x);
1633 : 3145343 : exp_ent->const_insn = this_insn;
1634 : 3145343 : }
1635 : :
1636 : 239504913 : else if (REG_P (x)
1637 : 101220381 : && classp
1638 : 86842708 : && ! qty_table[REG_QTY (REGNO (x))].const_rtx
1639 : 322109694 : && ! elt->is_const)
1640 : : {
1641 : : struct table_elt *p;
1642 : :
1643 : 186091260 : for (p = classp; p != 0; p = p->next_same_value)
1644 : : {
1645 : 116967788 : if (p->is_const && !REG_P (p->exp))
1646 : : {
1647 : 13479015 : int x_q = REG_QTY (REGNO (x));
1648 : 13479015 : struct qty_table_elem *x_ent = &qty_table[x_q];
1649 : :
1650 : 13479015 : x_ent->const_rtx
1651 : 13479015 : = gen_lowpart (GET_MODE (x), p->exp);
1652 : 13479015 : x_ent->const_insn = this_insn;
1653 : 13479015 : break;
1654 : : }
1655 : : }
1656 : : }
1657 : :
1658 : 156902426 : else if (REG_P (x)
1659 : 18617894 : && qty_table[REG_QTY (REGNO (x))].const_rtx
1660 : 161140354 : && GET_MODE (x) == qty_table[REG_QTY (REGNO (x))].mode)
1661 : 4237928 : qty_table[REG_QTY (REGNO (x))].const_insn = this_insn;
1662 : :
1663 : : /* If this is a constant with symbolic value,
1664 : : and it has a term with an explicit integer value,
1665 : : link it up with related expressions. */
1666 : 242650256 : if (GET_CODE (x) == CONST)
1667 : : {
1668 : 721004 : rtx subexp = get_related_value (x);
1669 : 721004 : unsigned subhash;
1670 : 721004 : struct table_elt *subelt, *subelt_prev;
1671 : :
1672 : 721004 : if (subexp != 0)
1673 : : {
1674 : : /* Get the integer-free subexpression in the hash table. */
1675 : 707361 : subhash = SAFE_HASH (subexp, mode);
1676 : 707361 : subelt = lookup (subexp, subhash, mode);
1677 : 707361 : if (subelt == 0)
1678 : 321069 : subelt = insert (subexp, NULL, subhash, mode);
1679 : : /* Initialize SUBELT's circular chain if it has none. */
1680 : 707361 : if (subelt->related_value == 0)
1681 : 479001 : subelt->related_value = subelt;
1682 : : /* Find the element in the circular chain that precedes SUBELT. */
1683 : 707361 : subelt_prev = subelt;
1684 : 2275779 : while (subelt_prev->related_value != subelt)
1685 : : subelt_prev = subelt_prev->related_value;
1686 : : /* Put new ELT into SUBELT's circular chain just before SUBELT.
1687 : : This way the element that follows SUBELT is the oldest one. */
1688 : 707361 : elt->related_value = subelt_prev->related_value;
1689 : 707361 : subelt_prev->related_value = elt;
1690 : : }
1691 : : }
1692 : :
1693 : 242650256 : return elt;
1694 : : }
1695 : :
1696 : : /* Wrap insert_with_costs by passing the default costs. */
1697 : :
1698 : : static struct table_elt *
1699 : 242650256 : insert (rtx x, struct table_elt *classp, unsigned int hash,
1700 : : machine_mode mode)
1701 : : {
1702 : 485300512 : return insert_with_costs (x, classp, hash, mode,
1703 : 242650256 : COST (x, mode), approx_reg_cost (x));
1704 : : }
1705 : :
1706 : :
1707 : : /* Given two equivalence classes, CLASS1 and CLASS2, put all the entries from
1708 : : CLASS2 into CLASS1. This is done when we have reached an insn which makes
1709 : : the two classes equivalent.
1710 : :
1711 : : CLASS1 will be the surviving class; CLASS2 should not be used after this
1712 : : call.
1713 : :
1714 : : Any invalid entries in CLASS2 will not be copied. */
1715 : :
1716 : : static void
1717 : 4913733 : merge_equiv_classes (struct table_elt *class1, struct table_elt *class2)
1718 : : {
1719 : 4913733 : struct table_elt *elt, *next, *new_elt;
1720 : :
1721 : : /* Ensure we start with the head of the classes. */
1722 : 4913733 : class1 = class1->first_same_value;
1723 : 4913733 : class2 = class2->first_same_value;
1724 : :
1725 : : /* If they were already equal, forget it. */
1726 : 4913733 : if (class1 == class2)
1727 : : return;
1728 : :
1729 : 11681040 : for (elt = class2; elt; elt = next)
1730 : : {
1731 : 6767307 : unsigned int hash;
1732 : 6767307 : rtx exp = elt->exp;
1733 : 6767307 : machine_mode mode = elt->mode;
1734 : :
1735 : 6767307 : next = elt->next_same_value;
1736 : :
1737 : : /* Remove old entry, make a new one in CLASS1's class.
1738 : : Don't do this for invalid entries as we cannot find their
1739 : : hash code (it also isn't necessary). */
1740 : 6767307 : if (REG_P (exp) || exp_equiv_p (exp, exp, 1, false))
1741 : : {
1742 : 6767237 : bool need_rehash = false;
1743 : :
1744 : 6767237 : hash_arg_in_memory = 0;
1745 : 6767237 : hash = HASH (exp, mode);
1746 : :
1747 : 6767237 : if (REG_P (exp))
1748 : : {
1749 : 1820056 : need_rehash = REGNO_QTY_VALID_P (REGNO (exp));
1750 : 1820056 : delete_reg_equiv (REGNO (exp));
1751 : : }
1752 : :
1753 : 6767237 : if (REG_P (exp) && REGNO (exp) >= FIRST_PSEUDO_REGISTER)
1754 : 1819420 : remove_pseudo_from_table (exp, hash);
1755 : : else
1756 : 4947817 : remove_from_table (elt, hash);
1757 : :
1758 : 6767237 : if (insert_regs (exp, class1, false) || need_rehash)
1759 : : {
1760 : 1820056 : rehash_using_reg (exp);
1761 : 1820056 : hash = HASH (exp, mode);
1762 : : }
1763 : 6767237 : new_elt = insert (exp, class1, hash, mode);
1764 : 6767237 : new_elt->in_memory = hash_arg_in_memory;
1765 : 6767237 : if (GET_CODE (exp) == ASM_OPERANDS && elt->cost == MAX_COST)
1766 : 0 : new_elt->cost = MAX_COST;
1767 : : }
1768 : : }
1769 : : }
1770 : :
1771 : : /* Flush the entire hash table. */
1772 : :
1773 : : static void
1774 : 3866 : flush_hash_table (void)
1775 : : {
1776 : 3866 : int i;
1777 : 3866 : struct table_elt *p;
1778 : :
1779 : 127578 : for (i = 0; i < HASH_SIZE; i++)
1780 : 912648 : for (p = table[i]; p; p = table[i])
1781 : : {
1782 : : /* Note that invalidate can remove elements
1783 : : after P in the current hash chain. */
1784 : 788936 : if (REG_P (p->exp))
1785 : 352208 : invalidate (p->exp, VOIDmode);
1786 : : else
1787 : 436728 : remove_from_table (p, i);
1788 : : }
1789 : 3866 : }
1790 : :
1791 : : /* Check whether an anti dependence exists between X and EXP. MODE and
1792 : : ADDR are as for canon_anti_dependence. */
1793 : :
1794 : : static bool
1795 : 172252304 : check_dependence (const_rtx x, rtx exp, machine_mode mode, rtx addr)
1796 : : {
1797 : 172252304 : subrtx_iterator::array_type array;
1798 : 815144220 : FOR_EACH_SUBRTX (iter, array, x, NONCONST)
1799 : : {
1800 : 650363012 : const_rtx x = *iter;
1801 : 650363012 : if (MEM_P (x) && canon_anti_dependence (x, true, exp, mode, addr))
1802 : 7471096 : return true;
1803 : : }
1804 : 164781208 : return false;
1805 : 172252304 : }
1806 : :
1807 : : /* Remove from the hash table, or mark as invalid, all expressions whose
1808 : : values could be altered by storing in register X. */
1809 : :
1810 : : static void
1811 : 206650105 : invalidate_reg (rtx x)
1812 : : {
1813 : 206650105 : gcc_assert (GET_CODE (x) == REG);
1814 : :
1815 : : /* If X is a register, dependencies on its contents are recorded
1816 : : through the qty number mechanism. Just change the qty number of
1817 : : the register, mark it as invalid for expressions that refer to it,
1818 : : and remove it itself. */
1819 : 206650105 : unsigned int regno = REGNO (x);
1820 : 206650105 : unsigned int hash = HASH (x, GET_MODE (x));
1821 : :
1822 : : /* Remove REGNO from any quantity list it might be on and indicate
1823 : : that its value might have changed. If it is a pseudo, remove its
1824 : : entry from the hash table.
1825 : :
1826 : : For a hard register, we do the first two actions above for any
1827 : : additional hard registers corresponding to X. Then, if any of these
1828 : : registers are in the table, we must remove any REG entries that
1829 : : overlap these registers. */
1830 : :
1831 : 206650105 : delete_reg_equiv (regno);
1832 : 206650105 : REG_TICK (regno)++;
1833 : 206650105 : SUBREG_TICKED (regno) = -1;
1834 : :
1835 : 206650105 : if (regno >= FIRST_PSEUDO_REGISTER)
1836 : 84223638 : remove_pseudo_from_table (x, hash);
1837 : : else
1838 : : {
1839 : 122426467 : HOST_WIDE_INT in_table = TEST_HARD_REG_BIT (hard_regs_in_table, regno);
1840 : 122426467 : unsigned int endregno = END_REGNO (x);
1841 : 122426467 : unsigned int rn;
1842 : 122426467 : struct table_elt *p, *next;
1843 : :
1844 : 122426467 : CLEAR_HARD_REG_BIT (hard_regs_in_table, regno);
1845 : :
1846 : 123010247 : for (rn = regno + 1; rn < endregno; rn++)
1847 : : {
1848 : 583780 : in_table |= TEST_HARD_REG_BIT (hard_regs_in_table, rn);
1849 : 583780 : CLEAR_HARD_REG_BIT (hard_regs_in_table, rn);
1850 : 583780 : delete_reg_equiv (rn);
1851 : 583780 : REG_TICK (rn)++;
1852 : 583780 : SUBREG_TICKED (rn) = -1;
1853 : : }
1854 : :
1855 : 122426467 : if (in_table)
1856 : 378344175 : for (hash = 0; hash < HASH_SIZE; hash++)
1857 : 586025185 : for (p = table[hash]; p; p = next)
1858 : : {
1859 : 219145985 : next = p->next_same_hash;
1860 : :
1861 : 219145985 : if (!REG_P (p->exp) || REGNO (p->exp) >= FIRST_PSEUDO_REGISTER)
1862 : 209436120 : continue;
1863 : :
1864 : 9709865 : unsigned int tregno = REGNO (p->exp);
1865 : 9709865 : unsigned int tendregno = END_REGNO (p->exp);
1866 : 9709865 : if (tendregno > regno && tregno < endregno)
1867 : 9645993 : remove_from_table (p, hash);
1868 : : }
1869 : : }
1870 : 206650105 : }
1871 : :
1872 : : /* Remove from the hash table, or mark as invalid, all expressions whose
1873 : : values could be altered by storing in X. X is a register, a subreg, or
1874 : : a memory reference with nonvarying address (because, when a memory
1875 : : reference with a varying address is stored in, all memory references are
1876 : : removed by invalidate_memory so specific invalidation is superfluous).
1877 : : FULL_MODE, if not VOIDmode, indicates that this much should be
1878 : : invalidated instead of just the amount indicated by the mode of X. This
1879 : : is only used for bitfield stores into memory.
1880 : :
1881 : : A nonvarying address may be just a register or just a symbol reference,
1882 : : or it may be either of those plus a numeric offset. */
1883 : :
1884 : : static void
1885 : 232909504 : invalidate (rtx x, machine_mode full_mode)
1886 : : {
1887 : 234387271 : int i;
1888 : 234387271 : struct table_elt *p;
1889 : 234387271 : rtx addr;
1890 : :
1891 : 234387271 : switch (GET_CODE (x))
1892 : : {
1893 : 206650105 : case REG:
1894 : 206650105 : invalidate_reg (x);
1895 : 206650105 : return;
1896 : :
1897 : 1437167 : case SUBREG:
1898 : 1437167 : invalidate (SUBREG_REG (x), VOIDmode);
1899 : 1437167 : return;
1900 : :
1901 : 22418 : case PARALLEL:
1902 : 63018 : for (i = XVECLEN (x, 0) - 1; i >= 0; --i)
1903 : 40600 : invalidate (XVECEXP (x, 0, i), VOIDmode);
1904 : : return;
1905 : :
1906 : 40600 : case EXPR_LIST:
1907 : : /* This is part of a disjoint return value; extract the location in
1908 : : question ignoring the offset. */
1909 : 40600 : invalidate (XEXP (x, 0), VOIDmode);
1910 : 40600 : return;
1911 : :
1912 : 26236981 : case MEM:
1913 : 26236981 : addr = canon_rtx (get_addr (XEXP (x, 0)));
1914 : : /* Calculate the canonical version of X here so that
1915 : : true_dependence doesn't generate new RTL for X on each call. */
1916 : 26236981 : x = canon_rtx (x);
1917 : :
1918 : : /* Remove all hash table elements that refer to overlapping pieces of
1919 : : memory. */
1920 : 26236981 : if (full_mode == VOIDmode)
1921 : 26236029 : full_mode = GET_MODE (x);
1922 : :
1923 : 865820373 : for (i = 0; i < HASH_SIZE; i++)
1924 : : {
1925 : 839583392 : struct table_elt *next;
1926 : :
1927 : 1729388820 : for (p = table[i]; p; p = next)
1928 : : {
1929 : 889805428 : next = p->next_same_hash;
1930 : 889805428 : if (p->in_memory)
1931 : : {
1932 : : /* Just canonicalize the expression once;
1933 : : otherwise each time we call invalidate
1934 : : true_dependence will canonicalize the
1935 : : expression again. */
1936 : 172252304 : if (!p->canon_exp)
1937 : 24563765 : p->canon_exp = canon_rtx (p->exp);
1938 : 172252304 : if (check_dependence (p->canon_exp, x, full_mode, addr))
1939 : 7471096 : remove_from_table (p, i);
1940 : : }
1941 : : }
1942 : : }
1943 : : return;
1944 : :
1945 : 0 : default:
1946 : 0 : gcc_unreachable ();
1947 : : }
1948 : : }
1949 : :
1950 : : /* Invalidate DEST. Used when DEST is not going to be added
1951 : : into the hash table for some reason, e.g. do_not_record
1952 : : flagged on it. */
1953 : :
1954 : : static void
1955 : 52005097 : invalidate_dest (rtx dest)
1956 : : {
1957 : 52005097 : if (REG_P (dest)
1958 : 24999387 : || GET_CODE (dest) == SUBREG
1959 : 24999387 : || MEM_P (dest))
1960 : 33550428 : invalidate (dest, VOIDmode);
1961 : 18454669 : else if (GET_CODE (dest) == STRICT_LOW_PART
1962 : 18454669 : || GET_CODE (dest) == ZERO_EXTRACT)
1963 : 960 : invalidate (XEXP (dest, 0), GET_MODE (dest));
1964 : 52005097 : }
1965 : :
1966 : : /* Remove all expressions that refer to register REGNO,
1967 : : since they are already invalid, and we are about to
1968 : : mark that register valid again and don't want the old
1969 : : expressions to reappear as valid. */
1970 : :
1971 : : static void
1972 : 12874106 : remove_invalid_refs (unsigned int regno)
1973 : : {
1974 : 12874106 : unsigned int i;
1975 : 12874106 : struct table_elt *p, *next;
1976 : :
1977 : 424845498 : for (i = 0; i < HASH_SIZE; i++)
1978 : 655188847 : for (p = table[i]; p; p = next)
1979 : : {
1980 : 243217455 : next = p->next_same_hash;
1981 : 243217455 : if (!REG_P (p->exp) && refers_to_regno_p (regno, p->exp))
1982 : 16430459 : remove_from_table (p, i);
1983 : : }
1984 : 12874106 : }
1985 : :
1986 : : /* Likewise for a subreg with subreg_reg REGNO, subreg_byte OFFSET,
1987 : : and mode MODE. */
1988 : : static void
1989 : 0 : remove_invalid_subreg_refs (unsigned int regno, poly_uint64 offset,
1990 : : machine_mode mode)
1991 : : {
1992 : 0 : unsigned int i;
1993 : 0 : struct table_elt *p, *next;
1994 : :
1995 : 0 : for (i = 0; i < HASH_SIZE; i++)
1996 : 0 : for (p = table[i]; p; p = next)
1997 : : {
1998 : 0 : rtx exp = p->exp;
1999 : 0 : next = p->next_same_hash;
2000 : :
2001 : 0 : if (!REG_P (exp)
2002 : 0 : && (GET_CODE (exp) != SUBREG
2003 : 0 : || !REG_P (SUBREG_REG (exp))
2004 : 0 : || REGNO (SUBREG_REG (exp)) != regno
2005 : 0 : || ranges_maybe_overlap_p (SUBREG_BYTE (exp),
2006 : 0 : GET_MODE_SIZE (GET_MODE (exp)),
2007 : 0 : offset, GET_MODE_SIZE (mode)))
2008 : 0 : && refers_to_regno_p (regno, p->exp))
2009 : 0 : remove_from_table (p, i);
2010 : : }
2011 : 0 : }
2012 : :
2013 : : /* Recompute the hash codes of any valid entries in the hash table that
2014 : : reference X, if X is a register, or SUBREG_REG (X) if X is a SUBREG.
2015 : :
2016 : : This is called when we make a jump equivalence. */
2017 : :
2018 : : static void
2019 : 116213833 : rehash_using_reg (rtx x)
2020 : : {
2021 : 116213833 : unsigned int i;
2022 : 116213833 : struct table_elt *p, *next;
2023 : 116213833 : unsigned hash;
2024 : :
2025 : 116213833 : if (GET_CODE (x) == SUBREG)
2026 : 1704339 : x = SUBREG_REG (x);
2027 : :
2028 : : /* If X is not a register or if the register is known not to be in any
2029 : : valid entries in the table, we have no work to do. */
2030 : :
2031 : 116213833 : if (!REG_P (x)
2032 : 107249178 : || REG_IN_TABLE (REGNO (x)) < 0
2033 : 120818588 : || REG_IN_TABLE (REGNO (x)) != REG_TICK (REGNO (x)))
2034 : 111609449 : return;
2035 : :
2036 : : /* Scan all hash chains looking for valid entries that mention X.
2037 : : If we find one and it is in the wrong hash chain, move it. */
2038 : :
2039 : 151944672 : for (i = 0; i < HASH_SIZE; i++)
2040 : 245616161 : for (p = table[i]; p; p = next)
2041 : : {
2042 : 98275873 : next = p->next_same_hash;
2043 : 98275873 : if (reg_mentioned_p (x, p->exp)
2044 : 4200556 : && exp_equiv_p (p->exp, p->exp, 1, false)
2045 : 102476193 : && i != (hash = SAFE_HASH (p->exp, p->mode)))
2046 : : {
2047 : 2989106 : if (p->next_same_hash)
2048 : 993644 : p->next_same_hash->prev_same_hash = p->prev_same_hash;
2049 : :
2050 : 2989106 : if (p->prev_same_hash)
2051 : 576844 : p->prev_same_hash->next_same_hash = p->next_same_hash;
2052 : : else
2053 : 2412262 : table[i] = p->next_same_hash;
2054 : :
2055 : 2989106 : p->next_same_hash = table[hash];
2056 : 2989106 : p->prev_same_hash = 0;
2057 : 2989106 : if (table[hash])
2058 : 1485799 : table[hash]->prev_same_hash = p;
2059 : 2989106 : table[hash] = p;
2060 : : }
2061 : : }
2062 : : }
2063 : :
2064 : : /* Remove from the hash table any expression that is a call-clobbered
2065 : : register in INSN. Also update their TICK values. */
2066 : :
2067 : : static void
2068 : 14773328 : invalidate_for_call (rtx_insn *insn)
2069 : : {
2070 : 14773328 : unsigned int regno;
2071 : 14773328 : unsigned hash;
2072 : 14773328 : struct table_elt *p, *next;
2073 : 14773328 : int in_table = 0;
2074 : 14773328 : hard_reg_set_iterator hrsi;
2075 : :
2076 : : /* Go through all the hard registers. For each that might be clobbered
2077 : : in call insn INSN, remove the register from quantity chains and update
2078 : : reg_tick if defined. Also see if any of these registers is currently
2079 : : in the table.
2080 : :
2081 : : ??? We could be more precise for partially-clobbered registers,
2082 : : and only invalidate values that actually occupy the clobbered part
2083 : : of the registers. It doesn't seem worth the effort though, since
2084 : : we shouldn't see this situation much before RA. Whatever choice
2085 : : we make here has to be consistent with the table walk below,
2086 : : so any change to this test will require a change there too. */
2087 : 14773328 : HARD_REG_SET callee_clobbers
2088 : 14773328 : = insn_callee_abi (insn).full_and_partial_reg_clobbers ();
2089 : 1221559633 : EXECUTE_IF_SET_IN_HARD_REG_SET (callee_clobbers, 0, regno, hrsi)
2090 : : {
2091 : 1206786305 : delete_reg_equiv (regno);
2092 : 1206786305 : if (REG_TICK (regno) >= 0)
2093 : : {
2094 : 1206786305 : REG_TICK (regno)++;
2095 : 1206786305 : SUBREG_TICKED (regno) = -1;
2096 : : }
2097 : 1206786305 : in_table |= (TEST_HARD_REG_BIT (hard_regs_in_table, regno) != 0);
2098 : : }
2099 : :
2100 : : /* In the case where we have no call-clobbered hard registers in the
2101 : : table, we are done. Otherwise, scan the table and remove any
2102 : : entry that overlaps a call-clobbered register. */
2103 : :
2104 : 14773328 : if (in_table)
2105 : 116136570 : for (hash = 0; hash < HASH_SIZE; hash++)
2106 : 165918473 : for (p = table[hash]; p; p = next)
2107 : : {
2108 : 53301193 : next = p->next_same_hash;
2109 : :
2110 : 103576998 : if (!REG_P (p->exp)
2111 : 53301193 : || REGNO (p->exp) >= FIRST_PSEUDO_REGISTER)
2112 : 50275805 : continue;
2113 : :
2114 : : /* This must use the same test as above rather than the
2115 : : more accurate clobbers_reg_p. */
2116 : 3025388 : if (overlaps_hard_reg_set_p (callee_clobbers, GET_MODE (p->exp),
2117 : 3025388 : REGNO (p->exp)))
2118 : 3006265 : remove_from_table (p, hash);
2119 : : }
2120 : 14773328 : }
2121 : :
2122 : : /* Given an expression X of type CONST,
2123 : : and ELT which is its table entry (or 0 if it
2124 : : is not in the hash table),
2125 : : return an alternate expression for X as a register plus integer.
2126 : : If none can be found, return 0. */
2127 : :
2128 : : static rtx
2129 : 673095 : use_related_value (rtx x, struct table_elt *elt)
2130 : : {
2131 : 673095 : struct table_elt *relt = 0;
2132 : 673095 : struct table_elt *p, *q;
2133 : 673095 : HOST_WIDE_INT offset;
2134 : :
2135 : : /* First, is there anything related known?
2136 : : If we have a table element, we can tell from that.
2137 : : Otherwise, must look it up. */
2138 : :
2139 : 673095 : if (elt != 0 && elt->related_value != 0)
2140 : : relt = elt;
2141 : 518816 : else if (elt == 0 && GET_CODE (x) == CONST)
2142 : : {
2143 : 518816 : rtx subexp = get_related_value (x);
2144 : 518816 : if (subexp != 0)
2145 : 505174 : relt = lookup (subexp,
2146 : : SAFE_HASH (subexp, GET_MODE (subexp)),
2147 : 505174 : GET_MODE (subexp));
2148 : : }
2149 : :
2150 : 618576 : if (relt == 0)
2151 : 365459 : return 0;
2152 : :
2153 : : /* Search all related table entries for one that has an
2154 : : equivalent register. */
2155 : :
2156 : : p = relt;
2157 : 819776 : while (1)
2158 : : {
2159 : : /* This loop is strange in that it is executed in two different cases.
2160 : : The first is when X is already in the table. Then it is searching
2161 : : the RELATED_VALUE list of X's class (RELT). The second case is when
2162 : : X is not in the table. Then RELT points to a class for the related
2163 : : value.
2164 : :
2165 : : Ensure that, whatever case we are in, that we ignore classes that have
2166 : : the same value as X. */
2167 : :
2168 : 819776 : if (rtx_equal_p (x, p->exp))
2169 : : q = 0;
2170 : : else
2171 : 1624468 : for (q = p->first_same_value; q; q = q->next_same_value)
2172 : 1142484 : if (REG_P (q->exp))
2173 : : break;
2174 : :
2175 : 706374 : if (q)
2176 : : break;
2177 : :
2178 : 595386 : p = p->related_value;
2179 : :
2180 : : /* We went all the way around, so there is nothing to be found.
2181 : : Alternatively, perhaps RELT was in the table for some other reason
2182 : : and it has no related values recorded. */
2183 : 595386 : if (p == relt || p == 0)
2184 : : break;
2185 : : }
2186 : :
2187 : 307636 : if (q == 0)
2188 : : return 0;
2189 : :
2190 : 224390 : offset = (get_integer_term (x) - get_integer_term (p->exp));
2191 : : /* Note: OFFSET may be 0 if P->xexp and X are related by commutativity. */
2192 : 224390 : return plus_constant (q->mode, q->exp, offset);
2193 : : }
2194 : :
2195 : :
2196 : : /* Hash a string. Just add its bytes up. */
2197 : : static inline unsigned
2198 : 131516 : hash_rtx_string (const char *ps)
2199 : : {
2200 : 131516 : unsigned hash = 0;
2201 : 131516 : const unsigned char *p = (const unsigned char *) ps;
2202 : :
2203 : 131516 : if (p)
2204 : 761554 : while (*p)
2205 : 630038 : hash += *p++;
2206 : :
2207 : 131516 : return hash;
2208 : : }
2209 : :
2210 : : /* Hash an rtx. We are careful to make sure the value is never negative.
2211 : : Equivalent registers hash identically.
2212 : : MODE is used in hashing for CONST_INTs only;
2213 : : otherwise the mode of X is used.
2214 : :
2215 : : Store 1 in DO_NOT_RECORD_P if any subexpression is volatile.
2216 : :
2217 : : If HASH_ARG_IN_MEMORY_P is not NULL, store 1 in it if X contains
2218 : : a MEM rtx which does not have the MEM_READONLY_P flag set.
2219 : :
2220 : : Note that cse_insn knows that the hash code of a MEM expression
2221 : : is just (int) MEM plus the hash code of the address.
2222 : :
2223 : : Call CB on each rtx if CB is not NULL.
2224 : : When the callback returns true, we continue with the new rtx. */
2225 : :
2226 : : unsigned
2227 : 1185391838 : hash_rtx (const_rtx x, machine_mode mode,
2228 : : int *do_not_record_p, int *hash_arg_in_memory_p,
2229 : : bool have_reg_qty, hash_rtx_callback_function cb)
2230 : : {
2231 : 1185391838 : int i, j;
2232 : 1185391838 : unsigned hash = 0;
2233 : 1743666892 : enum rtx_code code;
2234 : 1743666892 : const char *fmt;
2235 : 1743666892 : machine_mode newmode;
2236 : 1743666892 : rtx newx;
2237 : :
2238 : : /* Used to turn recursion into iteration. We can't rely on GCC's
2239 : : tail-recursion elimination since we need to keep accumulating values
2240 : : in HASH. */
2241 : 1743666892 : repeat:
2242 : 1743666892 : if (x == 0)
2243 : : return hash;
2244 : :
2245 : : /* Invoke the callback first. */
2246 : 1743666892 : if (cb != NULL
2247 : 1743666892 : && ((*cb) (x, mode, &newx, &newmode)))
2248 : : {
2249 : 0 : hash += hash_rtx (newx, newmode, do_not_record_p,
2250 : : hash_arg_in_memory_p, have_reg_qty, cb);
2251 : 0 : return hash;
2252 : : }
2253 : :
2254 : 1743666892 : code = GET_CODE (x);
2255 : 1743666892 : switch (code)
2256 : : {
2257 : 608953501 : case REG:
2258 : 608953501 : {
2259 : 608953501 : unsigned int regno = REGNO (x);
2260 : :
2261 : 608953501 : if (do_not_record_p && !reload_completed)
2262 : : {
2263 : : /* On some machines, we can't record any non-fixed hard register,
2264 : : because extending its life will cause reload problems. We
2265 : : consider ap, fp, sp, gp to be fixed for this purpose.
2266 : :
2267 : : We also consider CCmode registers to be fixed for this purpose;
2268 : : failure to do so leads to failure to simplify 0<100 type of
2269 : : conditionals.
2270 : :
2271 : : On all machines, we can't record any global registers.
2272 : : Nor should we record any register that is in a small
2273 : : class, as defined by TARGET_CLASS_LIKELY_SPILLED_P. */
2274 : 605848384 : bool record;
2275 : :
2276 : 605848384 : if (regno >= FIRST_PSEUDO_REGISTER)
2277 : : record = true;
2278 : 409938334 : else if (x == frame_pointer_rtx
2279 : 286021958 : || x == hard_frame_pointer_rtx
2280 : 285907439 : || x == arg_pointer_rtx
2281 : 278358344 : || x == stack_pointer_rtx
2282 : 243561741 : || x == pic_offset_table_rtx)
2283 : : record = true;
2284 : 243561741 : else if (global_regs[regno])
2285 : : record = false;
2286 : 243561380 : else if (fixed_regs[regno])
2287 : : record = true;
2288 : 74301882 : else if (GET_MODE_CLASS (GET_MODE (x)) == MODE_CC)
2289 : : record = true;
2290 : 74301882 : else if (targetm.small_register_classes_for_mode_p (GET_MODE (x)))
2291 : : record = false;
2292 : 0 : else if (targetm.class_likely_spilled_p (REGNO_REG_CLASS (regno)))
2293 : : record = false;
2294 : : else
2295 : : record = true;
2296 : :
2297 : : if (!record)
2298 : : {
2299 : 74302243 : *do_not_record_p = 1;
2300 : 74302243 : return 0;
2301 : : }
2302 : : }
2303 : :
2304 : 534651258 : hash += ((unsigned int) REG << 7);
2305 : 534651258 : hash += (have_reg_qty ? (unsigned) REG_QTY (regno) : regno);
2306 : 534651258 : return hash;
2307 : : }
2308 : :
2309 : : /* We handle SUBREG of a REG specially because the underlying
2310 : : reg changes its hash value with every value change; we don't
2311 : : want to have to forget unrelated subregs when one subreg changes. */
2312 : 32085317 : case SUBREG:
2313 : 32085317 : {
2314 : 32085317 : if (REG_P (SUBREG_REG (x)))
2315 : : {
2316 : 64067700 : hash += (((unsigned int) SUBREG << 7)
2317 : 32033850 : + REGNO (SUBREG_REG (x))
2318 : 32033850 : + (constant_lower_bound (SUBREG_BYTE (x))
2319 : 32033850 : / UNITS_PER_WORD));
2320 : 32033850 : return hash;
2321 : : }
2322 : : break;
2323 : : }
2324 : :
2325 : 314283854 : case CONST_INT:
2326 : 314283854 : hash += (((unsigned int) CONST_INT << 7) + (unsigned int) mode
2327 : 314283854 : + (unsigned int) INTVAL (x));
2328 : 314283854 : return hash;
2329 : :
2330 : : case CONST_WIDE_INT:
2331 : 3035640 : for (i = 0; i < CONST_WIDE_INT_NUNITS (x); i++)
2332 : 2023972 : hash += CONST_WIDE_INT_ELT (x, i);
2333 : : return hash;
2334 : :
2335 : 0 : case CONST_POLY_INT:
2336 : 0 : {
2337 : 0 : inchash::hash h;
2338 : 0 : h.add_int (hash);
2339 : 0 : for (unsigned int i = 0; i < NUM_POLY_INT_COEFFS; ++i)
2340 : 0 : h.add_wide_int (CONST_POLY_INT_COEFFS (x)[i]);
2341 : 0 : return h.end ();
2342 : : }
2343 : :
2344 : 4328701 : case CONST_DOUBLE:
2345 : : /* This is like the general case, except that it only counts
2346 : : the integers representing the constant. */
2347 : 4328701 : hash += (unsigned int) code + (unsigned int) GET_MODE (x);
2348 : 4328701 : if (TARGET_SUPPORTS_WIDE_INT == 0 && GET_MODE (x) == VOIDmode)
2349 : : hash += ((unsigned int) CONST_DOUBLE_LOW (x)
2350 : : + (unsigned int) CONST_DOUBLE_HIGH (x));
2351 : : else
2352 : 4328701 : hash += real_hash (CONST_DOUBLE_REAL_VALUE (x));
2353 : 4328701 : return hash;
2354 : :
2355 : 0 : case CONST_FIXED:
2356 : 0 : hash += (unsigned int) code + (unsigned int) GET_MODE (x);
2357 : 0 : hash += fixed_hash (CONST_FIXED_VALUE (x));
2358 : 0 : return hash;
2359 : :
2360 : 3238921 : case CONST_VECTOR:
2361 : 3238921 : {
2362 : 3238921 : int units;
2363 : 3238921 : rtx elt;
2364 : :
2365 : 3238921 : units = const_vector_encoded_nelts (x);
2366 : :
2367 : 9016914 : for (i = 0; i < units; ++i)
2368 : : {
2369 : 5777993 : elt = CONST_VECTOR_ENCODED_ELT (x, i);
2370 : 5777993 : hash += hash_rtx (elt, GET_MODE (elt),
2371 : : do_not_record_p, hash_arg_in_memory_p,
2372 : : have_reg_qty, cb);
2373 : : }
2374 : :
2375 : : return hash;
2376 : : }
2377 : :
2378 : : /* Assume there is only one rtx object for any given label. */
2379 : 18682334 : case LABEL_REF:
2380 : : /* We don't hash on the address of the CODE_LABEL to avoid bootstrap
2381 : : differences and differences between each stage's debugging dumps. */
2382 : 18682334 : hash += (((unsigned int) LABEL_REF << 7)
2383 : 18682334 : + CODE_LABEL_NUMBER (label_ref_label (x)));
2384 : 18682334 : return hash;
2385 : :
2386 : 142961124 : case SYMBOL_REF:
2387 : 142961124 : {
2388 : : /* Don't hash on the symbol's address to avoid bootstrap differences.
2389 : : Different hash values may cause expressions to be recorded in
2390 : : different orders and thus different registers to be used in the
2391 : : final assembler. This also avoids differences in the dump files
2392 : : between various stages. */
2393 : 142961124 : unsigned int h = 0;
2394 : 142961124 : const unsigned char *p = (const unsigned char *) XSTR (x, 0);
2395 : :
2396 : 3116250220 : while (*p)
2397 : 2973289096 : h += (h << 7) + *p++; /* ??? revisit */
2398 : :
2399 : 142961124 : hash += ((unsigned int) SYMBOL_REF << 7) + h;
2400 : 142961124 : return hash;
2401 : : }
2402 : :
2403 : 245139036 : case MEM:
2404 : : /* We don't record if marked volatile or if BLKmode since we don't
2405 : : know the size of the move. */
2406 : 245139036 : if (do_not_record_p && (MEM_VOLATILE_P (x) || GET_MODE (x) == BLKmode))
2407 : : {
2408 : 5288723 : *do_not_record_p = 1;
2409 : 5288723 : return 0;
2410 : : }
2411 : 239850313 : if (hash_arg_in_memory_p && !MEM_READONLY_P (x))
2412 : 54831313 : *hash_arg_in_memory_p = 1;
2413 : :
2414 : : /* Now that we have already found this special case,
2415 : : might as well speed it up as much as possible. */
2416 : 239850313 : hash += (unsigned) MEM;
2417 : 239850313 : x = XEXP (x, 0);
2418 : 239850313 : goto repeat;
2419 : :
2420 : 64 : case USE:
2421 : : /* A USE that mentions non-volatile memory needs special
2422 : : handling since the MEM may be BLKmode which normally
2423 : : prevents an entry from being made. Pure calls are
2424 : : marked by a USE which mentions BLKmode memory.
2425 : : See calls.cc:emit_call_1. */
2426 : 64 : if (MEM_P (XEXP (x, 0))
2427 : 64 : && ! MEM_VOLATILE_P (XEXP (x, 0)))
2428 : : {
2429 : 0 : hash += (unsigned) USE;
2430 : 0 : x = XEXP (x, 0);
2431 : :
2432 : 0 : if (hash_arg_in_memory_p && !MEM_READONLY_P (x))
2433 : 0 : *hash_arg_in_memory_p = 1;
2434 : :
2435 : : /* Now that we have already found this special case,
2436 : : might as well speed it up as much as possible. */
2437 : 0 : hash += (unsigned) MEM;
2438 : 0 : x = XEXP (x, 0);
2439 : 0 : goto repeat;
2440 : : }
2441 : : break;
2442 : :
2443 : 48373918 : case PRE_DEC:
2444 : 48373918 : case PRE_INC:
2445 : 48373918 : case POST_DEC:
2446 : 48373918 : case POST_INC:
2447 : 48373918 : case PRE_MODIFY:
2448 : 48373918 : case POST_MODIFY:
2449 : 48373918 : case PC:
2450 : 48373918 : case CALL:
2451 : 48373918 : case UNSPEC_VOLATILE:
2452 : 48373918 : if (do_not_record_p) {
2453 : 48372340 : *do_not_record_p = 1;
2454 : 48372340 : return 0;
2455 : : }
2456 : : else
2457 : : return hash;
2458 : 183496 : break;
2459 : :
2460 : 183496 : case ASM_OPERANDS:
2461 : 183496 : if (do_not_record_p && MEM_VOLATILE_P (x))
2462 : : {
2463 : 146682 : *do_not_record_p = 1;
2464 : 146682 : return 0;
2465 : : }
2466 : : else
2467 : : {
2468 : : /* We don't want to take the filename and line into account. */
2469 : 73628 : hash += (unsigned) code + (unsigned) GET_MODE (x)
2470 : 36814 : + hash_rtx_string (ASM_OPERANDS_TEMPLATE (x))
2471 : 36814 : + hash_rtx_string (ASM_OPERANDS_OUTPUT_CONSTRAINT (x))
2472 : 36814 : + (unsigned) ASM_OPERANDS_OUTPUT_IDX (x);
2473 : :
2474 : 36814 : if (ASM_OPERANDS_INPUT_LENGTH (x))
2475 : : {
2476 : 57888 : for (i = 1; i < ASM_OPERANDS_INPUT_LENGTH (x); i++)
2477 : : {
2478 : 51560 : hash += (hash_rtx (ASM_OPERANDS_INPUT (x, i),
2479 : 25780 : GET_MODE (ASM_OPERANDS_INPUT (x, i)),
2480 : : do_not_record_p, hash_arg_in_memory_p,
2481 : : have_reg_qty, cb)
2482 : 25780 : + hash_rtx_string
2483 : 51560 : (ASM_OPERANDS_INPUT_CONSTRAINT (x, i)));
2484 : : }
2485 : :
2486 : 32108 : hash += hash_rtx_string (ASM_OPERANDS_INPUT_CONSTRAINT (x, 0));
2487 : 32108 : x = ASM_OPERANDS_INPUT (x, 0);
2488 : 32108 : mode = GET_MODE (x);
2489 : 32108 : goto repeat;
2490 : : }
2491 : :
2492 : : return hash;
2493 : : }
2494 : : break;
2495 : :
2496 : : default:
2497 : : break;
2498 : : }
2499 : :
2500 : 324476489 : i = GET_RTX_LENGTH (code) - 1;
2501 : 324476489 : hash += (unsigned) code + (unsigned) GET_MODE (x);
2502 : 324476489 : fmt = GET_RTX_FORMAT (code);
2503 : 657015622 : for (; i >= 0; i--)
2504 : : {
2505 : 650931766 : switch (fmt[i])
2506 : : {
2507 : 639758021 : case 'e':
2508 : : /* If we are about to do the last recursive call
2509 : : needed at this level, change it into iteration.
2510 : : This function is called enough to be worth it. */
2511 : 639758021 : if (i == 0)
2512 : : {
2513 : 318392633 : x = XEXP (x, i);
2514 : 318392633 : goto repeat;
2515 : : }
2516 : :
2517 : 321365388 : hash += hash_rtx (XEXP (x, i), VOIDmode, do_not_record_p,
2518 : : hash_arg_in_memory_p,
2519 : : have_reg_qty, cb);
2520 : 321365388 : break;
2521 : :
2522 : : case 'E':
2523 : 15426433 : for (j = 0; j < XVECLEN (x, i); j++)
2524 : 9342837 : hash += hash_rtx (XVECEXP (x, i, j), VOIDmode, do_not_record_p,
2525 : : hash_arg_in_memory_p,
2526 : : have_reg_qty, cb);
2527 : : break;
2528 : :
2529 : 0 : case 's':
2530 : 0 : hash += hash_rtx_string (XSTR (x, i));
2531 : 0 : break;
2532 : :
2533 : 5038630 : case 'i':
2534 : 5038630 : hash += (unsigned int) XINT (x, i);
2535 : 5038630 : break;
2536 : :
2537 : 0 : case 'L':
2538 : 0 : hash += (unsigned int) XLOC (x, i);
2539 : 0 : break;
2540 : :
2541 : 51467 : case 'p':
2542 : 51467 : hash += constant_lower_bound (SUBREG_BYTE (x));
2543 : 51467 : break;
2544 : :
2545 : : case '0': case 't':
2546 : : /* Unused. */
2547 : : break;
2548 : :
2549 : 0 : default:
2550 : 0 : gcc_unreachable ();
2551 : : }
2552 : : }
2553 : :
2554 : : return hash;
2555 : : }
2556 : :
2557 : : /* Hash an rtx X for cse via hash_rtx.
2558 : : Stores 1 in do_not_record if any subexpression is volatile.
2559 : : Stores 1 in hash_arg_in_memory if X contains a mem rtx which
2560 : : does not have the MEM_READONLY_P flag set. */
2561 : :
2562 : : static inline unsigned
2563 : 482115264 : canon_hash (rtx x, machine_mode mode)
2564 : : {
2565 : 482115264 : return hash_rtx (x, mode, &do_not_record, &hash_arg_in_memory, true);
2566 : : }
2567 : :
2568 : : /* Like canon_hash but with no side effects, i.e. do_not_record
2569 : : and hash_arg_in_memory are not changed. */
2570 : :
2571 : : static inline unsigned
2572 : 152130375 : safe_hash (rtx x, machine_mode mode)
2573 : : {
2574 : 152130375 : int dummy_do_not_record;
2575 : 152130375 : return hash_rtx (x, mode, &dummy_do_not_record, NULL, true);
2576 : : }
2577 : :
2578 : : /* Return true iff X and Y would canonicalize into the same thing,
2579 : : without actually constructing the canonicalization of either one.
2580 : : If VALIDATE is nonzero,
2581 : : we assume X is an expression being processed from the rtl
2582 : : and Y was found in the hash table. We check register refs
2583 : : in Y for being marked as valid.
2584 : :
2585 : : If FOR_GCSE is true, we compare X and Y for equivalence for GCSE. */
2586 : :
2587 : : bool
2588 : 692440814 : exp_equiv_p (const_rtx x, const_rtx y, int validate, bool for_gcse)
2589 : : {
2590 : 692440814 : int i, j;
2591 : 692440814 : enum rtx_code code;
2592 : 692440814 : const char *fmt;
2593 : :
2594 : : /* Note: it is incorrect to assume an expression is equivalent to itself
2595 : : if VALIDATE is nonzero. */
2596 : 692440814 : if (x == y && !validate)
2597 : : return true;
2598 : :
2599 : 671552125 : if (x == 0 || y == 0)
2600 : : return x == y;
2601 : :
2602 : 671552125 : code = GET_CODE (x);
2603 : 671552125 : if (code != GET_CODE (y))
2604 : : return false;
2605 : :
2606 : : /* (MULT:SI x y) and (MULT:HI x y) are NOT equivalent. */
2607 : 571036184 : if (GET_MODE (x) != GET_MODE (y))
2608 : : return false;
2609 : :
2610 : : /* MEMs referring to different address space are not equivalent. */
2611 : 595592461 : if (code == MEM && MEM_ADDR_SPACE (x) != MEM_ADDR_SPACE (y))
2612 : : return false;
2613 : :
2614 : 502049849 : switch (code)
2615 : : {
2616 : : case PC:
2617 : : CASE_CONST_UNIQUE:
2618 : : return x == y;
2619 : :
2620 : : case CONST_VECTOR:
2621 : : if (!same_vector_encodings_p (x, y))
2622 : : return false;
2623 : : break;
2624 : :
2625 : 21946 : case LABEL_REF:
2626 : 21946 : return label_ref_label (x) == label_ref_label (y);
2627 : :
2628 : 16194568 : case SYMBOL_REF:
2629 : 16194568 : return XSTR (x, 0) == XSTR (y, 0);
2630 : :
2631 : 150541105 : case REG:
2632 : 150541105 : if (for_gcse)
2633 : 974895 : return REGNO (x) == REGNO (y);
2634 : : else
2635 : : {
2636 : 149566210 : unsigned int regno = REGNO (y);
2637 : 149566210 : unsigned int i;
2638 : 149566210 : unsigned int endregno = END_REGNO (y);
2639 : :
2640 : : /* If the quantities are not the same, the expressions are not
2641 : : equivalent. If there are and we are not to validate, they
2642 : : are equivalent. Otherwise, ensure all regs are up-to-date. */
2643 : :
2644 : 149566210 : if (REG_QTY (REGNO (x)) != REG_QTY (regno))
2645 : : return false;
2646 : :
2647 : 136797425 : if (! validate)
2648 : : return true;
2649 : :
2650 : 252307689 : for (i = regno; i < endregno; i++)
2651 : 127360911 : if (REG_IN_TABLE (i) != REG_TICK (i))
2652 : : return false;
2653 : :
2654 : : return true;
2655 : : }
2656 : :
2657 : 92822107 : case MEM:
2658 : 92822107 : if (for_gcse)
2659 : : {
2660 : : /* A volatile mem should not be considered equivalent to any
2661 : : other. */
2662 : 53542400 : if (MEM_VOLATILE_P (x) || MEM_VOLATILE_P (y))
2663 : : return false;
2664 : :
2665 : : /* Can't merge two expressions in different alias sets, since we
2666 : : can decide that the expression is transparent in a block when
2667 : : it isn't, due to it being set with the different alias set.
2668 : :
2669 : : Also, can't merge two expressions with different MEM_ATTRS.
2670 : : They could e.g. be two different entities allocated into the
2671 : : same space on the stack (see e.g. PR25130). In that case, the
2672 : : MEM addresses can be the same, even though the two MEMs are
2673 : : absolutely not equivalent.
2674 : :
2675 : : But because really all MEM attributes should be the same for
2676 : : equivalent MEMs, we just use the invariant that MEMs that have
2677 : : the same attributes share the same mem_attrs data structure. */
2678 : 53437098 : if (!mem_attrs_eq_p (MEM_ATTRS (x), MEM_ATTRS (y)))
2679 : : return false;
2680 : :
2681 : : /* If we are handling exceptions, we cannot consider two expressions
2682 : : with different trapping status as equivalent, because simple_mem
2683 : : might accept one and reject the other. */
2684 : 8041720 : if (cfun->can_throw_non_call_exceptions
2685 : 8041720 : && (MEM_NOTRAP_P (x) != MEM_NOTRAP_P (y)))
2686 : : return false;
2687 : : }
2688 : : break;
2689 : :
2690 : : /* For commutative operations, check both orders. */
2691 : 62698224 : case PLUS:
2692 : 62698224 : case MULT:
2693 : 62698224 : case AND:
2694 : 62698224 : case IOR:
2695 : 62698224 : case XOR:
2696 : 62698224 : case NE:
2697 : 62698224 : case EQ:
2698 : 62698224 : return ((exp_equiv_p (XEXP (x, 0), XEXP (y, 0),
2699 : : validate, for_gcse)
2700 : 57683013 : && exp_equiv_p (XEXP (x, 1), XEXP (y, 1),
2701 : : validate, for_gcse))
2702 : 69154949 : || (exp_equiv_p (XEXP (x, 0), XEXP (y, 1),
2703 : : validate, for_gcse)
2704 : 15106 : && exp_equiv_p (XEXP (x, 1), XEXP (y, 0),
2705 : : validate, for_gcse)));
2706 : :
2707 : 12642 : case ASM_OPERANDS:
2708 : : /* We don't use the generic code below because we want to
2709 : : disregard filename and line numbers. */
2710 : :
2711 : : /* A volatile asm isn't equivalent to any other. */
2712 : 12642 : if (MEM_VOLATILE_P (x) || MEM_VOLATILE_P (y))
2713 : : return false;
2714 : :
2715 : 12642 : if (GET_MODE (x) != GET_MODE (y)
2716 : 12642 : || strcmp (ASM_OPERANDS_TEMPLATE (x), ASM_OPERANDS_TEMPLATE (y))
2717 : 12642 : || strcmp (ASM_OPERANDS_OUTPUT_CONSTRAINT (x),
2718 : 12642 : ASM_OPERANDS_OUTPUT_CONSTRAINT (y))
2719 : 12632 : || ASM_OPERANDS_OUTPUT_IDX (x) != ASM_OPERANDS_OUTPUT_IDX (y)
2720 : 12632 : || ASM_OPERANDS_INPUT_LENGTH (x) != ASM_OPERANDS_INPUT_LENGTH (y))
2721 : : return false;
2722 : :
2723 : 12632 : if (ASM_OPERANDS_INPUT_LENGTH (x))
2724 : : {
2725 : 17070 : for (i = ASM_OPERANDS_INPUT_LENGTH (x) - 1; i >= 0; i--)
2726 : 8627 : if (! exp_equiv_p (ASM_OPERANDS_INPUT (x, i),
2727 : 8627 : ASM_OPERANDS_INPUT (y, i),
2728 : : validate, for_gcse)
2729 : 8627 : || strcmp (ASM_OPERANDS_INPUT_CONSTRAINT (x, i),
2730 : 8550 : ASM_OPERANDS_INPUT_CONSTRAINT (y, i)))
2731 : : return false;
2732 : : }
2733 : :
2734 : : return true;
2735 : :
2736 : : default:
2737 : : break;
2738 : : }
2739 : :
2740 : : /* Compare the elements. If any pair of corresponding elements
2741 : : fail to match, return 0 for the whole thing. */
2742 : :
2743 : 108917767 : fmt = GET_RTX_FORMAT (code);
2744 : 304553334 : for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
2745 : : {
2746 : 206866895 : switch (fmt[i])
2747 : : {
2748 : 141175235 : case 'e':
2749 : 141175235 : if (! exp_equiv_p (XEXP (x, i), XEXP (y, i),
2750 : : validate, for_gcse))
2751 : : return false;
2752 : : break;
2753 : :
2754 : 8205288 : case 'E':
2755 : 8205288 : if (XVECLEN (x, i) != XVECLEN (y, i))
2756 : : return 0;
2757 : 33073384 : for (j = 0; j < XVECLEN (x, i); j++)
2758 : 25694572 : if (! exp_equiv_p (XVECEXP (x, i, j), XVECEXP (y, i, j),
2759 : : validate, for_gcse))
2760 : : return false;
2761 : : break;
2762 : :
2763 : 0 : case 's':
2764 : 0 : if (strcmp (XSTR (x, i), XSTR (y, i)))
2765 : : return false;
2766 : : break;
2767 : :
2768 : 3402137 : case 'i':
2769 : 3402137 : if (XINT (x, i) != XINT (y, i))
2770 : : return false;
2771 : : break;
2772 : :
2773 : 0 : case 'L':
2774 : 0 : if (XLOC (x, i) != XLOC (y, i))
2775 : : return false;
2776 : : break;
2777 : :
2778 : 0 : case 'w':
2779 : 0 : if (XWINT (x, i) != XWINT (y, i))
2780 : : return false;
2781 : : break;
2782 : :
2783 : 6767242 : case 'p':
2784 : 6767242 : if (maybe_ne (SUBREG_BYTE (x), SUBREG_BYTE (y)))
2785 : : return false;
2786 : : break;
2787 : :
2788 : : case '0':
2789 : : case 't':
2790 : : break;
2791 : :
2792 : 0 : default:
2793 : 0 : gcc_unreachable ();
2794 : : }
2795 : : }
2796 : :
2797 : : return true;
2798 : : }
2799 : :
2800 : : /* Subroutine of canon_reg. Pass *XLOC through canon_reg, and validate
2801 : : the result if necessary. INSN is as for canon_reg. */
2802 : :
2803 : : static void
2804 : 918803202 : validate_canon_reg (rtx *xloc, rtx_insn *insn)
2805 : : {
2806 : 918803202 : if (*xloc)
2807 : : {
2808 : 918803202 : rtx new_rtx = canon_reg (*xloc, insn);
2809 : :
2810 : : /* If replacing pseudo with hard reg or vice versa, ensure the
2811 : : insn remains valid. Likewise if the insn has MATCH_DUPs. */
2812 : 918803202 : gcc_assert (insn && new_rtx);
2813 : 918803202 : validate_change (insn, xloc, new_rtx, 1);
2814 : : }
2815 : 918803202 : }
2816 : :
2817 : : /* Canonicalize an expression:
2818 : : replace each register reference inside it
2819 : : with the "oldest" equivalent register.
2820 : :
2821 : : If INSN is nonzero validate_change is used to ensure that INSN remains valid
2822 : : after we make our substitution. The calls are made with IN_GROUP nonzero
2823 : : so apply_change_group must be called upon the outermost return from this
2824 : : function (unless INSN is zero). The result of apply_change_group can
2825 : : generally be discarded since the changes we are making are optional. */
2826 : :
2827 : : static rtx
2828 : 1509863749 : canon_reg (rtx x, rtx_insn *insn)
2829 : : {
2830 : 1509863749 : int i;
2831 : 1509863749 : enum rtx_code code;
2832 : 1509863749 : const char *fmt;
2833 : :
2834 : 1509863749 : if (x == 0)
2835 : : return x;
2836 : :
2837 : 1509863749 : code = GET_CODE (x);
2838 : 1509863749 : switch (code)
2839 : : {
2840 : : case PC:
2841 : : case CONST:
2842 : : CASE_CONST_ANY:
2843 : : case SYMBOL_REF:
2844 : : case LABEL_REF:
2845 : : case ADDR_VEC:
2846 : : case ADDR_DIFF_VEC:
2847 : : return x;
2848 : :
2849 : 432251955 : case REG:
2850 : 432251955 : {
2851 : 432251955 : int first;
2852 : 432251955 : int q;
2853 : 432251955 : struct qty_table_elem *ent;
2854 : :
2855 : : /* Never replace a hard reg, because hard regs can appear
2856 : : in more than one machine mode, and we must preserve the mode
2857 : : of each occurrence. Also, some hard regs appear in
2858 : : MEMs that are shared and mustn't be altered. Don't try to
2859 : : replace any reg that maps to a reg of class NO_REGS. */
2860 : 432251955 : if (REGNO (x) < FIRST_PSEUDO_REGISTER
2861 : 432251955 : || ! REGNO_QTY_VALID_P (REGNO (x)))
2862 : 281395388 : return x;
2863 : :
2864 : 150856567 : q = REG_QTY (REGNO (x));
2865 : 150856567 : ent = &qty_table[q];
2866 : 150856567 : first = ent->first_reg;
2867 : 150856567 : return (first >= FIRST_PSEUDO_REGISTER ? regno_reg_rtx[first]
2868 : 395720 : : REGNO_REG_CLASS (first) == NO_REGS ? x
2869 : 395720 : : gen_rtx_REG (ent->mode, first));
2870 : : }
2871 : :
2872 : 656648768 : default:
2873 : 656648768 : break;
2874 : : }
2875 : :
2876 : 656648768 : fmt = GET_RTX_FORMAT (code);
2877 : 1820402631 : for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
2878 : : {
2879 : 1163753863 : int j;
2880 : :
2881 : 1163753863 : if (fmt[i] == 'e')
2882 : 906960884 : validate_canon_reg (&XEXP (x, i), insn);
2883 : 256792979 : else if (fmt[i] == 'E')
2884 : 17978966 : for (j = 0; j < XVECLEN (x, i); j++)
2885 : 11842318 : validate_canon_reg (&XVECEXP (x, i, j), insn);
2886 : : }
2887 : :
2888 : : return x;
2889 : : }
2890 : :
2891 : : /* Given an operation (CODE, *PARG1, *PARG2), where code is a comparison
2892 : : operation (EQ, NE, GT, etc.), follow it back through the hash table and
2893 : : what values are being compared.
2894 : :
2895 : : *PARG1 and *PARG2 are updated to contain the rtx representing the values
2896 : : actually being compared. For example, if *PARG1 was (reg:CC CC_REG) and
2897 : : *PARG2 was (const_int 0), *PARG1 and *PARG2 will be set to the objects that
2898 : : were compared to produce (reg:CC CC_REG).
2899 : :
2900 : : The return value is the comparison operator and is either the code of
2901 : : A or the code corresponding to the inverse of the comparison. */
2902 : :
2903 : : static enum rtx_code
2904 : 34031535 : find_comparison_args (enum rtx_code code, rtx *parg1, rtx *parg2,
2905 : : machine_mode *pmode1, machine_mode *pmode2)
2906 : : {
2907 : 34031535 : rtx arg1, arg2;
2908 : 34031535 : hash_set<rtx> *visited = NULL;
2909 : : /* Set nonzero when we find something of interest. */
2910 : 34031535 : rtx x = NULL;
2911 : :
2912 : 34031535 : arg1 = *parg1, arg2 = *parg2;
2913 : :
2914 : : /* If ARG2 is const0_rtx, see what ARG1 is equivalent to. */
2915 : :
2916 : 66215404 : while (arg2 == CONST0_RTX (GET_MODE (arg1)))
2917 : : {
2918 : 50301546 : int reverse_code = 0;
2919 : 50301546 : struct table_elt *p = 0;
2920 : :
2921 : : /* Remember state from previous iteration. */
2922 : 50301546 : if (x)
2923 : : {
2924 : 16345345 : if (!visited)
2925 : 16341340 : visited = new hash_set<rtx>;
2926 : 16345345 : visited->add (x);
2927 : 16345345 : x = 0;
2928 : : }
2929 : :
2930 : : /* If arg1 is a COMPARE, extract the comparison arguments from it. */
2931 : :
2932 : 50301546 : if (GET_CODE (arg1) == COMPARE && arg2 == const0_rtx)
2933 : 0 : x = arg1;
2934 : :
2935 : : /* If ARG1 is a comparison operator and CODE is testing for
2936 : : STORE_FLAG_VALUE, get the inner arguments. */
2937 : :
2938 : 50301546 : else if (COMPARISON_P (arg1))
2939 : : {
2940 : : #ifdef FLOAT_STORE_FLAG_VALUE
2941 : : REAL_VALUE_TYPE fsfv;
2942 : : #endif
2943 : :
2944 : 0 : if (code == NE
2945 : : || (GET_MODE_CLASS (GET_MODE (arg1)) == MODE_INT
2946 : : && code == LT && STORE_FLAG_VALUE == -1)
2947 : : #ifdef FLOAT_STORE_FLAG_VALUE
2948 : : || (SCALAR_FLOAT_MODE_P (GET_MODE (arg1))
2949 : : && (fsfv = FLOAT_STORE_FLAG_VALUE (GET_MODE (arg1)),
2950 : : REAL_VALUE_NEGATIVE (fsfv)))
2951 : : #endif
2952 : : )
2953 : 0 : x = arg1;
2954 : 0 : else if (code == EQ
2955 : : || (GET_MODE_CLASS (GET_MODE (arg1)) == MODE_INT
2956 : : && code == GE && STORE_FLAG_VALUE == -1)
2957 : : #ifdef FLOAT_STORE_FLAG_VALUE
2958 : : || (SCALAR_FLOAT_MODE_P (GET_MODE (arg1))
2959 : : && (fsfv = FLOAT_STORE_FLAG_VALUE (GET_MODE (arg1)),
2960 : : REAL_VALUE_NEGATIVE (fsfv)))
2961 : : #endif
2962 : : )
2963 : 0 : x = arg1, reverse_code = 1;
2964 : : }
2965 : :
2966 : : /* ??? We could also check for
2967 : :
2968 : : (ne (and (eq (...) (const_int 1))) (const_int 0))
2969 : :
2970 : : and related forms, but let's wait until we see them occurring. */
2971 : :
2972 : 50301546 : if (x == 0)
2973 : : /* Look up ARG1 in the hash table and see if it has an equivalence
2974 : : that lets us see what is being compared. */
2975 : 50301546 : p = lookup (arg1, SAFE_HASH (arg1, GET_MODE (arg1)), GET_MODE (arg1));
2976 : 50301546 : if (p)
2977 : : {
2978 : 39828141 : p = p->first_same_value;
2979 : :
2980 : : /* If what we compare is already known to be constant, that is as
2981 : : good as it gets.
2982 : : We need to break the loop in this case, because otherwise we
2983 : : can have an infinite loop when looking at a reg that is known
2984 : : to be a constant which is the same as a comparison of a reg
2985 : : against zero which appears later in the insn stream, which in
2986 : : turn is constant and the same as the comparison of the first reg
2987 : : against zero... */
2988 : 39828141 : if (p->is_const)
2989 : : break;
2990 : : }
2991 : :
2992 : 65146579 : for (; p; p = p->next_same_value)
2993 : : {
2994 : 47034322 : machine_mode inner_mode = GET_MODE (p->exp);
2995 : : #ifdef FLOAT_STORE_FLAG_VALUE
2996 : : REAL_VALUE_TYPE fsfv;
2997 : : #endif
2998 : :
2999 : : /* If the entry isn't valid, skip it. */
3000 : 47034322 : if (! exp_equiv_p (p->exp, p->exp, 1, false))
3001 : 1869185 : continue;
3002 : :
3003 : : /* If it's a comparison we've used before, skip it. */
3004 : 45165137 : if (visited && visited->contains (p->exp))
3005 : 0 : continue;
3006 : :
3007 : 45165137 : if (GET_CODE (p->exp) == COMPARE
3008 : : /* Another possibility is that this machine has a compare insn
3009 : : that includes the comparison code. In that case, ARG1 would
3010 : : be equivalent to a comparison operation that would set ARG1 to
3011 : : either STORE_FLAG_VALUE or zero. If this is an NE operation,
3012 : : ORIG_CODE is the actual comparison being done; if it is an EQ,
3013 : : we must reverse ORIG_CODE. On machine with a negative value
3014 : : for STORE_FLAG_VALUE, also look at LT and GE operations. */
3015 : 45165137 : || ((code == NE
3016 : 8941864 : || (code == LT
3017 : 236946 : && val_signbit_known_set_p (inner_mode,
3018 : : STORE_FLAG_VALUE))
3019 : : #ifdef FLOAT_STORE_FLAG_VALUE
3020 : : || (code == LT
3021 : : && SCALAR_FLOAT_MODE_P (inner_mode)
3022 : : && (fsfv = FLOAT_STORE_FLAG_VALUE (GET_MODE (arg1)),
3023 : : REAL_VALUE_NEGATIVE (fsfv)))
3024 : : #endif
3025 : : )
3026 : 4144880 : && COMPARISON_P (p->exp)))
3027 : : {
3028 : 32081755 : x = p->exp;
3029 : 32081755 : break;
3030 : : }
3031 : 13083382 : else if ((code == EQ
3032 : 7207326 : || (code == GE
3033 : 222471 : && val_signbit_known_set_p (inner_mode,
3034 : : STORE_FLAG_VALUE))
3035 : : #ifdef FLOAT_STORE_FLAG_VALUE
3036 : : || (code == GE
3037 : : && SCALAR_FLOAT_MODE_P (inner_mode)
3038 : : && (fsfv = FLOAT_STORE_FLAG_VALUE (GET_MODE (arg1)),
3039 : : REAL_VALUE_NEGATIVE (fsfv)))
3040 : : #endif
3041 : : )
3042 : 13083382 : && COMPARISON_P (p->exp))
3043 : : {
3044 : 102114 : reverse_code = 1;
3045 : 102114 : x = p->exp;
3046 : 102114 : break;
3047 : : }
3048 : :
3049 : : /* If this non-trapping address, e.g. fp + constant, the
3050 : : equivalent is a better operand since it may let us predict
3051 : : the value of the comparison. */
3052 : 12981268 : else if (!rtx_addr_can_trap_p (p->exp))
3053 : : {
3054 : 0 : arg1 = p->exp;
3055 : 0 : continue;
3056 : : }
3057 : : }
3058 : :
3059 : : /* If we didn't find a useful equivalence for ARG1, we are done.
3060 : : Otherwise, set up for the next iteration. */
3061 : 50296126 : if (x == 0)
3062 : : break;
3063 : :
3064 : : /* If we need to reverse the comparison, make sure that is
3065 : : possible -- we can't necessarily infer the value of GE from LT
3066 : : with floating-point operands. */
3067 : 32183869 : if (reverse_code)
3068 : : {
3069 : 102114 : enum rtx_code reversed = reversed_comparison_code (x, NULL);
3070 : 102114 : if (reversed == UNKNOWN)
3071 : : break;
3072 : : else
3073 : : code = reversed;
3074 : : }
3075 : 32081755 : else if (COMPARISON_P (x))
3076 : 3362 : code = GET_CODE (x);
3077 : 32183869 : arg1 = XEXP (x, 0), arg2 = XEXP (x, 1);
3078 : : }
3079 : :
3080 : : /* Return our results. Return the modes from before fold_rtx
3081 : : because fold_rtx might produce const_int, and then it's too late. */
3082 : 34031535 : *pmode1 = GET_MODE (arg1), *pmode2 = GET_MODE (arg2);
3083 : 34031535 : *parg1 = fold_rtx (arg1, 0), *parg2 = fold_rtx (arg2, 0);
3084 : :
3085 : 34031535 : if (visited)
3086 : 16341340 : delete visited;
3087 : 34031535 : return code;
3088 : : }
3089 : :
3090 : : /* If X is a nontrivial arithmetic operation on an argument for which
3091 : : a constant value can be determined, return the result of operating
3092 : : on that value, as a constant. Otherwise, return X, possibly with
3093 : : one or more operands changed to a forward-propagated constant.
3094 : :
3095 : : If X is a register whose contents are known, we do NOT return
3096 : : those contents here; equiv_constant is called to perform that task.
3097 : : For SUBREGs and MEMs, we do that both here and in equiv_constant.
3098 : :
3099 : : INSN is the insn that we may be modifying. If it is 0, make a copy
3100 : : of X before modifying it. */
3101 : :
3102 : : static rtx
3103 : 369173155 : fold_rtx (rtx x, rtx_insn *insn)
3104 : : {
3105 : 369174900 : enum rtx_code code;
3106 : 369174900 : machine_mode mode;
3107 : 369174900 : const char *fmt;
3108 : 369174900 : int i;
3109 : 369174900 : rtx new_rtx = 0;
3110 : 369174900 : bool changed = false;
3111 : 369174900 : poly_int64 xval;
3112 : :
3113 : : /* Operands of X. */
3114 : : /* Workaround -Wmaybe-uninitialized false positive during
3115 : : profiledbootstrap by initializing them. */
3116 : 369174900 : rtx folded_arg0 = NULL_RTX;
3117 : 369174900 : rtx folded_arg1 = NULL_RTX;
3118 : :
3119 : : /* Constant equivalents of first three operands of X;
3120 : : 0 when no such equivalent is known. */
3121 : 369174900 : rtx const_arg0;
3122 : 369174900 : rtx const_arg1;
3123 : 369174900 : rtx const_arg2;
3124 : :
3125 : : /* The mode of the first operand of X. We need this for sign and zero
3126 : : extends. */
3127 : 369174900 : machine_mode mode_arg0;
3128 : :
3129 : 369174900 : if (x == 0)
3130 : : return x;
3131 : :
3132 : : /* Try to perform some initial simplifications on X. */
3133 : 369174900 : code = GET_CODE (x);
3134 : 369174900 : switch (code)
3135 : : {
3136 : 57288837 : case MEM:
3137 : 57288837 : case SUBREG:
3138 : : /* The first operand of a SIGN/ZERO_EXTRACT has a different meaning
3139 : : than it would in other contexts. Basically its mode does not
3140 : : signify the size of the object read. That information is carried
3141 : : by size operand. If we happen to have a MEM of the appropriate
3142 : : mode in our tables with a constant value we could simplify the
3143 : : extraction incorrectly if we allowed substitution of that value
3144 : : for the MEM. */
3145 : 57288837 : case ZERO_EXTRACT:
3146 : 57288837 : case SIGN_EXTRACT:
3147 : 57288837 : if ((new_rtx = equiv_constant (x)) != NULL_RTX)
3148 : : return new_rtx;
3149 : : return x;
3150 : :
3151 : : case CONST:
3152 : : CASE_CONST_ANY:
3153 : : case SYMBOL_REF:
3154 : : case LABEL_REF:
3155 : : case REG:
3156 : : case PC:
3157 : : /* No use simplifying an EXPR_LIST
3158 : : since they are used only for lists of args
3159 : : in a function call's REG_EQUAL note. */
3160 : : case EXPR_LIST:
3161 : : return x;
3162 : :
3163 : 182688 : case ASM_OPERANDS:
3164 : 182688 : if (insn)
3165 : : {
3166 : 0 : for (i = ASM_OPERANDS_INPUT_LENGTH (x) - 1; i >= 0; i--)
3167 : 0 : validate_change (insn, &ASM_OPERANDS_INPUT (x, i),
3168 : 0 : fold_rtx (ASM_OPERANDS_INPUT (x, i), insn), 0);
3169 : : }
3170 : : return x;
3171 : :
3172 : 14773328 : case CALL:
3173 : 14773328 : if (NO_FUNCTION_CSE && CONSTANT_P (XEXP (XEXP (x, 0), 0)))
3174 : : return x;
3175 : : break;
3176 : 833010 : case VEC_SELECT:
3177 : 833010 : {
3178 : 833010 : rtx trueop0 = XEXP (x, 0);
3179 : 833010 : mode = GET_MODE (trueop0);
3180 : 833010 : rtx trueop1 = XEXP (x, 1);
3181 : : /* If we select a low-part subreg, return that. */
3182 : 833010 : if (vec_series_lowpart_p (GET_MODE (x), mode, trueop1))
3183 : : {
3184 : 198 : rtx new_rtx = lowpart_subreg (GET_MODE (x), trueop0, mode);
3185 : 198 : if (new_rtx != NULL_RTX)
3186 : : return new_rtx;
3187 : : }
3188 : : }
3189 : :
3190 : : /* Anything else goes through the loop below. */
3191 : : default:
3192 : : break;
3193 : : }
3194 : :
3195 : 107434611 : mode = GET_MODE (x);
3196 : 107434611 : const_arg0 = 0;
3197 : 107434611 : const_arg1 = 0;
3198 : 107434611 : const_arg2 = 0;
3199 : 107434611 : mode_arg0 = VOIDmode;
3200 : :
3201 : : /* Try folding our operands.
3202 : : Then see which ones have constant values known. */
3203 : :
3204 : 107434611 : fmt = GET_RTX_FORMAT (code);
3205 : 334843540 : for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
3206 : 227408929 : if (fmt[i] == 'e')
3207 : : {
3208 : 223108799 : rtx folded_arg = XEXP (x, i), const_arg;
3209 : 223108799 : machine_mode mode_arg = GET_MODE (folded_arg);
3210 : :
3211 : 223108799 : switch (GET_CODE (folded_arg))
3212 : : {
3213 : 99342631 : case MEM:
3214 : 99342631 : case REG:
3215 : 99342631 : case SUBREG:
3216 : 99342631 : const_arg = equiv_constant (folded_arg);
3217 : 99342631 : break;
3218 : :
3219 : : case CONST:
3220 : : CASE_CONST_ANY:
3221 : : case SYMBOL_REF:
3222 : : case LABEL_REF:
3223 : : const_arg = folded_arg;
3224 : : break;
3225 : :
3226 : 42095905 : default:
3227 : 42095905 : folded_arg = fold_rtx (folded_arg, insn);
3228 : 42095905 : const_arg = equiv_constant (folded_arg);
3229 : 42095905 : break;
3230 : : }
3231 : :
3232 : : /* For the first three operands, see if the operand
3233 : : is constant or equivalent to a constant. */
3234 : 223108799 : switch (i)
3235 : : {
3236 : 104868140 : case 0:
3237 : 104868140 : folded_arg0 = folded_arg;
3238 : 104868140 : const_arg0 = const_arg;
3239 : 104868140 : mode_arg0 = mode_arg;
3240 : 104868140 : break;
3241 : 99146299 : case 1:
3242 : 99146299 : folded_arg1 = folded_arg;
3243 : 99146299 : const_arg1 = const_arg;
3244 : 99146299 : break;
3245 : 19094360 : case 2:
3246 : 19094360 : const_arg2 = const_arg;
3247 : 19094360 : break;
3248 : : }
3249 : :
3250 : : /* Pick the least expensive of the argument and an equivalent constant
3251 : : argument. */
3252 : 223108799 : if (const_arg != 0
3253 : 223108799 : && const_arg != folded_arg
3254 : 5976686 : && (COST_IN (const_arg, mode_arg, code, i)
3255 : 2988343 : <= COST_IN (folded_arg, mode_arg, code, i))
3256 : :
3257 : : /* It's not safe to substitute the operand of a conversion
3258 : : operator with a constant, as the conversion's identity
3259 : : depends upon the mode of its operand. This optimization
3260 : : is handled by the call to simplify_unary_operation. */
3261 : 224785014 : && (GET_RTX_CLASS (code) != RTX_UNARY
3262 : 403664 : || GET_MODE (const_arg) == mode_arg0
3263 : 327825 : || (code != ZERO_EXTEND
3264 : : && code != SIGN_EXTEND
3265 : 327825 : && code != TRUNCATE
3266 : 327825 : && code != FLOAT_TRUNCATE
3267 : 245711 : && code != FLOAT_EXTEND
3268 : 245711 : && code != FLOAT
3269 : : && code != FIX
3270 : 245519 : && code != UNSIGNED_FLOAT
3271 : 245519 : && code != UNSIGNED_FIX)))
3272 : : folded_arg = const_arg;
3273 : :
3274 : 223108799 : if (folded_arg == XEXP (x, i))
3275 : 220914302 : continue;
3276 : :
3277 : 2194497 : if (insn == NULL_RTX && !changed)
3278 : 1969866 : x = copy_rtx (x);
3279 : 2194497 : changed = true;
3280 : 2194497 : validate_unshare_change (insn, &XEXP (x, i), folded_arg, 1);
3281 : : }
3282 : :
3283 : 107434611 : if (changed)
3284 : : {
3285 : : /* Canonicalize X if necessary, and keep const_argN and folded_argN
3286 : : consistent with the order in X. */
3287 : 1970554 : if (canonicalize_change_group (insn, x))
3288 : : {
3289 : 190730 : std::swap (const_arg0, const_arg1);
3290 : 190730 : std::swap (folded_arg0, folded_arg1);
3291 : : }
3292 : :
3293 : 1970554 : apply_change_group ();
3294 : : }
3295 : :
3296 : : /* If X is an arithmetic operation, see if we can simplify it. */
3297 : :
3298 : 107434611 : switch (GET_RTX_CLASS (code))
3299 : : {
3300 : 5721841 : case RTX_UNARY:
3301 : 5721841 : {
3302 : : /* We can't simplify extension ops unless we know the
3303 : : original mode. */
3304 : 5721841 : if ((code == ZERO_EXTEND || code == SIGN_EXTEND)
3305 : 4064999 : && mode_arg0 == VOIDmode)
3306 : : break;
3307 : :
3308 : 5721841 : new_rtx = simplify_unary_operation (code, mode,
3309 : : const_arg0 ? const_arg0 : folded_arg0,
3310 : : mode_arg0);
3311 : : }
3312 : 5721841 : break;
3313 : :
3314 : 20496385 : case RTX_COMPARE:
3315 : 20496385 : case RTX_COMM_COMPARE:
3316 : : /* See what items are actually being compared and set FOLDED_ARG[01]
3317 : : to those values and CODE to the actual comparison code. If any are
3318 : : constant, set CONST_ARG0 and CONST_ARG1 appropriately. We needn't
3319 : : do anything if both operands are already known to be constant. */
3320 : :
3321 : : /* ??? Vector mode comparisons are not supported yet. */
3322 : 20496385 : if (VECTOR_MODE_P (mode))
3323 : : break;
3324 : :
3325 : 20393644 : if (const_arg0 == 0 || const_arg1 == 0)
3326 : : {
3327 : 20392571 : struct table_elt *p0, *p1;
3328 : 20392571 : rtx true_rtx, false_rtx;
3329 : 20392571 : machine_mode mode_arg1;
3330 : :
3331 : 20392571 : if (SCALAR_FLOAT_MODE_P (mode))
3332 : : {
3333 : : #ifdef FLOAT_STORE_FLAG_VALUE
3334 : : true_rtx = (const_double_from_real_value
3335 : : (FLOAT_STORE_FLAG_VALUE (mode), mode));
3336 : : #else
3337 : 2347 : true_rtx = NULL_RTX;
3338 : : #endif
3339 : 2347 : false_rtx = CONST0_RTX (mode);
3340 : : }
3341 : : else
3342 : : {
3343 : 20390224 : true_rtx = const_true_rtx;
3344 : 20390224 : false_rtx = const0_rtx;
3345 : : }
3346 : :
3347 : 20392571 : code = find_comparison_args (code, &folded_arg0, &folded_arg1,
3348 : : &mode_arg0, &mode_arg1);
3349 : :
3350 : : /* If the mode is VOIDmode or a MODE_CC mode, we don't know
3351 : : what kinds of things are being compared, so we can't do
3352 : : anything with this comparison. */
3353 : :
3354 : 20392571 : if (mode_arg0 == VOIDmode || GET_MODE_CLASS (mode_arg0) == MODE_CC)
3355 : : break;
3356 : :
3357 : 19088060 : const_arg0 = equiv_constant (folded_arg0);
3358 : 19088060 : const_arg1 = equiv_constant (folded_arg1);
3359 : :
3360 : : /* If we do not now have two constants being compared, see
3361 : : if we can nevertheless deduce some things about the
3362 : : comparison. */
3363 : 19088060 : if (const_arg0 == 0 || const_arg1 == 0)
3364 : : {
3365 : 18904960 : if (const_arg1 != NULL)
3366 : : {
3367 : 14191504 : rtx cheapest_simplification;
3368 : 14191504 : int cheapest_cost;
3369 : 14191504 : rtx simp_result;
3370 : 14191504 : struct table_elt *p;
3371 : :
3372 : : /* See if we can find an equivalent of folded_arg0
3373 : : that gets us a cheaper expression, possibly a
3374 : : constant through simplifications. */
3375 : 14191504 : p = lookup (folded_arg0, SAFE_HASH (folded_arg0, mode_arg0),
3376 : : mode_arg0);
3377 : :
3378 : 14191504 : if (p != NULL)
3379 : : {
3380 : 5882339 : cheapest_simplification = x;
3381 : 5882339 : cheapest_cost = COST (x, mode);
3382 : :
3383 : 17204336 : for (p = p->first_same_value; p != NULL; p = p->next_same_value)
3384 : : {
3385 : 11321997 : int cost;
3386 : :
3387 : : /* If the entry isn't valid, skip it. */
3388 : 11321997 : if (! exp_equiv_p (p->exp, p->exp, 1, false))
3389 : 537028 : continue;
3390 : :
3391 : : /* Try to simplify using this equivalence. */
3392 : 10784969 : simp_result
3393 : 10784969 : = simplify_relational_operation (code, mode,
3394 : : mode_arg0,
3395 : : p->exp,
3396 : : const_arg1);
3397 : :
3398 : 10784969 : if (simp_result == NULL)
3399 : 10662913 : continue;
3400 : :
3401 : 122056 : cost = COST (simp_result, mode);
3402 : 122056 : if (cost < cheapest_cost)
3403 : : {
3404 : 11321997 : cheapest_cost = cost;
3405 : 11321997 : cheapest_simplification = simp_result;
3406 : : }
3407 : : }
3408 : :
3409 : : /* If we have a cheaper expression now, use that
3410 : : and try folding it further, from the top. */
3411 : 5882339 : if (cheapest_simplification != x)
3412 : 1719 : return fold_rtx (copy_rtx (cheapest_simplification),
3413 : 10959 : insn);
3414 : : }
3415 : : }
3416 : :
3417 : : /* See if the two operands are the same. */
3418 : :
3419 : 19074829 : if ((REG_P (folded_arg0)
3420 : 16059140 : && REG_P (folded_arg1)
3421 : 4128022 : && (REG_QTY (REGNO (folded_arg0))
3422 : 4128022 : == REG_QTY (REGNO (folded_arg1))))
3423 : 35122203 : || ((p0 = lookup (folded_arg0,
3424 : : SAFE_HASH (folded_arg0, mode_arg0),
3425 : : mode_arg0))
3426 : 8121340 : && (p1 = lookup (folded_arg1,
3427 : : SAFE_HASH (folded_arg1, mode_arg0),
3428 : : mode_arg0))
3429 : 2236941 : && p0->first_same_value == p1->first_same_value))
3430 : 12305 : folded_arg1 = folded_arg0;
3431 : :
3432 : : /* If FOLDED_ARG0 is a register, see if the comparison we are
3433 : : doing now is either the same as we did before or the reverse
3434 : : (we only check the reverse if not floating-point). */
3435 : 19062524 : else if (REG_P (folded_arg0))
3436 : : {
3437 : 16047072 : int qty = REG_QTY (REGNO (folded_arg0));
3438 : :
3439 : 16047072 : if (REGNO_QTY_VALID_P (REGNO (folded_arg0)))
3440 : : {
3441 : 16036134 : struct qty_table_elem *ent = &qty_table[qty];
3442 : :
3443 : 16036134 : if ((comparison_dominates_p (ent->comparison_code, code)
3444 : 15650948 : || (! FLOAT_MODE_P (mode_arg0)
3445 : 15432438 : && comparison_dominates_p (ent->comparison_code,
3446 : : reverse_condition (code))))
3447 : 16440305 : && (rtx_equal_p (ent->comparison_const, folded_arg1)
3448 : 781528 : || (const_arg1
3449 : 653884 : && rtx_equal_p (ent->comparison_const,
3450 : : const_arg1))
3451 : 781528 : || (REG_P (folded_arg1)
3452 : 122220 : && (REG_QTY (REGNO (folded_arg1)) == ent->comparison_qty))))
3453 : : {
3454 : 9240 : if (comparison_dominates_p (ent->comparison_code, code))
3455 : : {
3456 : 7352 : if (true_rtx)
3457 : : return true_rtx;
3458 : : else
3459 : : break;
3460 : : }
3461 : : else
3462 : : return false_rtx;
3463 : : }
3464 : : }
3465 : : }
3466 : : }
3467 : : }
3468 : :
3469 : : /* If we are comparing against zero, see if the first operand is
3470 : : equivalent to an IOR with a constant. If so, we may be able to
3471 : : determine the result of this comparison. */
3472 : 19078174 : if (const_arg1 == const0_rtx && !const_arg0)
3473 : : {
3474 : 9423663 : rtx y = lookup_as_function (folded_arg0, IOR);
3475 : 9423663 : rtx inner_const;
3476 : :
3477 : 9423663 : if (y != 0
3478 : 72614 : && (inner_const = equiv_constant (XEXP (y, 1))) != 0
3479 : 78 : && CONST_INT_P (inner_const)
3480 : 9423741 : && INTVAL (inner_const) != 0)
3481 : 78 : folded_arg0 = gen_rtx_IOR (mode_arg0, XEXP (y, 0), inner_const);
3482 : : }
3483 : :
3484 : 19070665 : {
3485 : 19070665 : rtx op0 = const_arg0 ? const_arg0 : copy_rtx (folded_arg0);
3486 : 19078174 : rtx op1 = const_arg1 ? const_arg1 : copy_rtx (folded_arg1);
3487 : 19078174 : new_rtx = simplify_relational_operation (code, mode, mode_arg0,
3488 : : op0, op1);
3489 : : }
3490 : 19078174 : break;
3491 : :
3492 : 59054536 : case RTX_BIN_ARITH:
3493 : 59054536 : case RTX_COMM_ARITH:
3494 : 59054536 : switch (code)
3495 : : {
3496 : 25261474 : case PLUS:
3497 : : /* If the second operand is a LABEL_REF, see if the first is a MINUS
3498 : : with that LABEL_REF as its second operand. If so, the result is
3499 : : the first operand of that MINUS. This handles switches with an
3500 : : ADDR_DIFF_VEC table. */
3501 : 25261474 : if (const_arg1 && GET_CODE (const_arg1) == LABEL_REF)
3502 : : {
3503 : 2676 : rtx y
3504 : 2676 : = GET_CODE (folded_arg0) == MINUS ? folded_arg0
3505 : 2676 : : lookup_as_function (folded_arg0, MINUS);
3506 : :
3507 : 0 : if (y != 0 && GET_CODE (XEXP (y, 1)) == LABEL_REF
3508 : 2676 : && label_ref_label (XEXP (y, 1)) == label_ref_label (const_arg1))
3509 : 0 : return XEXP (y, 0);
3510 : :
3511 : : /* Now try for a CONST of a MINUS like the above. */
3512 : 2676 : if ((y = (GET_CODE (folded_arg0) == CONST ? folded_arg0
3513 : 2676 : : lookup_as_function (folded_arg0, CONST))) != 0
3514 : 0 : && GET_CODE (XEXP (y, 0)) == MINUS
3515 : 0 : && GET_CODE (XEXP (XEXP (y, 0), 1)) == LABEL_REF
3516 : 2676 : && label_ref_label (XEXP (XEXP (y, 0), 1)) == label_ref_label (const_arg1))
3517 : 0 : return XEXP (XEXP (y, 0), 0);
3518 : : }
3519 : :
3520 : : /* Likewise if the operands are in the other order. */
3521 : 25261474 : if (const_arg0 && GET_CODE (const_arg0) == LABEL_REF)
3522 : : {
3523 : 23 : rtx y
3524 : 23 : = GET_CODE (folded_arg1) == MINUS ? folded_arg1
3525 : 23 : : lookup_as_function (folded_arg1, MINUS);
3526 : :
3527 : 0 : if (y != 0 && GET_CODE (XEXP (y, 1)) == LABEL_REF
3528 : 23 : && label_ref_label (XEXP (y, 1)) == label_ref_label (const_arg0))
3529 : 0 : return XEXP (y, 0);
3530 : :
3531 : : /* Now try for a CONST of a MINUS like the above. */
3532 : 23 : if ((y = (GET_CODE (folded_arg1) == CONST ? folded_arg1
3533 : 23 : : lookup_as_function (folded_arg1, CONST))) != 0
3534 : 0 : && GET_CODE (XEXP (y, 0)) == MINUS
3535 : 0 : && GET_CODE (XEXP (XEXP (y, 0), 1)) == LABEL_REF
3536 : 23 : && label_ref_label (XEXP (XEXP (y, 0), 1)) == label_ref_label (const_arg0))
3537 : 0 : return XEXP (XEXP (y, 0), 0);
3538 : : }
3539 : :
3540 : : /* If second operand is a register equivalent to a negative
3541 : : CONST_INT, see if we can find a register equivalent to the
3542 : : positive constant. Make a MINUS if so. Don't do this for
3543 : : a non-negative constant since we might then alternate between
3544 : : choosing positive and negative constants. Having the positive
3545 : : constant previously-used is the more common case. Be sure
3546 : : the resulting constant is non-negative; if const_arg1 were
3547 : : the smallest negative number this would overflow: depending
3548 : : on the mode, this would either just be the same value (and
3549 : : hence not save anything) or be incorrect. */
3550 : 25261474 : if (const_arg1 != 0 && CONST_INT_P (const_arg1)
3551 : 20385460 : && INTVAL (const_arg1) < 0
3552 : : /* This used to test
3553 : :
3554 : : -INTVAL (const_arg1) >= 0
3555 : :
3556 : : But The Sun V5.0 compilers mis-compiled that test. So
3557 : : instead we test for the problematic value in a more direct
3558 : : manner and hope the Sun compilers get it correct. */
3559 : 11496103 : && INTVAL (const_arg1) !=
3560 : : (HOST_WIDE_INT_1 << (HOST_BITS_PER_WIDE_INT - 1))
3561 : 11477121 : && REG_P (folded_arg1))
3562 : : {
3563 : 31871 : rtx new_const = GEN_INT (-INTVAL (const_arg1));
3564 : 31871 : struct table_elt *p
3565 : 31871 : = lookup (new_const, SAFE_HASH (new_const, mode), mode);
3566 : :
3567 : 31871 : if (p)
3568 : 5182 : for (p = p->first_same_value; p; p = p->next_same_value)
3569 : 5182 : if (REG_P (p->exp))
3570 : 2736 : return simplify_gen_binary (MINUS, mode, folded_arg0,
3571 : 2736 : canon_reg (p->exp, NULL));
3572 : : }
3573 : 25258738 : goto from_plus;
3574 : :
3575 : 1990119 : case MINUS:
3576 : : /* If we have (MINUS Y C), see if Y is known to be (PLUS Z C2).
3577 : : If so, produce (PLUS Z C2-C). */
3578 : 1990119 : if (const_arg1 != 0 && poly_int_rtx_p (const_arg1, &xval))
3579 : : {
3580 : 44197 : rtx y = lookup_as_function (XEXP (x, 0), PLUS);
3581 : 44197 : if (y && poly_int_rtx_p (XEXP (y, 1)))
3582 : 26 : return fold_rtx (plus_constant (mode, copy_rtx (y), -xval),
3583 : 26 : NULL);
3584 : : }
3585 : :
3586 : : /* Fall through. */
3587 : :
3588 : 37261043 : from_plus:
3589 : 37261043 : case SMIN: case SMAX: case UMIN: case UMAX:
3590 : 37261043 : case IOR: case AND: case XOR:
3591 : 37261043 : case MULT:
3592 : 37261043 : case ASHIFT: case LSHIFTRT: case ASHIFTRT:
3593 : : /* If we have (<op> <reg> <const_int>) for an associative OP and REG
3594 : : is known to be of similar form, we may be able to replace the
3595 : : operation with a combined operation. This may eliminate the
3596 : : intermediate operation if every use is simplified in this way.
3597 : : Note that the similar optimization done by combine.cc only works
3598 : : if the intermediate operation's result has only one reference. */
3599 : :
3600 : 37261043 : if (REG_P (folded_arg0)
3601 : 33972891 : && const_arg1 && CONST_INT_P (const_arg1))
3602 : : {
3603 : 25050387 : int is_shift
3604 : 25050387 : = (code == ASHIFT || code == ASHIFTRT || code == LSHIFTRT);
3605 : : rtx y, inner_const, new_const;
3606 : : rtx canon_const_arg1 = const_arg1;
3607 : : enum rtx_code associate_code;
3608 : :
3609 : : if (is_shift
3610 : 5952154 : && (INTVAL (const_arg1) >= GET_MODE_UNIT_PRECISION (mode)
3611 : 2976059 : || INTVAL (const_arg1) < 0))
3612 : : {
3613 : : if (SHIFT_COUNT_TRUNCATED)
3614 : : canon_const_arg1 = gen_int_shift_amount
3615 : : (mode, (INTVAL (const_arg1)
3616 : : & (GET_MODE_UNIT_BITSIZE (mode) - 1)));
3617 : : else
3618 : : break;
3619 : : }
3620 : :
3621 : 25050367 : y = lookup_as_function (folded_arg0, code);
3622 : 25050367 : if (y == 0)
3623 : : break;
3624 : :
3625 : : /* If we have compiled a statement like
3626 : : "if (x == (x & mask1))", and now are looking at
3627 : : "x & mask2", we will have a case where the first operand
3628 : : of Y is the same as our first operand. Unless we detect
3629 : : this case, an infinite loop will result. */
3630 : 799553 : if (XEXP (y, 0) == folded_arg0)
3631 : : break;
3632 : :
3633 : 799080 : inner_const = equiv_constant (fold_rtx (XEXP (y, 1), 0));
3634 : 799080 : if (!inner_const || !CONST_INT_P (inner_const))
3635 : : break;
3636 : :
3637 : : /* Don't associate these operations if they are a PLUS with the
3638 : : same constant and it is a power of two. These might be doable
3639 : : with a pre- or post-increment. Similarly for two subtracts of
3640 : : identical powers of two with post decrement. */
3641 : :
3642 : 548084 : if (code == PLUS && const_arg1 == inner_const
3643 : : && ((HAVE_PRE_INCREMENT
3644 : : && pow2p_hwi (INTVAL (const_arg1)))
3645 : : || (HAVE_POST_INCREMENT
3646 : : && pow2p_hwi (INTVAL (const_arg1)))
3647 : : || (HAVE_PRE_DECREMENT
3648 : : && pow2p_hwi (- INTVAL (const_arg1)))
3649 : : || (HAVE_POST_DECREMENT
3650 : : && pow2p_hwi (- INTVAL (const_arg1)))))
3651 : : break;
3652 : :
3653 : : /* ??? Vector mode shifts by scalar
3654 : : shift operand are not supported yet. */
3655 : 548084 : if (is_shift && VECTOR_MODE_P (mode))
3656 : : break;
3657 : :
3658 : 2680 : if (is_shift
3659 : 5360 : && (INTVAL (inner_const) >= GET_MODE_UNIT_PRECISION (mode)
3660 : 2680 : || INTVAL (inner_const) < 0))
3661 : : {
3662 : : if (SHIFT_COUNT_TRUNCATED)
3663 : : inner_const = gen_int_shift_amount
3664 : : (mode, (INTVAL (inner_const)
3665 : : & (GET_MODE_UNIT_BITSIZE (mode) - 1)));
3666 : : else
3667 : : break;
3668 : : }
3669 : :
3670 : : /* Compute the code used to compose the constants. For example,
3671 : : A-C1-C2 is A-(C1 + C2), so if CODE == MINUS, we want PLUS. */
3672 : :
3673 : 547804 : associate_code = (is_shift || code == MINUS ? PLUS : code);
3674 : :
3675 : 547804 : new_const = simplify_binary_operation (associate_code, mode,
3676 : : canon_const_arg1,
3677 : : inner_const);
3678 : :
3679 : 547804 : if (new_const == 0)
3680 : : break;
3681 : :
3682 : : /* If we are associating shift operations, don't let this
3683 : : produce a shift of the size of the object or larger.
3684 : : This could occur when we follow a sign-extend by a right
3685 : : shift on a machine that does a sign-extend as a pair
3686 : : of shifts. */
3687 : :
3688 : 547804 : if (is_shift
3689 : 2680 : && CONST_INT_P (new_const)
3690 : 553164 : && INTVAL (new_const) >= GET_MODE_UNIT_PRECISION (mode))
3691 : : {
3692 : : /* As an exception, we can turn an ASHIFTRT of this
3693 : : form into a shift of the number of bits - 1. */
3694 : 1421 : if (code == ASHIFTRT)
3695 : 1388 : new_const = gen_int_shift_amount
3696 : 1388 : (mode, GET_MODE_UNIT_BITSIZE (mode) - 1);
3697 : 33 : else if (!side_effects_p (XEXP (y, 0)))
3698 : 33 : return CONST0_RTX (mode);
3699 : : else
3700 : : break;
3701 : : }
3702 : :
3703 : 547771 : y = copy_rtx (XEXP (y, 0));
3704 : :
3705 : : /* If Y contains our first operand (the most common way this
3706 : : can happen is if Y is a MEM), we would do into an infinite
3707 : : loop if we tried to fold it. So don't in that case. */
3708 : :
3709 : 547771 : if (! reg_mentioned_p (folded_arg0, y))
3710 : 547771 : y = fold_rtx (y, insn);
3711 : :
3712 : 547771 : return simplify_gen_binary (code, mode, y, new_const);
3713 : : }
3714 : : break;
3715 : :
3716 : : case DIV: case UDIV:
3717 : : /* ??? The associative optimization performed immediately above is
3718 : : also possible for DIV and UDIV using associate_code of MULT.
3719 : : However, we would need extra code to verify that the
3720 : : multiplication does not overflow, that is, there is no overflow
3721 : : in the calculation of new_const. */
3722 : : break;
3723 : :
3724 : : default:
3725 : : break;
3726 : : }
3727 : :
3728 : 99896549 : new_rtx = simplify_binary_operation (code, mode,
3729 : : const_arg0 ? const_arg0 : folded_arg0,
3730 : : const_arg1 ? const_arg1 : folded_arg1);
3731 : 58503970 : break;
3732 : :
3733 : 0 : case RTX_OBJ:
3734 : : /* (lo_sum (high X) X) is simply X. */
3735 : 0 : if (code == LO_SUM && const_arg0 != 0
3736 : 0 : && GET_CODE (const_arg0) == HIGH
3737 : 0 : && rtx_equal_p (XEXP (const_arg0, 0), const_arg1))
3738 : : return const_arg1;
3739 : : break;
3740 : :
3741 : 19094360 : case RTX_TERNARY:
3742 : 19094360 : case RTX_BITFIELD_OPS:
3743 : 19094360 : new_rtx = simplify_ternary_operation (code, mode, mode_arg0,
3744 : : const_arg0 ? const_arg0 : folded_arg0,
3745 : : const_arg1 ? const_arg1 : folded_arg1,
3746 : : const_arg2 ? const_arg2 : XEXP (x, 2));
3747 : 19094360 : break;
3748 : :
3749 : : default:
3750 : : break;
3751 : : }
3752 : :
3753 : 103702856 : return new_rtx ? new_rtx : x;
3754 : : }
3755 : :
3756 : : /* Return a constant value currently equivalent to X.
3757 : : Return 0 if we don't know one. */
3758 : :
3759 : : static rtx
3760 : 249908178 : equiv_constant (rtx x)
3761 : : {
3762 : 249908178 : if (REG_P (x)
3763 : 249908178 : && REGNO_QTY_VALID_P (REGNO (x)))
3764 : : {
3765 : 78950731 : int x_q = REG_QTY (REGNO (x));
3766 : 78950731 : struct qty_table_elem *x_ent = &qty_table[x_q];
3767 : :
3768 : 78950731 : if (x_ent->const_rtx)
3769 : 4256475 : x = gen_lowpart (GET_MODE (x), x_ent->const_rtx);
3770 : : }
3771 : :
3772 : 249908178 : if (x == 0 || CONSTANT_P (x))
3773 : 25065195 : return x;
3774 : :
3775 : 224842983 : if (GET_CODE (x) == SUBREG)
3776 : : {
3777 : 5278135 : machine_mode mode = GET_MODE (x);
3778 : 5278135 : machine_mode imode = GET_MODE (SUBREG_REG (x));
3779 : 5278135 : rtx new_rtx;
3780 : :
3781 : : /* See if we previously assigned a constant value to this SUBREG. */
3782 : 5278135 : if ((new_rtx = lookup_as_function (x, CONST_INT)) != 0
3783 : 5271537 : || (new_rtx = lookup_as_function (x, CONST_WIDE_INT)) != 0
3784 : 5271537 : || (NUM_POLY_INT_COEFFS > 1
3785 : : && (new_rtx = lookup_as_function (x, CONST_POLY_INT)) != 0)
3786 : 5265594 : || (new_rtx = lookup_as_function (x, CONST_DOUBLE)) != 0
3787 : 10543559 : || (new_rtx = lookup_as_function (x, CONST_FIXED)) != 0)
3788 : 12711 : return new_rtx;
3789 : :
3790 : : /* If we didn't and if doing so makes sense, see if we previously
3791 : : assigned a constant value to the enclosing word mode SUBREG. */
3792 : 11368597 : if (known_lt (GET_MODE_SIZE (mode), UNITS_PER_WORD)
3793 : 8149130 : && known_lt (UNITS_PER_WORD, GET_MODE_SIZE (imode)))
3794 : : {
3795 : 33099 : poly_int64 byte = (SUBREG_BYTE (x)
3796 : 33099 : - subreg_lowpart_offset (mode, word_mode));
3797 : 66198 : if (known_ge (byte, 0) && multiple_p (byte, UNITS_PER_WORD))
3798 : : {
3799 : 33099 : rtx y = gen_rtx_SUBREG (word_mode, SUBREG_REG (x), byte);
3800 : 33099 : new_rtx = lookup_as_function (y, CONST_INT);
3801 : 33099 : if (new_rtx)
3802 : 0 : return gen_lowpart (mode, new_rtx);
3803 : : }
3804 : : }
3805 : :
3806 : : /* Otherwise see if we already have a constant for the inner REG,
3807 : : and if that is enough to calculate an equivalent constant for
3808 : : the subreg. Note that the upper bits of paradoxical subregs
3809 : : are undefined, so they cannot be said to equal anything. */
3810 : 5265424 : if (REG_P (SUBREG_REG (x))
3811 : 5256472 : && !paradoxical_subreg_p (x)
3812 : 10376595 : && (new_rtx = equiv_constant (SUBREG_REG (x))) != 0)
3813 : 71574 : return simplify_subreg (mode, new_rtx, imode, SUBREG_BYTE (x));
3814 : :
3815 : 5193850 : return 0;
3816 : : }
3817 : :
3818 : : /* If X is a MEM, see if it is a constant-pool reference, or look it up in
3819 : : the hash table in case its value was seen before. */
3820 : :
3821 : 219564848 : if (MEM_P (x))
3822 : : {
3823 : 63452724 : struct table_elt *elt;
3824 : :
3825 : 63452724 : x = avoid_constant_pool_reference (x);
3826 : 63452724 : if (CONSTANT_P (x))
3827 : : return x;
3828 : :
3829 : 61418344 : elt = lookup (x, SAFE_HASH (x, GET_MODE (x)), GET_MODE (x));
3830 : 61418344 : if (elt == 0)
3831 : : return 0;
3832 : :
3833 : 5533343 : for (elt = elt->first_same_value; elt; elt = elt->next_same_value)
3834 : 3928711 : if (elt->is_const && CONSTANT_P (elt->exp))
3835 : : return elt->exp;
3836 : : }
3837 : :
3838 : : return 0;
3839 : : }
3840 : :
3841 : : /* Given INSN, a jump insn, TAKEN indicates if we are following the
3842 : : "taken" branch.
3843 : :
3844 : : In certain cases, this can cause us to add an equivalence. For example,
3845 : : if we are following the taken case of
3846 : : if (i == 2)
3847 : : we can add the fact that `i' and '2' are now equivalent.
3848 : :
3849 : : In any case, we can record that this comparison was passed. If the same
3850 : : comparison is seen later, we will know its value. */
3851 : :
3852 : : static void
3853 : 13638964 : record_jump_equiv (rtx_insn *insn, bool taken)
3854 : : {
3855 : 13638964 : int cond_known_true;
3856 : 13638964 : rtx op0, op1;
3857 : 13638964 : rtx set;
3858 : 13638964 : machine_mode mode, mode0, mode1;
3859 : 13638964 : enum rtx_code code;
3860 : :
3861 : : /* Ensure this is the right kind of insn. */
3862 : 13638964 : gcc_assert (any_condjump_p (insn));
3863 : :
3864 : 13638964 : set = pc_set (insn);
3865 : :
3866 : : /* See if this jump condition is known true or false. */
3867 : 13638964 : if (taken)
3868 : 5423470 : cond_known_true = (XEXP (SET_SRC (set), 2) == pc_rtx);
3869 : : else
3870 : 8215494 : cond_known_true = (XEXP (SET_SRC (set), 1) == pc_rtx);
3871 : :
3872 : : /* Get the type of comparison being done and the operands being compared.
3873 : : If we had to reverse a non-equality condition, record that fact so we
3874 : : know that it isn't valid for floating-point. */
3875 : 13638964 : code = GET_CODE (XEXP (SET_SRC (set), 0));
3876 : 13638964 : op0 = fold_rtx (XEXP (XEXP (SET_SRC (set), 0), 0), insn);
3877 : 13638964 : op1 = fold_rtx (XEXP (XEXP (SET_SRC (set), 0), 1), insn);
3878 : :
3879 : : /* If fold_rtx returns NULL_RTX, there's nothing to record. */
3880 : 13638964 : if (op0 == NULL_RTX || op1 == NULL_RTX)
3881 : 83401 : return;
3882 : :
3883 : 13638964 : code = find_comparison_args (code, &op0, &op1, &mode0, &mode1);
3884 : 13638964 : if (! cond_known_true)
3885 : : {
3886 : 8215494 : code = reversed_comparison_code_parts (code, op0, op1, insn);
3887 : :
3888 : : /* Don't remember if we can't find the inverse. */
3889 : 8215494 : if (code == UNKNOWN)
3890 : : return;
3891 : : }
3892 : :
3893 : : /* The mode is the mode of the non-constant. */
3894 : 13555563 : mode = mode0;
3895 : 13555563 : if (mode1 != VOIDmode)
3896 : 3224435 : mode = mode1;
3897 : :
3898 : 13555563 : record_jump_cond (code, mode, op0, op1);
3899 : : }
3900 : :
3901 : : /* Yet another form of subreg creation. In this case, we want something in
3902 : : MODE, and we should assume OP has MODE iff it is naturally modeless. */
3903 : :
3904 : : static rtx
3905 : 72494 : record_jump_cond_subreg (machine_mode mode, rtx op)
3906 : : {
3907 : 72494 : machine_mode op_mode = GET_MODE (op);
3908 : 72494 : if (op_mode == mode || op_mode == VOIDmode)
3909 : : return op;
3910 : 7179 : return lowpart_subreg (mode, op, op_mode);
3911 : : }
3912 : :
3913 : : /* We know that comparison CODE applied to OP0 and OP1 in MODE is true.
3914 : : Make any useful entries we can with that information. Called from
3915 : : above function and called recursively. */
3916 : :
3917 : : static void
3918 : 13628053 : record_jump_cond (enum rtx_code code, machine_mode mode, rtx op0, rtx op1)
3919 : : {
3920 : 13628053 : unsigned op0_hash, op1_hash;
3921 : 13628053 : int op0_in_memory, op1_in_memory;
3922 : 13628053 : struct table_elt *op0_elt, *op1_elt;
3923 : :
3924 : : /* If OP0 and OP1 are known equal, and either is a paradoxical SUBREG,
3925 : : we know that they are also equal in the smaller mode (this is also
3926 : : true for all smaller modes whether or not there is a SUBREG, but
3927 : : is not worth testing for with no SUBREG). */
3928 : :
3929 : : /* Note that GET_MODE (op0) may not equal MODE. */
3930 : 13628053 : if (code == EQ && paradoxical_subreg_p (op0))
3931 : : {
3932 : 0 : machine_mode inner_mode = GET_MODE (SUBREG_REG (op0));
3933 : 0 : rtx tem = record_jump_cond_subreg (inner_mode, op1);
3934 : 0 : if (tem)
3935 : 0 : record_jump_cond (code, mode, SUBREG_REG (op0), tem);
3936 : : }
3937 : :
3938 : 13628053 : if (code == EQ && paradoxical_subreg_p (op1))
3939 : : {
3940 : 0 : machine_mode inner_mode = GET_MODE (SUBREG_REG (op1));
3941 : 0 : rtx tem = record_jump_cond_subreg (inner_mode, op0);
3942 : 0 : if (tem)
3943 : 0 : record_jump_cond (code, mode, SUBREG_REG (op1), tem);
3944 : : }
3945 : :
3946 : : /* Similarly, if this is an NE comparison, and either is a SUBREG
3947 : : making a smaller mode, we know the whole thing is also NE. */
3948 : :
3949 : : /* Note that GET_MODE (op0) may not equal MODE;
3950 : : if we test MODE instead, we can get an infinite recursion
3951 : : alternating between two modes each wider than MODE. */
3952 : :
3953 : 13628053 : if (code == NE
3954 : 5781218 : && partial_subreg_p (op0)
3955 : 13694727 : && subreg_lowpart_p (op0))
3956 : : {
3957 : 66343 : machine_mode inner_mode = GET_MODE (SUBREG_REG (op0));
3958 : 66343 : rtx tem = record_jump_cond_subreg (inner_mode, op1);
3959 : 66343 : if (tem)
3960 : 66343 : record_jump_cond (code, mode, SUBREG_REG (op0), tem);
3961 : : }
3962 : :
3963 : 13628053 : if (code == NE
3964 : 5781218 : && partial_subreg_p (op1)
3965 : 13634275 : && subreg_lowpart_p (op1))
3966 : : {
3967 : 6151 : machine_mode inner_mode = GET_MODE (SUBREG_REG (op1));
3968 : 6151 : rtx tem = record_jump_cond_subreg (inner_mode, op0);
3969 : 6151 : if (tem)
3970 : 6147 : record_jump_cond (code, mode, SUBREG_REG (op1), tem);
3971 : : }
3972 : :
3973 : : /* Hash both operands. */
3974 : :
3975 : 13628053 : do_not_record = 0;
3976 : 13628053 : hash_arg_in_memory = 0;
3977 : 13628053 : op0_hash = HASH (op0, mode);
3978 : 13628053 : op0_in_memory = hash_arg_in_memory;
3979 : :
3980 : 13628053 : if (do_not_record)
3981 : : return;
3982 : :
3983 : 13628053 : do_not_record = 0;
3984 : 13628053 : hash_arg_in_memory = 0;
3985 : 13628053 : op1_hash = HASH (op1, mode);
3986 : 13628053 : op1_in_memory = hash_arg_in_memory;
3987 : :
3988 : 13628053 : if (do_not_record)
3989 : : return;
3990 : :
3991 : : /* Look up both operands. */
3992 : 13628053 : op0_elt = lookup (op0, op0_hash, mode);
3993 : 13628053 : op1_elt = lookup (op1, op1_hash, mode);
3994 : :
3995 : : /* If both operands are already equivalent or if they are not in the
3996 : : table but are identical, do nothing. */
3997 : 13628053 : if ((op0_elt != 0 && op1_elt != 0
3998 : 1663757 : && op0_elt->first_same_value == op1_elt->first_same_value)
3999 : 15291753 : || op0 == op1 || rtx_equal_p (op0, op1))
4000 : 747 : return;
4001 : :
4002 : : /* If we aren't setting two things equal all we can do is save this
4003 : : comparison. Similarly if this is floating-point. In the latter
4004 : : case, OP1 might be zero and both -0.0 and 0.0 are equal to it.
4005 : : If we record the equality, we might inadvertently delete code
4006 : : whose intent was to change -0 to +0. */
4007 : :
4008 : 13627306 : if (code != EQ || FLOAT_MODE_P (GET_MODE (op0)))
4009 : : {
4010 : 8725169 : struct qty_table_elem *ent;
4011 : 8725169 : int qty;
4012 : :
4013 : : /* If OP0 is not a register, or if OP1 is neither a register
4014 : : or constant, we can't do anything. */
4015 : :
4016 : 8725169 : if (!REG_P (op1))
4017 : 7021820 : op1 = equiv_constant (op1);
4018 : :
4019 : 8725169 : if (!REG_P (op0) || op1 == 0)
4020 : : return;
4021 : :
4022 : : /* Put OP0 in the hash table if it isn't already. This gives it a
4023 : : new quantity number. */
4024 : 7556414 : if (op0_elt == 0)
4025 : : {
4026 : 3238800 : if (insert_regs (op0, NULL, false))
4027 : : {
4028 : 69653 : rehash_using_reg (op0);
4029 : 69653 : op0_hash = HASH (op0, mode);
4030 : :
4031 : : /* If OP0 is contained in OP1, this changes its hash code
4032 : : as well. Faster to rehash than to check, except
4033 : : for the simple case of a constant. */
4034 : 69653 : if (! CONSTANT_P (op1))
4035 : 547 : op1_hash = HASH (op1,mode);
4036 : : }
4037 : :
4038 : 3238800 : op0_elt = insert (op0, NULL, op0_hash, mode);
4039 : 3238800 : op0_elt->in_memory = op0_in_memory;
4040 : : }
4041 : :
4042 : 7556414 : qty = REG_QTY (REGNO (op0));
4043 : 7556414 : ent = &qty_table[qty];
4044 : :
4045 : 7556414 : ent->comparison_code = code;
4046 : 7556414 : if (REG_P (op1))
4047 : : {
4048 : : /* Look it up again--in case op0 and op1 are the same. */
4049 : 1622350 : op1_elt = lookup (op1, op1_hash, mode);
4050 : :
4051 : : /* Put OP1 in the hash table so it gets a new quantity number. */
4052 : 1622350 : if (op1_elt == 0)
4053 : : {
4054 : 609358 : if (insert_regs (op1, NULL, false))
4055 : : {
4056 : 435 : rehash_using_reg (op1);
4057 : 435 : op1_hash = HASH (op1, mode);
4058 : : }
4059 : :
4060 : 609358 : op1_elt = insert (op1, NULL, op1_hash, mode);
4061 : 609358 : op1_elt->in_memory = op1_in_memory;
4062 : : }
4063 : :
4064 : 1622350 : ent->comparison_const = NULL_RTX;
4065 : 1622350 : ent->comparison_qty = REG_QTY (REGNO (op1));
4066 : : }
4067 : : else
4068 : : {
4069 : 5934064 : ent->comparison_const = op1;
4070 : 5934064 : ent->comparison_qty = INT_MIN;
4071 : : }
4072 : :
4073 : 7556414 : return;
4074 : : }
4075 : :
4076 : : /* If either side is still missing an equivalence, make it now,
4077 : : then merge the equivalences. */
4078 : :
4079 : 4902137 : if (op0_elt == 0)
4080 : : {
4081 : 3049437 : if (insert_regs (op0, NULL, false))
4082 : : {
4083 : 22232 : rehash_using_reg (op0);
4084 : 22232 : op0_hash = HASH (op0, mode);
4085 : : }
4086 : :
4087 : 3049437 : op0_elt = insert (op0, NULL, op0_hash, mode);
4088 : 3049437 : op0_elt->in_memory = op0_in_memory;
4089 : : }
4090 : :
4091 : 4902137 : if (op1_elt == 0)
4092 : : {
4093 : 3711691 : if (insert_regs (op1, NULL, false))
4094 : : {
4095 : 8370 : rehash_using_reg (op1);
4096 : 8370 : op1_hash = HASH (op1, mode);
4097 : : }
4098 : :
4099 : 3711691 : op1_elt = insert (op1, NULL, op1_hash, mode);
4100 : 3711691 : op1_elt->in_memory = op1_in_memory;
4101 : : }
4102 : :
4103 : 4902137 : merge_equiv_classes (op0_elt, op1_elt);
4104 : : }
4105 : :
4106 : : /* CSE processing for one instruction.
4107 : :
4108 : : Most "true" common subexpressions are mostly optimized away in GIMPLE,
4109 : : but the few that "leak through" are cleaned up by cse_insn, and complex
4110 : : addressing modes are often formed here.
4111 : :
4112 : : The main function is cse_insn, and between here and that function
4113 : : a couple of helper functions is defined to keep the size of cse_insn
4114 : : within reasonable proportions.
4115 : :
4116 : : Data is shared between the main and helper functions via STRUCT SET,
4117 : : that contains all data related for every set in the instruction that
4118 : : is being processed.
4119 : :
4120 : : Note that cse_main processes all sets in the instruction. Most
4121 : : passes in GCC only process simple SET insns or single_set insns, but
4122 : : CSE processes insns with multiple sets as well. */
4123 : :
4124 : : /* Data on one SET contained in the instruction. */
4125 : :
4126 : : struct set
4127 : : {
4128 : : /* The SET rtx itself. */
4129 : : rtx rtl;
4130 : : /* The SET_SRC of the rtx (the original value, if it is changing). */
4131 : : rtx src;
4132 : : /* The hash-table element for the SET_SRC of the SET. */
4133 : : struct table_elt *src_elt;
4134 : : /* Hash value for the SET_SRC. */
4135 : : unsigned src_hash;
4136 : : /* Hash value for the SET_DEST. */
4137 : : unsigned dest_hash;
4138 : : /* The SET_DEST, with SUBREG, etc., stripped. */
4139 : : rtx inner_dest;
4140 : : /* Original machine mode, in case it becomes a CONST_INT. */
4141 : : ENUM_BITFIELD(machine_mode) mode : MACHINE_MODE_BITSIZE;
4142 : : /* Nonzero if the SET_SRC is in memory. */
4143 : : unsigned int src_in_memory : 1;
4144 : : /* Nonzero if the SET_SRC contains something
4145 : : whose value cannot be predicted and understood. */
4146 : : unsigned int src_volatile : 1;
4147 : : /* Nonzero if RTL is an artifical set that has been created to describe
4148 : : part of an insn's effect. Zero means that RTL appears directly in
4149 : : the insn pattern. */
4150 : : unsigned int is_fake_set : 1;
4151 : : /* Hash value of constant equivalent for SET_SRC. */
4152 : : unsigned src_const_hash;
4153 : : /* A constant equivalent for SET_SRC, if any. */
4154 : : rtx src_const;
4155 : : /* Table entry for constant equivalent for SET_SRC, if any. */
4156 : : struct table_elt *src_const_elt;
4157 : : /* Table entry for the destination address. */
4158 : : struct table_elt *dest_addr_elt;
4159 : : };
4160 : :
4161 : : /* Special handling for (set REG0 REG1) where REG0 is the
4162 : : "cheapest", cheaper than REG1. After cse, REG1 will probably not
4163 : : be used in the sequel, so (if easily done) change this insn to
4164 : : (set REG1 REG0) and replace REG1 with REG0 in the previous insn
4165 : : that computed their value. Then REG1 will become a dead store
4166 : : and won't cloud the situation for later optimizations.
4167 : :
4168 : : Do not make this change if REG1 is a hard register, because it will
4169 : : then be used in the sequel and we may be changing a two-operand insn
4170 : : into a three-operand insn.
4171 : :
4172 : : This is the last transformation that cse_insn will try to do. */
4173 : :
4174 : : static void
4175 : 126823980 : try_back_substitute_reg (rtx set, rtx_insn *insn)
4176 : : {
4177 : 126823980 : rtx dest = SET_DEST (set);
4178 : 126823980 : rtx src = SET_SRC (set);
4179 : :
4180 : 126823980 : if (REG_P (dest)
4181 : 106382274 : && REG_P (src) && ! HARD_REGISTER_P (src)
4182 : 133448726 : && REGNO_QTY_VALID_P (REGNO (src)))
4183 : : {
4184 : 6624712 : int src_q = REG_QTY (REGNO (src));
4185 : 6624712 : struct qty_table_elem *src_ent = &qty_table[src_q];
4186 : :
4187 : 6624712 : if (src_ent->first_reg == REGNO (dest))
4188 : : {
4189 : : /* Scan for the previous nonnote insn, but stop at a basic
4190 : : block boundary. */
4191 : 1663648 : rtx_insn *prev = insn;
4192 : 1663648 : rtx_insn *bb_head = BB_HEAD (BLOCK_FOR_INSN (insn));
4193 : 3893152 : do
4194 : : {
4195 : 3893152 : prev = PREV_INSN (prev);
4196 : : }
4197 : 3893152 : while (prev != bb_head && (NOTE_P (prev) || DEBUG_INSN_P (prev)));
4198 : :
4199 : : /* Do not swap the registers around if the previous instruction
4200 : : attaches a REG_EQUIV note to REG1.
4201 : :
4202 : : ??? It's not entirely clear whether we can transfer a REG_EQUIV
4203 : : from the pseudo that originally shadowed an incoming argument
4204 : : to another register. Some uses of REG_EQUIV might rely on it
4205 : : being attached to REG1 rather than REG2.
4206 : :
4207 : : This section previously turned the REG_EQUIV into a REG_EQUAL
4208 : : note. We cannot do that because REG_EQUIV may provide an
4209 : : uninitialized stack slot when REG_PARM_STACK_SPACE is used. */
4210 : 1663648 : if (NONJUMP_INSN_P (prev)
4211 : 1005489 : && GET_CODE (PATTERN (prev)) == SET
4212 : 752483 : && SET_DEST (PATTERN (prev)) == src
4213 : 1870181 : && ! find_reg_note (prev, REG_EQUIV, NULL_RTX))
4214 : : {
4215 : 206468 : rtx note;
4216 : :
4217 : 206468 : validate_change (prev, &SET_DEST (PATTERN (prev)), dest, 1);
4218 : 206468 : validate_change (insn, &SET_DEST (set), src, 1);
4219 : 206468 : validate_change (insn, &SET_SRC (set), dest, 1);
4220 : 206468 : apply_change_group ();
4221 : :
4222 : : /* If INSN has a REG_EQUAL note, and this note mentions
4223 : : REG0, then we must delete it, because the value in
4224 : : REG0 has changed. If the note's value is REG1, we must
4225 : : also delete it because that is now this insn's dest. */
4226 : 206468 : note = find_reg_note (insn, REG_EQUAL, NULL_RTX);
4227 : 206468 : if (note != 0
4228 : 206468 : && (reg_mentioned_p (dest, XEXP (note, 0))
4229 : 1410 : || rtx_equal_p (src, XEXP (note, 0))))
4230 : 0 : remove_note (insn, note);
4231 : :
4232 : : /* If INSN has a REG_ARGS_SIZE note, move it to PREV. */
4233 : 206468 : note = find_reg_note (insn, REG_ARGS_SIZE, NULL_RTX);
4234 : 206468 : if (note != 0)
4235 : : {
4236 : 0 : remove_note (insn, note);
4237 : 0 : gcc_assert (!find_reg_note (prev, REG_ARGS_SIZE, NULL_RTX));
4238 : 0 : set_unique_reg_note (prev, REG_ARGS_SIZE, XEXP (note, 0));
4239 : : }
4240 : : }
4241 : : }
4242 : : }
4243 : 126823980 : }
4244 : :
4245 : : /* Add an entry containing RTL X into SETS. IS_FAKE_SET is true if X is
4246 : : an artifical set that has been created to describe part of an insn's
4247 : : effect. */
4248 : : static inline void
4249 : 181475920 : add_to_set (vec<struct set> *sets, rtx x, bool is_fake_set)
4250 : : {
4251 : 181475920 : struct set entry = {};
4252 : 181475920 : entry.rtl = x;
4253 : 181475920 : entry.is_fake_set = is_fake_set;
4254 : 181475920 : sets->safe_push (entry);
4255 : 181475920 : }
4256 : :
4257 : : /* Record all the SETs in this instruction into SETS_PTR,
4258 : : and return the number of recorded sets. */
4259 : : static int
4260 : 343692392 : find_sets_in_insn (rtx_insn *insn, vec<struct set> *psets)
4261 : : {
4262 : 343692392 : rtx x = PATTERN (insn);
4263 : :
4264 : 343692392 : if (GET_CODE (x) == SET)
4265 : : {
4266 : : /* Ignore SETs that are unconditional jumps.
4267 : : They never need cse processing, so this does not hurt.
4268 : : The reason is not efficiency but rather
4269 : : so that we can test at the end for instructions
4270 : : that have been simplified to unconditional jumps
4271 : : and not be misled by unchanged instructions
4272 : : that were unconditional jumps to begin with. */
4273 : 158250609 : if (SET_DEST (x) == pc_rtx
4274 : 18458000 : && GET_CODE (SET_SRC (x)) == LABEL_REF)
4275 : : ;
4276 : : /* Don't count call-insns, (set (reg 0) (call ...)), as a set.
4277 : : The hard function value register is used only once, to copy to
4278 : : someplace else, so it isn't worth cse'ing. */
4279 : 158250130 : else if (GET_CODE (SET_SRC (x)) == CALL)
4280 : : ;
4281 : 151375677 : else if (GET_CODE (SET_SRC (x)) == CONST_VECTOR
4282 : 529487 : && GET_MODE_CLASS (GET_MODE (SET_SRC (x))) != MODE_VECTOR_BOOL
4283 : : /* Prevent duplicates from being generated if the type is a V1
4284 : : type and a subreg. Folding this will result in the same
4285 : : element as folding x itself. */
4286 : 151905164 : && !(SUBREG_P (SET_DEST (x))
4287 : 68 : && known_eq (GET_MODE_NUNITS (GET_MODE (SET_SRC (x))), 1)))
4288 : : {
4289 : : /* First register the vector itself. */
4290 : 529487 : add_to_set (psets, x, false);
4291 : 529487 : rtx src = SET_SRC (x);
4292 : : /* Go over the constants of the CONST_VECTOR in forward order, to
4293 : : put them in the same order in the SETS array. */
4294 : 1059124 : for (unsigned i = 0; i < const_vector_encoded_nelts (src) ; i++)
4295 : : {
4296 : : /* These are templates and don't actually get emitted but are
4297 : : used to tell CSE how to get to a particular constant. */
4298 : 529637 : rtx y = simplify_gen_vec_select (SET_DEST (x), i);
4299 : 529637 : gcc_assert (y);
4300 : 529637 : rtx set = gen_rtx_SET (y, CONST_VECTOR_ELT (src, i));
4301 : 529637 : add_to_set (psets, set, true);
4302 : : }
4303 : : }
4304 : : else
4305 : 150846190 : add_to_set (psets, x, false);
4306 : : }
4307 : 185441783 : else if (GET_CODE (x) == PARALLEL)
4308 : : {
4309 : 28718466 : int i, lim = XVECLEN (x, 0);
4310 : :
4311 : : /* Go over the expressions of the PARALLEL in forward order, to
4312 : : put them in the same order in the SETS array. */
4313 : 87501214 : for (i = 0; i < lim; i++)
4314 : : {
4315 : 58782748 : rtx y = XVECEXP (x, 0, i);
4316 : 58782748 : if (GET_CODE (y) == SET)
4317 : : {
4318 : : /* As above, we ignore unconditional jumps and call-insns and
4319 : : ignore the result of apply_change_group. */
4320 : 29581500 : if (SET_DEST (y) == pc_rtx
4321 : 18074 : && GET_CODE (SET_SRC (y)) == LABEL_REF)
4322 : : ;
4323 : 29581500 : else if (GET_CODE (SET_SRC (y)) == CALL)
4324 : : ;
4325 : : else
4326 : 29570606 : add_to_set (psets, y, false);
4327 : : }
4328 : : }
4329 : : }
4330 : :
4331 : 343692392 : return psets->length ();
4332 : : }
4333 : :
4334 : : /* Subroutine of canonicalize_insn. X is an ASM_OPERANDS in INSN. */
4335 : :
4336 : : static void
4337 : 94656 : canon_asm_operands (rtx x, rtx_insn *insn)
4338 : : {
4339 : 121405 : for (int i = ASM_OPERANDS_INPUT_LENGTH (x) - 1; i >= 0; i--)
4340 : : {
4341 : 26749 : rtx input = ASM_OPERANDS_INPUT (x, i);
4342 : 26749 : if (!(REG_P (input) && HARD_REGISTER_P (input)))
4343 : : {
4344 : 26363 : input = canon_reg (input, insn);
4345 : 26363 : validate_change (insn, &ASM_OPERANDS_INPUT (x, i), input, 1);
4346 : : }
4347 : : }
4348 : 94656 : }
4349 : :
4350 : : /* Where possible, substitute every register reference in the N_SETS
4351 : : number of SETS in INSN with the canonical register.
4352 : :
4353 : : Register canonicalization propagatest the earliest register (i.e.
4354 : : one that is set before INSN) with the same value. This is a very
4355 : : useful, simple form of CSE, to clean up warts from expanding GIMPLE
4356 : : to RTL. For instance, a CONST for an address is usually expanded
4357 : : multiple times to loads into different registers, thus creating many
4358 : : subexpressions of the form:
4359 : :
4360 : : (set (reg1) (some_const))
4361 : : (set (mem (... reg1 ...) (thing)))
4362 : : (set (reg2) (some_const))
4363 : : (set (mem (... reg2 ...) (thing)))
4364 : :
4365 : : After canonicalizing, the code takes the following form:
4366 : :
4367 : : (set (reg1) (some_const))
4368 : : (set (mem (... reg1 ...) (thing)))
4369 : : (set (reg2) (some_const))
4370 : : (set (mem (... reg1 ...) (thing)))
4371 : :
4372 : : The set to reg2 is now trivially dead, and the memory reference (or
4373 : : address, or whatever) may be a candidate for further CSEing.
4374 : :
4375 : : In this function, the result of apply_change_group can be ignored;
4376 : : see canon_reg. */
4377 : :
4378 : : static void
4379 : 343692392 : canonicalize_insn (rtx_insn *insn, vec<struct set> *psets)
4380 : : {
4381 : 343692392 : vec<struct set> sets = *psets;
4382 : 343692392 : int n_sets = sets.length ();
4383 : 343692392 : rtx tem;
4384 : 343692392 : rtx x = PATTERN (insn);
4385 : 343692392 : int i;
4386 : :
4387 : 343692392 : if (CALL_P (insn))
4388 : : {
4389 : 41613203 : for (tem = CALL_INSN_FUNCTION_USAGE (insn); tem; tem = XEXP (tem, 1))
4390 : 26839875 : if (GET_CODE (XEXP (tem, 0)) != SET)
4391 : 26706960 : XEXP (tem, 0) = canon_reg (XEXP (tem, 0), insn);
4392 : : }
4393 : :
4394 : 343692392 : if (GET_CODE (x) == SET && GET_CODE (SET_SRC (x)) == CALL)
4395 : : {
4396 : 6874453 : canon_reg (SET_SRC (x), insn);
4397 : 6874453 : apply_change_group ();
4398 : 6874453 : fold_rtx (SET_SRC (x), insn);
4399 : : }
4400 : 336817939 : else if (GET_CODE (x) == CLOBBER)
4401 : : {
4402 : : /* If we clobber memory, canon the address.
4403 : : This does nothing when a register is clobbered
4404 : : because we have already invalidated the reg. */
4405 : 77631 : if (MEM_P (XEXP (x, 0)))
4406 : 12708 : canon_reg (XEXP (x, 0), insn);
4407 : : }
4408 : 336740308 : else if (GET_CODE (x) == USE
4409 : 336740308 : && ! (REG_P (XEXP (x, 0))
4410 : 1234872 : && REGNO (XEXP (x, 0)) < FIRST_PSEUDO_REGISTER))
4411 : : /* Canonicalize a USE of a pseudo register or memory location. */
4412 : 0 : canon_reg (x, insn);
4413 : 336740308 : else if (GET_CODE (x) == ASM_OPERANDS)
4414 : 18 : canon_asm_operands (x, insn);
4415 : 336740290 : else if (GET_CODE (x) == CALL)
4416 : : {
4417 : 7401327 : canon_reg (x, insn);
4418 : 7401327 : apply_change_group ();
4419 : 7401327 : fold_rtx (x, insn);
4420 : : }
4421 : 329338963 : else if (DEBUG_INSN_P (insn))
4422 : 147303924 : canon_reg (PATTERN (insn), insn);
4423 : 182035039 : else if (GET_CODE (x) == PARALLEL)
4424 : : {
4425 : 87501214 : for (i = XVECLEN (x, 0) - 1; i >= 0; i--)
4426 : : {
4427 : 58782748 : rtx y = XVECEXP (x, 0, i);
4428 : 58782748 : if (GET_CODE (y) == SET && GET_CODE (SET_SRC (y)) == CALL)
4429 : : {
4430 : 10894 : canon_reg (SET_SRC (y), insn);
4431 : 10894 : apply_change_group ();
4432 : 10894 : fold_rtx (SET_SRC (y), insn);
4433 : : }
4434 : 58771854 : else if (GET_CODE (y) == CLOBBER)
4435 : : {
4436 : 28277654 : if (MEM_P (XEXP (y, 0)))
4437 : 59092 : canon_reg (XEXP (y, 0), insn);
4438 : : }
4439 : 30494200 : else if (GET_CODE (y) == USE
4440 : 30494200 : && ! (REG_P (XEXP (y, 0))
4441 : 269429 : && REGNO (XEXP (y, 0)) < FIRST_PSEUDO_REGISTER))
4442 : 305071 : canon_reg (y, insn);
4443 : 30189129 : else if (GET_CODE (y) == ASM_OPERANDS)
4444 : 94638 : canon_asm_operands (y, insn);
4445 : 30094491 : else if (GET_CODE (y) == CALL)
4446 : : {
4447 : 486654 : canon_reg (y, insn);
4448 : 486654 : apply_change_group ();
4449 : 486654 : fold_rtx (y, insn);
4450 : : }
4451 : : }
4452 : : }
4453 : :
4454 : 178783667 : if (n_sets == 1 && REG_NOTES (insn) != 0
4455 : 459706353 : && (tem = find_reg_note (insn, REG_EQUAL, NULL_RTX)) != 0)
4456 : : {
4457 : : /* We potentially will process this insn many times. Therefore,
4458 : : drop the REG_EQUAL note if it is equal to the SET_SRC of the
4459 : : unique set in INSN.
4460 : :
4461 : : Do not do so if the REG_EQUAL note is for a STRICT_LOW_PART,
4462 : : because cse_insn handles those specially. */
4463 : 8155883 : if (GET_CODE (SET_DEST (sets[0].rtl)) != STRICT_LOW_PART
4464 : 8155883 : && rtx_equal_p (XEXP (tem, 0), SET_SRC (sets[0].rtl)))
4465 : 178239 : remove_note (insn, tem);
4466 : : else
4467 : : {
4468 : 7977644 : canon_reg (XEXP (tem, 0), insn);
4469 : 7977644 : apply_change_group ();
4470 : 7977644 : XEXP (tem, 0) = fold_rtx (XEXP (tem, 0), insn);
4471 : 7977644 : df_notes_rescan (insn);
4472 : : }
4473 : : }
4474 : :
4475 : : /* Canonicalize sources and addresses of destinations.
4476 : : We do this in a separate pass to avoid problems when a MATCH_DUP is
4477 : : present in the insn pattern. In that case, we want to ensure that
4478 : : we don't break the duplicate nature of the pattern. So we will replace
4479 : : both operands at the same time. Otherwise, we would fail to find an
4480 : : equivalent substitution in the loop calling validate_change below.
4481 : :
4482 : : We used to suppress canonicalization of DEST if it appears in SRC,
4483 : : but we don't do this any more. */
4484 : :
4485 : 525168312 : for (i = 0; i < n_sets; i++)
4486 : : {
4487 : 181475920 : rtx dest = SET_DEST (sets[i].rtl);
4488 : 181475920 : rtx src = SET_SRC (sets[i].rtl);
4489 : 181475920 : rtx new_rtx = canon_reg (src, insn);
4490 : :
4491 : 181475920 : validate_change (insn, &SET_SRC (sets[i].rtl), new_rtx, 1);
4492 : :
4493 : 181475920 : if (GET_CODE (dest) == ZERO_EXTRACT)
4494 : : {
4495 : 5458 : validate_change (insn, &XEXP (dest, 1),
4496 : : canon_reg (XEXP (dest, 1), insn), 1);
4497 : 5458 : validate_change (insn, &XEXP (dest, 2),
4498 : : canon_reg (XEXP (dest, 2), insn), 1);
4499 : : }
4500 : :
4501 : 182934019 : while (GET_CODE (dest) == SUBREG
4502 : 181496735 : || GET_CODE (dest) == ZERO_EXTRACT
4503 : 364425296 : || GET_CODE (dest) == STRICT_LOW_PART)
4504 : 1458099 : dest = XEXP (dest, 0);
4505 : :
4506 : 181475920 : if (MEM_P (dest))
4507 : 26162509 : canon_reg (dest, insn);
4508 : : }
4509 : :
4510 : : /* Now that we have done all the replacements, we can apply the change
4511 : : group and see if they all work. Note that this will cause some
4512 : : canonicalizations that would have worked individually not to be applied
4513 : : because some other canonicalization didn't work, but this should not
4514 : : occur often.
4515 : :
4516 : : The result of apply_change_group can be ignored; see canon_reg. */
4517 : :
4518 : 343692392 : apply_change_group ();
4519 : 343692392 : }
4520 : :
4521 : : /* Main function of CSE.
4522 : : First simplify sources and addresses of all assignments
4523 : : in the instruction, using previously-computed equivalents values.
4524 : : Then install the new sources and destinations in the table
4525 : : of available values. */
4526 : :
4527 : : static void
4528 : 343692392 : cse_insn (rtx_insn *insn)
4529 : : {
4530 : 343692392 : rtx x = PATTERN (insn);
4531 : 343692392 : int i;
4532 : 343692392 : rtx tem;
4533 : 343692392 : int n_sets = 0;
4534 : :
4535 : 343692392 : rtx src_eqv = 0;
4536 : 343692392 : struct table_elt *src_eqv_elt = 0;
4537 : 343692392 : int src_eqv_volatile = 0;
4538 : 343692392 : int src_eqv_in_memory = 0;
4539 : 343692392 : unsigned src_eqv_hash = 0;
4540 : :
4541 : 343692392 : this_insn = insn;
4542 : :
4543 : : /* Find all regs explicitly clobbered in this insn,
4544 : : to ensure they are not replaced with any other regs
4545 : : elsewhere in this insn. */
4546 : 343692392 : invalidate_from_sets_and_clobbers (insn);
4547 : :
4548 : : /* Record all the SETs in this instruction. */
4549 : 343692392 : auto_vec<struct set, 8> sets;
4550 : 343692392 : n_sets = find_sets_in_insn (insn, (vec<struct set>*)&sets);
4551 : :
4552 : : /* Substitute the canonical register where possible. */
4553 : 343692392 : canonicalize_insn (insn, (vec<struct set>*)&sets);
4554 : :
4555 : : /* If this insn has a REG_EQUAL note, store the equivalent value in SRC_EQV,
4556 : : if different, or if the DEST is a STRICT_LOW_PART/ZERO_EXTRACT. The
4557 : : latter condition is necessary because SRC_EQV is handled specially for
4558 : : this case, and if it isn't set, then there will be no equivalence
4559 : : for the destination. */
4560 : 178783667 : if (n_sets == 1 && REG_NOTES (insn) != 0
4561 : 459565158 : && (tem = find_reg_note (insn, REG_EQUAL, NULL_RTX)) != 0)
4562 : : {
4563 : :
4564 : 7977644 : if (GET_CODE (SET_DEST (sets[0].rtl)) != ZERO_EXTRACT
4565 : 7977644 : && (! rtx_equal_p (XEXP (tem, 0), SET_SRC (sets[0].rtl))
4566 : 16232 : || GET_CODE (SET_DEST (sets[0].rtl)) == STRICT_LOW_PART))
4567 : 7961412 : src_eqv = copy_rtx (XEXP (tem, 0));
4568 : : /* If DEST is of the form ZERO_EXTACT, as in:
4569 : : (set (zero_extract:SI (reg:SI 119)
4570 : : (const_int 16 [0x10])
4571 : : (const_int 16 [0x10]))
4572 : : (const_int 51154 [0xc7d2]))
4573 : : REG_EQUAL note will specify the value of register (reg:SI 119) at this
4574 : : point. Note that this is different from SRC_EQV. We can however
4575 : : calculate SRC_EQV with the position and width of ZERO_EXTRACT. */
4576 : 16232 : else if (GET_CODE (SET_DEST (sets[0].rtl)) == ZERO_EXTRACT
4577 : 0 : && CONST_INT_P (XEXP (tem, 0))
4578 : 0 : && CONST_INT_P (XEXP (SET_DEST (sets[0].rtl), 1))
4579 : 16232 : && CONST_INT_P (XEXP (SET_DEST (sets[0].rtl), 2)))
4580 : : {
4581 : 0 : rtx dest_reg = XEXP (SET_DEST (sets[0].rtl), 0);
4582 : : /* This is the mode of XEXP (tem, 0) as well. */
4583 : 0 : scalar_int_mode dest_mode
4584 : 0 : = as_a <scalar_int_mode> (GET_MODE (dest_reg));
4585 : 0 : rtx width = XEXP (SET_DEST (sets[0].rtl), 1);
4586 : 0 : rtx pos = XEXP (SET_DEST (sets[0].rtl), 2);
4587 : 0 : HOST_WIDE_INT val = INTVAL (XEXP (tem, 0));
4588 : 0 : HOST_WIDE_INT mask;
4589 : 0 : unsigned int shift;
4590 : 0 : if (BITS_BIG_ENDIAN)
4591 : : shift = (GET_MODE_PRECISION (dest_mode)
4592 : : - INTVAL (pos) - INTVAL (width));
4593 : : else
4594 : 0 : shift = INTVAL (pos);
4595 : 0 : if (INTVAL (width) == HOST_BITS_PER_WIDE_INT)
4596 : : mask = HOST_WIDE_INT_M1;
4597 : : else
4598 : 0 : mask = (HOST_WIDE_INT_1 << INTVAL (width)) - 1;
4599 : 0 : val = (val >> shift) & mask;
4600 : 0 : src_eqv = GEN_INT (val);
4601 : : }
4602 : : }
4603 : :
4604 : : /* Set sets[i].src_elt to the class each source belongs to.
4605 : : Detect assignments from or to volatile things
4606 : : and set set[i] to zero so they will be ignored
4607 : : in the rest of this function.
4608 : :
4609 : : Nothing in this loop changes the hash table or the register chains. */
4610 : :
4611 : 525168312 : for (i = 0; i < n_sets; i++)
4612 : : {
4613 : 181475920 : bool repeat = false;
4614 : 181475920 : bool noop_insn = false;
4615 : 181475920 : rtx src, dest;
4616 : 181475920 : rtx src_folded;
4617 : 181475920 : struct table_elt *elt = 0, *p;
4618 : 181475920 : machine_mode mode;
4619 : 181475920 : rtx src_eqv_here;
4620 : 181475920 : rtx src_const = 0;
4621 : 181475920 : rtx src_related = 0;
4622 : 181475920 : rtx dest_related = 0;
4623 : 181475920 : bool src_related_is_const_anchor = false;
4624 : 181475920 : struct table_elt *src_const_elt = 0;
4625 : 181475920 : int src_cost = MAX_COST;
4626 : 181475920 : int src_eqv_cost = MAX_COST;
4627 : 181475920 : int src_folded_cost = MAX_COST;
4628 : 181475920 : int src_related_cost = MAX_COST;
4629 : 181475920 : int src_elt_cost = MAX_COST;
4630 : 181475920 : int src_regcost = MAX_COST;
4631 : 181475920 : int src_eqv_regcost = MAX_COST;
4632 : 181475920 : int src_folded_regcost = MAX_COST;
4633 : 181475920 : int src_related_regcost = MAX_COST;
4634 : 181475920 : int src_elt_regcost = MAX_COST;
4635 : 181475920 : scalar_int_mode int_mode;
4636 : 181475920 : bool is_fake_set = sets[i].is_fake_set;
4637 : :
4638 : 181475920 : dest = SET_DEST (sets[i].rtl);
4639 : 181475920 : src = SET_SRC (sets[i].rtl);
4640 : :
4641 : : /* If SRC is a constant that has no machine mode,
4642 : : hash it with the destination's machine mode.
4643 : : This way we can keep different modes separate. */
4644 : :
4645 : 181475920 : mode = GET_MODE (src) == VOIDmode ? GET_MODE (dest) : GET_MODE (src);
4646 : 181475920 : sets[i].mode = mode;
4647 : :
4648 : 181475920 : if (!is_fake_set && src_eqv)
4649 : : {
4650 : 7961412 : machine_mode eqvmode = mode;
4651 : 7961412 : if (GET_CODE (dest) == STRICT_LOW_PART)
4652 : 0 : eqvmode = GET_MODE (SUBREG_REG (XEXP (dest, 0)));
4653 : 7961412 : do_not_record = 0;
4654 : 7961412 : hash_arg_in_memory = 0;
4655 : 7961412 : src_eqv_hash = HASH (src_eqv, eqvmode);
4656 : :
4657 : : /* Find the equivalence class for the equivalent expression. */
4658 : :
4659 : 7961412 : if (!do_not_record)
4660 : 7959212 : src_eqv_elt = lookup (src_eqv, src_eqv_hash, eqvmode);
4661 : :
4662 : 7961412 : src_eqv_volatile = do_not_record;
4663 : 7961412 : src_eqv_in_memory = hash_arg_in_memory;
4664 : : }
4665 : :
4666 : : /* If this is a STRICT_LOW_PART assignment, src_eqv corresponds to the
4667 : : value of the INNER register, not the destination. So it is not
4668 : : a valid substitution for the source. But save it for later. */
4669 : 181475920 : if (is_fake_set || GET_CODE (dest) == STRICT_LOW_PART)
4670 : : src_eqv_here = 0;
4671 : : else
4672 : 181475920 : src_eqv_here = src_eqv;
4673 : :
4674 : : /* Simplify and foldable subexpressions in SRC. Then get the fully-
4675 : : simplified result, which may not necessarily be valid. */
4676 : 181475920 : src_folded = fold_rtx (src, NULL);
4677 : :
4678 : : #if 0
4679 : : /* ??? This caused bad code to be generated for the m68k port with -O2.
4680 : : Suppose src is (CONST_INT -1), and that after truncation src_folded
4681 : : is (CONST_INT 3). Suppose src_folded is then used for src_const.
4682 : : At the end we will add src and src_const to the same equivalence
4683 : : class. We now have 3 and -1 on the same equivalence class. This
4684 : : causes later instructions to be mis-optimized. */
4685 : : /* If storing a constant in a bitfield, pre-truncate the constant
4686 : : so we will be able to record it later. */
4687 : : if (GET_CODE (SET_DEST (sets[i].rtl)) == ZERO_EXTRACT)
4688 : : {
4689 : : rtx width = XEXP (SET_DEST (sets[i].rtl), 1);
4690 : :
4691 : : if (CONST_INT_P (src)
4692 : : && CONST_INT_P (width)
4693 : : && INTVAL (width) < HOST_BITS_PER_WIDE_INT
4694 : : && (INTVAL (src) & ((HOST_WIDE_INT) (-1) << INTVAL (width))))
4695 : : src_folded
4696 : : = GEN_INT (INTVAL (src) & ((HOST_WIDE_INT_1
4697 : : << INTVAL (width)) - 1));
4698 : : }
4699 : : #endif
4700 : :
4701 : : /* Compute SRC's hash code, and also notice if it
4702 : : should not be recorded at all. In that case,
4703 : : prevent any further processing of this assignment.
4704 : :
4705 : : We set DO_NOT_RECORD if the destination has a REG_UNUSED note.
4706 : : This avoids getting the source register into the tables, where it
4707 : : may be invalidated later (via REG_QTY), then trigger an ICE upon
4708 : : re-insertion.
4709 : :
4710 : : This is only a problem in multi-set insns. If it were a single
4711 : : set the dead copy would have been removed. If the RHS were anything
4712 : : but a simple REG, then we won't call insert_regs and thus there's
4713 : : no potential for triggering the ICE. */
4714 : 362951840 : do_not_record = (REG_P (dest)
4715 : 135398866 : && REG_P (src)
4716 : 214011988 : && find_reg_note (insn, REG_UNUSED, dest));
4717 : 181475920 : hash_arg_in_memory = 0;
4718 : :
4719 : 181475920 : sets[i].src = src;
4720 : 181475920 : sets[i].src_hash = HASH (src, mode);
4721 : 181475920 : sets[i].src_volatile = do_not_record;
4722 : 181475920 : sets[i].src_in_memory = hash_arg_in_memory;
4723 : :
4724 : : /* If SRC is a MEM, there is a REG_EQUIV note for SRC, and DEST is
4725 : : a pseudo, do not record SRC. Using SRC as a replacement for
4726 : : anything else will be incorrect in that situation. Note that
4727 : : this usually occurs only for stack slots, in which case all the
4728 : : RTL would be referring to SRC, so we don't lose any optimization
4729 : : opportunities by not having SRC in the hash table. */
4730 : :
4731 : 181475920 : if (MEM_P (src)
4732 : 23468179 : && find_reg_note (insn, REG_EQUIV, NULL_RTX) != 0
4733 : 915894 : && REG_P (dest)
4734 : 182391814 : && REGNO (dest) >= FIRST_PSEUDO_REGISTER)
4735 : 915894 : sets[i].src_volatile = 1;
4736 : :
4737 : 180560026 : else if (GET_CODE (src) == ASM_OPERANDS
4738 : 182688 : && GET_CODE (x) == PARALLEL)
4739 : : {
4740 : : /* Do not record result of a non-volatile inline asm with
4741 : : more than one result. */
4742 : 182664 : if (n_sets > 1)
4743 : 140289 : sets[i].src_volatile = 1;
4744 : :
4745 : 182664 : int j, lim = XVECLEN (x, 0);
4746 : 937996 : for (j = 0; j < lim; j++)
4747 : : {
4748 : 757134 : rtx y = XVECEXP (x, 0, j);
4749 : : /* And do not record result of a non-volatile inline asm
4750 : : with "memory" clobber. */
4751 : 757134 : if (GET_CODE (y) == CLOBBER && MEM_P (XEXP (y, 0)))
4752 : : {
4753 : 1802 : sets[i].src_volatile = 1;
4754 : 1802 : break;
4755 : : }
4756 : : }
4757 : : }
4758 : :
4759 : : #if 0
4760 : : /* It is no longer clear why we used to do this, but it doesn't
4761 : : appear to still be needed. So let's try without it since this
4762 : : code hurts cse'ing widened ops. */
4763 : : /* If source is a paradoxical subreg (such as QI treated as an SI),
4764 : : treat it as volatile. It may do the work of an SI in one context
4765 : : where the extra bits are not being used, but cannot replace an SI
4766 : : in general. */
4767 : : if (paradoxical_subreg_p (src))
4768 : : sets[i].src_volatile = 1;
4769 : : #endif
4770 : :
4771 : : /* Locate all possible equivalent forms for SRC. Try to replace
4772 : : SRC in the insn with each cheaper equivalent.
4773 : :
4774 : : We have the following types of equivalents: SRC itself, a folded
4775 : : version, a value given in a REG_EQUAL note, or a value related
4776 : : to a constant.
4777 : :
4778 : : Each of these equivalents may be part of an additional class
4779 : : of equivalents (if more than one is in the table, they must be in
4780 : : the same class; we check for this).
4781 : :
4782 : : If the source is volatile, we don't do any table lookups.
4783 : :
4784 : : We note any constant equivalent for possible later use in a
4785 : : REG_NOTE. */
4786 : :
4787 : 181475920 : if (!sets[i].src_volatile)
4788 : 149199621 : elt = lookup (src, sets[i].src_hash, mode);
4789 : :
4790 : 181475920 : sets[i].src_elt = elt;
4791 : :
4792 : 181475920 : if (elt && src_eqv_here && src_eqv_elt)
4793 : : {
4794 : 2652744 : if (elt->first_same_value != src_eqv_elt->first_same_value)
4795 : : {
4796 : : /* The REG_EQUAL is indicating that two formerly distinct
4797 : : classes are now equivalent. So merge them. */
4798 : 10741 : merge_equiv_classes (elt, src_eqv_elt);
4799 : 10741 : src_eqv_hash = HASH (src_eqv, elt->mode);
4800 : 10741 : src_eqv_elt = lookup (src_eqv, src_eqv_hash, elt->mode);
4801 : : }
4802 : :
4803 : 10741 : src_eqv_here = 0;
4804 : : }
4805 : :
4806 : 178634111 : else if (src_eqv_elt)
4807 : : elt = src_eqv_elt;
4808 : :
4809 : : /* Try to find a constant somewhere and record it in `src_const'.
4810 : : Record its table element, if any, in `src_const_elt'. Look in
4811 : : any known equivalences first. (If the constant is not in the
4812 : : table, also set `sets[i].src_const_hash'). */
4813 : 178482986 : if (elt)
4814 : 85194105 : for (p = elt->first_same_value; p; p = p->next_same_value)
4815 : 68402470 : if (p->is_const)
4816 : : {
4817 : 14635483 : src_const = p->exp;
4818 : 14635483 : src_const_elt = elt;
4819 : 14635483 : break;
4820 : : }
4821 : :
4822 : 31427118 : if (src_const == 0
4823 : 166840437 : && (CONSTANT_P (src_folded)
4824 : : /* Consider (minus (label_ref L1) (label_ref L2)) as
4825 : : "constant" here so we will record it. This allows us
4826 : : to fold switch statements when an ADDR_DIFF_VEC is used. */
4827 : 141956083 : || (GET_CODE (src_folded) == MINUS
4828 : 1631004 : && GET_CODE (XEXP (src_folded, 0)) == LABEL_REF
4829 : 95 : && GET_CODE (XEXP (src_folded, 1)) == LABEL_REF)))
4830 : : src_const = src_folded, src_const_elt = elt;
4831 : 156591480 : else if (src_const == 0 && src_eqv_here && CONSTANT_P (src_eqv_here))
4832 : 400691 : src_const = src_eqv_here, src_const_elt = src_eqv_elt;
4833 : :
4834 : : /* If we don't know if the constant is in the table, get its
4835 : : hash code and look it up. */
4836 : 181475920 : if (src_const && src_const_elt == 0)
4837 : : {
4838 : 25284929 : sets[i].src_const_hash = HASH (src_const, mode);
4839 : 25284929 : src_const_elt = lookup (src_const, sets[i].src_const_hash, mode);
4840 : : }
4841 : :
4842 : 181475920 : sets[i].src_const = src_const;
4843 : 181475920 : sets[i].src_const_elt = src_const_elt;
4844 : :
4845 : : /* If the constant and our source are both in the table, mark them as
4846 : : equivalent. Otherwise, if a constant is in the table but the source
4847 : : isn't, set ELT to it. */
4848 : 181475920 : if (src_const_elt && elt
4849 : 14635685 : && src_const_elt->first_same_value != elt->first_same_value)
4850 : 0 : merge_equiv_classes (elt, src_const_elt);
4851 : 181475920 : else if (src_const_elt && elt == 0)
4852 : 181475920 : elt = src_const_elt;
4853 : :
4854 : : /* See if there is a register linearly related to a constant
4855 : : equivalent of SRC. */
4856 : 181475920 : if (src_const
4857 : 39920614 : && (GET_CODE (src_const) == CONST
4858 : 39330789 : || (src_const_elt && src_const_elt->related_value != 0)))
4859 : : {
4860 : 673095 : src_related = use_related_value (src_const, src_const_elt);
4861 : 673095 : if (src_related)
4862 : : {
4863 : 224390 : struct table_elt *src_related_elt
4864 : 224390 : = lookup (src_related, HASH (src_related, mode), mode);
4865 : 224390 : if (src_related_elt && elt)
4866 : : {
4867 : 1230 : if (elt->first_same_value
4868 : 1230 : != src_related_elt->first_same_value)
4869 : : /* This can occur when we previously saw a CONST
4870 : : involving a SYMBOL_REF and then see the SYMBOL_REF
4871 : : twice. Merge the involved classes. */
4872 : 791 : merge_equiv_classes (elt, src_related_elt);
4873 : :
4874 : : src_related = 0;
4875 : 181475920 : src_related_elt = 0;
4876 : : }
4877 : 223160 : else if (src_related_elt && elt == 0)
4878 : 6549 : elt = src_related_elt;
4879 : : }
4880 : : }
4881 : :
4882 : : /* See if we have a CONST_INT that is already in a register in a
4883 : : wider mode. */
4884 : :
4885 : 39697454 : if (src_const && src_related == 0 && CONST_INT_P (src_const)
4886 : 17251680 : && is_int_mode (mode, &int_mode)
4887 : 200771665 : && GET_MODE_PRECISION (int_mode) < BITS_PER_WORD)
4888 : : {
4889 : 7339841 : opt_scalar_int_mode wider_mode_iter;
4890 : 19272007 : FOR_EACH_WIDER_MODE (wider_mode_iter, int_mode)
4891 : : {
4892 : 19272007 : scalar_int_mode wider_mode = wider_mode_iter.require ();
4893 : 20189572 : if (GET_MODE_PRECISION (wider_mode) > BITS_PER_WORD)
4894 : : break;
4895 : :
4896 : 12170021 : struct table_elt *const_elt
4897 : 12170021 : = lookup (src_const, HASH (src_const, wider_mode), wider_mode);
4898 : :
4899 : 12170021 : if (const_elt == 0)
4900 : 11482846 : continue;
4901 : :
4902 : 687175 : for (const_elt = const_elt->first_same_value;
4903 : 2049890 : const_elt; const_elt = const_elt->next_same_value)
4904 : 1600570 : if (REG_P (const_elt->exp))
4905 : : {
4906 : 237855 : src_related = gen_lowpart (int_mode, const_elt->exp);
4907 : 237855 : break;
4908 : : }
4909 : :
4910 : 687175 : if (src_related != 0)
4911 : : break;
4912 : : }
4913 : : }
4914 : :
4915 : : /* Another possibility is that we have an AND with a constant in
4916 : : a mode narrower than a word. If so, it might have been generated
4917 : : as part of an "if" which would narrow the AND. If we already
4918 : : have done the AND in a wider mode, we can use a SUBREG of that
4919 : : value. */
4920 : :
4921 : 177552220 : if (flag_expensive_optimizations && ! src_related
4922 : 303889774 : && is_a <scalar_int_mode> (mode, &int_mode)
4923 : 122413854 : && GET_CODE (src) == AND && CONST_INT_P (XEXP (src, 1))
4924 : 182959633 : && GET_MODE_SIZE (int_mode) < UNITS_PER_WORD)
4925 : : {
4926 : 938893 : opt_scalar_int_mode tmode_iter;
4927 : 938893 : rtx new_and = gen_rtx_AND (VOIDmode, NULL_RTX, XEXP (src, 1));
4928 : :
4929 : 2694525 : FOR_EACH_WIDER_MODE (tmode_iter, int_mode)
4930 : : {
4931 : 2694525 : scalar_int_mode tmode = tmode_iter.require ();
4932 : 5527486 : if (GET_MODE_SIZE (tmode) > UNITS_PER_WORD)
4933 : : break;
4934 : :
4935 : 1755687 : rtx inner = gen_lowpart (tmode, XEXP (src, 0));
4936 : 1755687 : struct table_elt *larger_elt;
4937 : :
4938 : 1755687 : if (inner)
4939 : : {
4940 : 1755379 : PUT_MODE (new_and, tmode);
4941 : 1755379 : XEXP (new_and, 0) = inner;
4942 : 1755379 : larger_elt = lookup (new_and, HASH (new_and, tmode), tmode);
4943 : 1755379 : if (larger_elt == 0)
4944 : 1755324 : continue;
4945 : :
4946 : 55 : for (larger_elt = larger_elt->first_same_value;
4947 : 55 : larger_elt; larger_elt = larger_elt->next_same_value)
4948 : 55 : if (REG_P (larger_elt->exp))
4949 : : {
4950 : 55 : src_related
4951 : 55 : = gen_lowpart (int_mode, larger_elt->exp);
4952 : 55 : break;
4953 : : }
4954 : :
4955 : 55 : if (src_related)
4956 : : break;
4957 : : }
4958 : : }
4959 : : }
4960 : :
4961 : : /* See if a MEM has already been loaded with a widening operation;
4962 : : if it has, we can use a subreg of that. Many CISC machines
4963 : : also have such operations, but this is only likely to be
4964 : : beneficial on these machines. */
4965 : :
4966 : 181475920 : rtx_code extend_op;
4967 : 181475920 : if (flag_expensive_optimizations && src_related == 0
4968 : : && MEM_P (src) && ! do_not_record
4969 : : && is_a <scalar_int_mode> (mode, &int_mode)
4970 : : && (extend_op = load_extend_op (int_mode)) != UNKNOWN)
4971 : : {
4972 : : #if GCC_VERSION >= 5000
4973 : : struct rtx_def memory_extend_buf;
4974 : : rtx memory_extend_rtx = &memory_extend_buf;
4975 : : #else
4976 : : /* Workaround GCC < 5 bug, fixed in r5-3834 as part of PR63362
4977 : : fix. */
4978 : : alignas (rtx_def) unsigned char memory_extended_buf[sizeof (rtx_def)];
4979 : : rtx memory_extend_rtx = (rtx) &memory_extended_buf[0];
4980 : : #endif
4981 : :
4982 : : /* Set what we are trying to extend and the operation it might
4983 : : have been extended with. */
4984 : : memset (memory_extend_rtx, 0, sizeof (*memory_extend_rtx));
4985 : : PUT_CODE (memory_extend_rtx, extend_op);
4986 : : XEXP (memory_extend_rtx, 0) = src;
4987 : :
4988 : : opt_scalar_int_mode tmode_iter;
4989 : : FOR_EACH_WIDER_MODE (tmode_iter, int_mode)
4990 : : {
4991 : : struct table_elt *larger_elt;
4992 : :
4993 : : scalar_int_mode tmode = tmode_iter.require ();
4994 : : if (GET_MODE_SIZE (tmode) > UNITS_PER_WORD)
4995 : : break;
4996 : :
4997 : : PUT_MODE (memory_extend_rtx, tmode);
4998 : : larger_elt = lookup (memory_extend_rtx,
4999 : : HASH (memory_extend_rtx, tmode), tmode);
5000 : : if (larger_elt == 0)
5001 : : continue;
5002 : :
5003 : : for (larger_elt = larger_elt->first_same_value;
5004 : : larger_elt; larger_elt = larger_elt->next_same_value)
5005 : : if (REG_P (larger_elt->exp))
5006 : : {
5007 : : src_related = gen_lowpart (int_mode, larger_elt->exp);
5008 : : break;
5009 : : }
5010 : :
5011 : : if (src_related)
5012 : : break;
5013 : : }
5014 : : }
5015 : :
5016 : : /* Try to express the constant using a register+offset expression
5017 : : derived from a constant anchor. */
5018 : :
5019 : 181475920 : if (targetm.const_anchor
5020 : 0 : && !src_related
5021 : 0 : && src_const
5022 : 0 : && GET_CODE (src_const) == CONST_INT)
5023 : : {
5024 : 0 : src_related = try_const_anchors (src_const, mode);
5025 : 0 : src_related_is_const_anchor = src_related != NULL_RTX;
5026 : : }
5027 : :
5028 : : /* Try to re-materialize a vec_dup with an existing constant. */
5029 : 181475920 : rtx src_elt;
5030 : 5308668 : if ((!src_eqv_here || CONSTANT_P (src_eqv_here))
5031 : 181475920 : && const_vec_duplicate_p (src, &src_elt))
5032 : : {
5033 : 534175 : machine_mode const_mode = GET_MODE_INNER (GET_MODE (src));
5034 : 534175 : struct table_elt *related_elt
5035 : 534175 : = lookup (src_elt, HASH (src_elt, const_mode), const_mode);
5036 : 534175 : if (related_elt)
5037 : : {
5038 : 231459 : for (related_elt = related_elt->first_same_value;
5039 : 1550338 : related_elt; related_elt = related_elt->next_same_value)
5040 : 1352652 : if (REG_P (related_elt->exp))
5041 : : {
5042 : : /* We don't need to compare costs with an existing (constant)
5043 : : src_eqv_here, since any such src_eqv_here should already be
5044 : : available in src_const. */
5045 : 33773 : src_eqv_here
5046 : 33773 : = gen_rtx_VEC_DUPLICATE (GET_MODE (src),
5047 : : related_elt->exp);
5048 : 33773 : break;
5049 : : }
5050 : : }
5051 : : }
5052 : :
5053 : 181475920 : if (src == src_folded)
5054 : 177237552 : src_folded = 0;
5055 : :
5056 : : /* At this point, ELT, if nonzero, points to a class of expressions
5057 : : equivalent to the source of this SET and SRC, SRC_EQV, SRC_FOLDED,
5058 : : and SRC_RELATED, if nonzero, each contain additional equivalent
5059 : : expressions. Prune these latter expressions by deleting expressions
5060 : : already in the equivalence class.
5061 : :
5062 : : Check for an equivalent identical to the destination. If found,
5063 : : this is the preferred equivalent since it will likely lead to
5064 : : elimination of the insn. Indicate this by placing it in
5065 : : `src_related'. */
5066 : :
5067 : 181475920 : if (elt)
5068 : 31507935 : elt = elt->first_same_value;
5069 : 270426147 : for (p = elt; p; p = p->next_same_value)
5070 : : {
5071 : 88950227 : enum rtx_code code = GET_CODE (p->exp);
5072 : :
5073 : : /* If the expression is not valid, ignore it. Then we do not
5074 : : have to check for validity below. In most cases, we can use
5075 : : `rtx_equal_p', since canonicalization has already been done. */
5076 : 88950227 : if (code != REG && ! exp_equiv_p (p->exp, p->exp, 1, false))
5077 : 5774 : continue;
5078 : :
5079 : : /* Also skip paradoxical subregs, unless that's what we're
5080 : : looking for. */
5081 : 88947319 : if (paradoxical_subreg_p (p->exp)
5082 : 88947319 : && ! (src != 0
5083 : 2866 : && GET_CODE (src) == SUBREG
5084 : 2866 : && GET_MODE (src) == GET_MODE (p->exp)
5085 : 2866 : && partial_subreg_p (GET_MODE (SUBREG_REG (src)),
5086 : 2866 : GET_MODE (SUBREG_REG (p->exp)))))
5087 : 2866 : continue;
5088 : :
5089 : 88941587 : if (src && GET_CODE (src) == code && rtx_equal_p (src, p->exp))
5090 : : src = 0;
5091 : 2088759 : else if (src_folded && GET_CODE (src_folded) == code
5092 : 58403293 : && rtx_equal_p (src_folded, p->exp))
5093 : : src_folded = 0;
5094 : 706262 : else if (src_eqv_here && GET_CODE (src_eqv_here) == code
5095 : 57626914 : && rtx_equal_p (src_eqv_here, p->exp))
5096 : : src_eqv_here = 0;
5097 : 522714 : else if (src_related && GET_CODE (src_related) == code
5098 : 57118099 : && rtx_equal_p (src_related, p->exp))
5099 : : src_related = 0;
5100 : :
5101 : : /* This is the same as the destination of the insns, we want
5102 : : to prefer it. The code below will then give it a negative
5103 : : cost. */
5104 : 88941587 : if (!dest_related
5105 : 88941587 : && GET_CODE (dest) == code && rtx_equal_p (p->exp, dest))
5106 : 243839 : dest_related = p->exp;
5107 : : }
5108 : :
5109 : : /* Find the cheapest valid equivalent, trying all the available
5110 : : possibilities. Prefer items not in the hash table to ones
5111 : : that are when they are equal cost. Note that we can never
5112 : : worsen an insn as the current contents will also succeed.
5113 : : If we find an equivalent identical to the destination, use it as best,
5114 : : since this insn will probably be eliminated in that case. */
5115 : 181475920 : if (src)
5116 : : {
5117 : 150411434 : if (rtx_equal_p (src, dest))
5118 : : src_cost = src_regcost = -1;
5119 : : else
5120 : : {
5121 : 150411368 : src_cost = COST (src, mode);
5122 : 150411368 : src_regcost = approx_reg_cost (src);
5123 : : }
5124 : : }
5125 : :
5126 : 181475920 : if (src_eqv_here)
5127 : : {
5128 : 5067445 : if (rtx_equal_p (src_eqv_here, dest))
5129 : : src_eqv_cost = src_eqv_regcost = -1;
5130 : : else
5131 : : {
5132 : 5067445 : src_eqv_cost = COST (src_eqv_here, mode);
5133 : 5067445 : src_eqv_regcost = approx_reg_cost (src_eqv_here);
5134 : : }
5135 : : }
5136 : :
5137 : 181475920 : if (src_folded)
5138 : : {
5139 : 3712820 : if (rtx_equal_p (src_folded, dest))
5140 : : src_folded_cost = src_folded_regcost = -1;
5141 : : else
5142 : : {
5143 : 3700781 : src_folded_cost = COST (src_folded, mode);
5144 : 3700781 : src_folded_regcost = approx_reg_cost (src_folded);
5145 : : }
5146 : : }
5147 : :
5148 : 181475920 : if (dest_related)
5149 : : {
5150 : : src_related_cost = src_related_regcost = -1;
5151 : : /* Handle it as src_related. */
5152 : : src_related = dest_related;
5153 : : }
5154 : 181232081 : else if (src_related)
5155 : : {
5156 : 458877 : src_related_cost = COST (src_related, mode);
5157 : 458877 : src_related_regcost = approx_reg_cost (src_related);
5158 : :
5159 : : /* If a const-anchor is used to synthesize a constant that
5160 : : normally requires multiple instructions then slightly prefer
5161 : : it over the original sequence. These instructions are likely
5162 : : to become redundant now. We can't compare against the cost
5163 : : of src_eqv_here because, on MIPS for example, multi-insn
5164 : : constants have zero cost; they are assumed to be hoisted from
5165 : : loops. */
5166 : 458877 : if (src_related_is_const_anchor
5167 : 458877 : && src_related_cost == src_cost
5168 : 0 : && src_eqv_here)
5169 : 0 : src_related_cost--;
5170 : : }
5171 : :
5172 : : /* If this was an indirect jump insn, a known label will really be
5173 : : cheaper even though it looks more expensive. */
5174 : 181475920 : if (dest == pc_rtx && src_const && GET_CODE (src_const) == LABEL_REF)
5175 : 181475920 : src_folded = src_const, src_folded_cost = src_folded_regcost = -1;
5176 : :
5177 : : /* Terminate loop when replacement made. This must terminate since
5178 : : the current contents will be tested and will always be valid. */
5179 : 186400798 : while (!is_fake_set)
5180 : : {
5181 : : rtx trial;
5182 : :
5183 : : /* Skip invalid entries. */
5184 : 32226931 : while (elt && !REG_P (elt->exp)
5185 : 193754047 : && ! exp_equiv_p (elt->exp, elt->exp, 1, false))
5186 : 8 : elt = elt->next_same_value;
5187 : :
5188 : : /* A paradoxical subreg would be bad here: it'll be the right
5189 : : size, but later may be adjusted so that the upper bits aren't
5190 : : what we want. So reject it. */
5191 : 185872485 : if (elt != 0
5192 : 32226923 : && paradoxical_subreg_p (elt->exp)
5193 : : /* It is okay, though, if the rtx we're trying to match
5194 : : will ignore any of the bits we can't predict. */
5195 : 185873809 : && ! (src != 0
5196 : 1324 : && GET_CODE (src) == SUBREG
5197 : 1324 : && GET_MODE (src) == GET_MODE (elt->exp)
5198 : 1324 : && partial_subreg_p (GET_MODE (SUBREG_REG (src)),
5199 : 1324 : GET_MODE (SUBREG_REG (elt->exp)))))
5200 : : {
5201 : 1324 : elt = elt->next_same_value;
5202 : 1324 : continue;
5203 : : }
5204 : :
5205 : 185869837 : if (elt)
5206 : : {
5207 : 32225599 : src_elt_cost = elt->cost;
5208 : 32225599 : src_elt_regcost = elt->regcost;
5209 : : }
5210 : :
5211 : : /* Find cheapest and skip it for the next time. For items
5212 : : of equal cost, use this order:
5213 : : src_folded, src, src_eqv, src_related and hash table entry. */
5214 : 185869837 : if (src_folded
5215 : 7670296 : && preferable (src_folded_cost, src_folded_regcost,
5216 : : src_cost, src_regcost) <= 0
5217 : 5765432 : && preferable (src_folded_cost, src_folded_regcost,
5218 : : src_eqv_cost, src_eqv_regcost) <= 0
5219 : 4949334 : && preferable (src_folded_cost, src_folded_regcost,
5220 : : src_related_cost, src_related_regcost) <= 0
5221 : 190805636 : && preferable (src_folded_cost, src_folded_regcost,
5222 : : src_elt_cost, src_elt_regcost) <= 0)
5223 : : trial = src_folded, src_folded_cost = MAX_COST;
5224 : 181220582 : else if (src
5225 : 149472228 : && preferable (src_cost, src_regcost,
5226 : : src_eqv_cost, src_eqv_regcost) <= 0
5227 : 147981167 : && preferable (src_cost, src_regcost,
5228 : : src_related_cost, src_related_regcost) <= 0
5229 : 329165933 : && preferable (src_cost, src_regcost,
5230 : : src_elt_cost, src_elt_regcost) <= 0)
5231 : : trial = src, src_cost = MAX_COST;
5232 : 33356946 : else if (src_eqv_here
5233 : 1685914 : && preferable (src_eqv_cost, src_eqv_regcost,
5234 : : src_related_cost, src_related_regcost) <= 0
5235 : 35040964 : && preferable (src_eqv_cost, src_eqv_regcost,
5236 : : src_elt_cost, src_elt_regcost) <= 0)
5237 : : trial = src_eqv_here, src_eqv_cost = MAX_COST;
5238 : 31869348 : else if (src_related
5239 : 31869348 : && preferable (src_related_cost, src_related_regcost,
5240 : : src_elt_cost, src_elt_regcost) <= 0)
5241 : : trial = src_related, src_related_cost = MAX_COST;
5242 : : else
5243 : : {
5244 : 31601216 : trial = elt->exp;
5245 : 31601216 : elt = elt->next_same_value;
5246 : 31601216 : src_elt_cost = MAX_COST;
5247 : : }
5248 : :
5249 : : /* Try to optimize
5250 : : (set (reg:M N) (const_int A))
5251 : : (set (reg:M2 O) (const_int B))
5252 : : (set (zero_extract:M2 (reg:M N) (const_int C) (const_int D))
5253 : : (reg:M2 O)). */
5254 : 185869837 : if (GET_CODE (SET_DEST (sets[i].rtl)) == ZERO_EXTRACT
5255 : 5458 : && CONST_INT_P (trial)
5256 : 850 : && CONST_INT_P (XEXP (SET_DEST (sets[i].rtl), 1))
5257 : 850 : && CONST_INT_P (XEXP (SET_DEST (sets[i].rtl), 2))
5258 : 699 : && REG_P (XEXP (SET_DEST (sets[i].rtl), 0))
5259 : 150 : && (known_ge
5260 : : (GET_MODE_PRECISION (GET_MODE (SET_DEST (sets[i].rtl))),
5261 : : INTVAL (XEXP (SET_DEST (sets[i].rtl), 1))))
5262 : 185869837 : && ((unsigned) INTVAL (XEXP (SET_DEST (sets[i].rtl), 1))
5263 : 150 : + (unsigned) INTVAL (XEXP (SET_DEST (sets[i].rtl), 2))
5264 : : <= HOST_BITS_PER_WIDE_INT))
5265 : : {
5266 : 150 : rtx dest_reg = XEXP (SET_DEST (sets[i].rtl), 0);
5267 : 150 : rtx width = XEXP (SET_DEST (sets[i].rtl), 1);
5268 : 150 : rtx pos = XEXP (SET_DEST (sets[i].rtl), 2);
5269 : 150 : unsigned int dest_hash = HASH (dest_reg, GET_MODE (dest_reg));
5270 : 150 : struct table_elt *dest_elt
5271 : 150 : = lookup (dest_reg, dest_hash, GET_MODE (dest_reg));
5272 : 150 : rtx dest_cst = NULL;
5273 : :
5274 : 150 : if (dest_elt)
5275 : 332 : for (p = dest_elt->first_same_value; p; p = p->next_same_value)
5276 : 238 : if (p->is_const && CONST_INT_P (p->exp))
5277 : : {
5278 : : dest_cst = p->exp;
5279 : : break;
5280 : : }
5281 : 94 : if (dest_cst)
5282 : : {
5283 : 0 : HOST_WIDE_INT val = INTVAL (dest_cst);
5284 : 0 : HOST_WIDE_INT mask;
5285 : 0 : unsigned int shift;
5286 : : /* This is the mode of DEST_CST as well. */
5287 : 0 : scalar_int_mode dest_mode
5288 : 0 : = as_a <scalar_int_mode> (GET_MODE (dest_reg));
5289 : 0 : if (BITS_BIG_ENDIAN)
5290 : : shift = GET_MODE_PRECISION (dest_mode)
5291 : : - INTVAL (pos) - INTVAL (width);
5292 : : else
5293 : 0 : shift = INTVAL (pos);
5294 : 0 : if (INTVAL (width) == HOST_BITS_PER_WIDE_INT)
5295 : : mask = HOST_WIDE_INT_M1;
5296 : : else
5297 : 0 : mask = (HOST_WIDE_INT_1 << INTVAL (width)) - 1;
5298 : 0 : val &= ~(mask << shift);
5299 : 0 : val |= (INTVAL (trial) & mask) << shift;
5300 : 0 : val = trunc_int_for_mode (val, dest_mode);
5301 : 0 : validate_unshare_change (insn, &SET_DEST (sets[i].rtl),
5302 : : dest_reg, 1);
5303 : 0 : validate_unshare_change (insn, &SET_SRC (sets[i].rtl),
5304 : : GEN_INT (val), 1);
5305 : 0 : if (apply_change_group ())
5306 : : {
5307 : 0 : rtx note = find_reg_note (insn, REG_EQUAL, NULL_RTX);
5308 : 0 : if (note)
5309 : : {
5310 : 0 : remove_note (insn, note);
5311 : 0 : df_notes_rescan (insn);
5312 : : }
5313 : 0 : src_eqv = NULL_RTX;
5314 : 0 : src_eqv_elt = NULL;
5315 : 0 : src_eqv_volatile = 0;
5316 : 0 : src_eqv_in_memory = 0;
5317 : 0 : src_eqv_hash = 0;
5318 : 0 : repeat = true;
5319 : 0 : break;
5320 : : }
5321 : : }
5322 : : }
5323 : :
5324 : : /* We don't normally have an insn matching (set (pc) (pc)), so
5325 : : check for this separately here. We will delete such an
5326 : : insn below.
5327 : :
5328 : : For other cases such as a table jump or conditional jump
5329 : : where we know the ultimate target, go ahead and replace the
5330 : : operand. While that may not make a valid insn, we will
5331 : : reemit the jump below (and also insert any necessary
5332 : : barriers). */
5333 : 183230831 : if (n_sets == 1 && dest == pc_rtx
5334 : 204353490 : && (trial == pc_rtx
5335 : 18471810 : || (GET_CODE (trial) == LABEL_REF
5336 : 11424 : && ! condjump_p (insn))))
5337 : : {
5338 : : /* Don't substitute non-local labels, this confuses CFG. */
5339 : 14460 : if (GET_CODE (trial) == LABEL_REF
5340 : 13152 : && LABEL_REF_NONLOCAL_P (trial))
5341 : 1308 : continue;
5342 : :
5343 : 11844 : SET_SRC (sets[i].rtl) = trial;
5344 : 11844 : cse_jumps_altered = true;
5345 : 11844 : break;
5346 : : }
5347 : :
5348 : : /* Similarly, lots of targets don't allow no-op
5349 : : (set (mem x) (mem x)) moves. Even (set (reg x) (reg x))
5350 : : might be impossible for certain registers (like CC registers). */
5351 : 185856685 : else if (n_sets == 1
5352 : 183217679 : && !CALL_P (insn)
5353 : 182731090 : && (MEM_P (trial) || REG_P (trial))
5354 : 74371262 : && rtx_equal_p (trial, dest)
5355 : 231901 : && !side_effects_p (dest)
5356 : 231901 : && (cfun->can_delete_dead_exceptions
5357 : 71860 : || insn_nothrow_p (insn))
5358 : : /* We can only remove the later store if the earlier aliases
5359 : : at least all accesses the later one. */
5360 : 186070112 : && (!MEM_P (trial)
5361 : 20611 : || ((MEM_ALIAS_SET (dest) == MEM_ALIAS_SET (trial)
5362 : 5638 : || alias_set_subset_of (MEM_ALIAS_SET (dest),
5363 : 5638 : MEM_ALIAS_SET (trial)))
5364 : 15223 : && (!MEM_EXPR (trial)
5365 : 14738 : || refs_same_for_tbaa_p (MEM_EXPR (trial),
5366 : 14738 : MEM_EXPR (dest))))))
5367 : : {
5368 : 206841 : SET_SRC (sets[i].rtl) = trial;
5369 : 206841 : noop_insn = true;
5370 : 206841 : break;
5371 : : }
5372 : :
5373 : : /* Reject certain invalid forms of CONST that we create. */
5374 : 185649844 : else if (CONSTANT_P (trial)
5375 : 30511053 : && GET_CODE (trial) == CONST
5376 : : /* Reject cases that will cause decode_rtx_const to
5377 : : die. On the alpha when simplifying a switch, we
5378 : : get (const (truncate (minus (label_ref)
5379 : : (label_ref)))). */
5380 : 525574 : && (GET_CODE (XEXP (trial, 0)) == TRUNCATE
5381 : : /* Likewise on IA-64, except without the
5382 : : truncate. */
5383 : 525574 : || (GET_CODE (XEXP (trial, 0)) == MINUS
5384 : 0 : && GET_CODE (XEXP (XEXP (trial, 0), 0)) == LABEL_REF
5385 : 0 : && GET_CODE (XEXP (XEXP (trial, 0), 1)) == LABEL_REF)))
5386 : : /* Do nothing for this case. */
5387 : : ;
5388 : :
5389 : : /* Do not replace anything with a MEM, except the replacement
5390 : : is a no-op. This allows this loop to terminate. */
5391 : 185649844 : else if (MEM_P (trial) && !rtx_equal_p (trial, SET_SRC(sets[i].rtl)))
5392 : : /* Do nothing for this case. */
5393 : : ;
5394 : :
5395 : : /* Look for a substitution that makes a valid insn. */
5396 : 185560023 : else if (validate_unshare_change (insn, &SET_SRC (sets[i].rtl),
5397 : : trial, 0))
5398 : : {
5399 : 180727598 : rtx new_rtx = canon_reg (SET_SRC (sets[i].rtl), insn);
5400 : :
5401 : : /* The result of apply_change_group can be ignored; see
5402 : : canon_reg. */
5403 : :
5404 : 180727598 : validate_change (insn, &SET_SRC (sets[i].rtl), new_rtx, 1);
5405 : 180727598 : apply_change_group ();
5406 : :
5407 : 180727598 : break;
5408 : : }
5409 : :
5410 : : /* If the current function uses a constant pool and this is a
5411 : : constant, try making a pool entry. Put it in src_folded
5412 : : unless we already have done this since that is where it
5413 : : likely came from. */
5414 : :
5415 : 4832425 : else if (crtl->uses_const_pool
5416 : 3543171 : && CONSTANT_P (trial)
5417 : 2494095 : && !CONST_INT_P (trial)
5418 : 2475792 : && (src_folded == 0 || !MEM_P (src_folded))
5419 : 1670774 : && GET_MODE_CLASS (mode) != MODE_CC
5420 : 1670774 : && mode != VOIDmode)
5421 : : {
5422 : 1670774 : src_folded = force_const_mem (mode, trial);
5423 : 1670774 : if (src_folded)
5424 : : {
5425 : 1670153 : src_folded_cost = COST (src_folded, mode);
5426 : 1670153 : src_folded_regcost = approx_reg_cost (src_folded);
5427 : : }
5428 : : }
5429 : : }
5430 : :
5431 : : /* If we changed the insn too much, handle this set from scratch. */
5432 : 180946283 : if (repeat)
5433 : : {
5434 : 0 : i--;
5435 : 0 : continue;
5436 : : }
5437 : :
5438 : 181475920 : src = SET_SRC (sets[i].rtl);
5439 : :
5440 : : /* In general, it is good to have a SET with SET_SRC == SET_DEST.
5441 : : However, there is an important exception: If both are registers
5442 : : that are not the head of their equivalence class, replace SET_SRC
5443 : : with the head of the class. If we do not do this, we will have
5444 : : both registers live over a portion of the basic block. This way,
5445 : : their lifetimes will likely abut instead of overlapping. */
5446 : 181475920 : if (!is_fake_set
5447 : 180946283 : && REG_P (dest)
5448 : 316874296 : && REGNO_QTY_VALID_P (REGNO (dest)))
5449 : : {
5450 : 7643560 : int dest_q = REG_QTY (REGNO (dest));
5451 : 7643560 : struct qty_table_elem *dest_ent = &qty_table[dest_q];
5452 : :
5453 : 7643560 : if (dest_ent->mode == GET_MODE (dest)
5454 : 5908969 : && dest_ent->first_reg != REGNO (dest)
5455 : 108698 : && REG_P (src) && REGNO (src) == REGNO (dest)
5456 : : /* Don't do this if the original insn had a hard reg as
5457 : : SET_SRC or SET_DEST. */
5458 : 4903 : && (!REG_P (sets[i].src)
5459 : 3325 : || REGNO (sets[i].src) >= FIRST_PSEUDO_REGISTER)
5460 : 7648443 : && (!REG_P (dest) || REGNO (dest) >= FIRST_PSEUDO_REGISTER))
5461 : : /* We can't call canon_reg here because it won't do anything if
5462 : : SRC is a hard register. */
5463 : : {
5464 : 4883 : int src_q = REG_QTY (REGNO (src));
5465 : 4883 : struct qty_table_elem *src_ent = &qty_table[src_q];
5466 : 4883 : int first = src_ent->first_reg;
5467 : 4883 : rtx new_src
5468 : : = (first >= FIRST_PSEUDO_REGISTER
5469 : 4883 : ? regno_reg_rtx[first] : gen_rtx_REG (GET_MODE (src), first));
5470 : :
5471 : : /* We must use validate-change even for this, because this
5472 : : might be a special no-op instruction, suitable only to
5473 : : tag notes onto. */
5474 : 4883 : if (validate_change (insn, &SET_SRC (sets[i].rtl), new_src, 0))
5475 : : {
5476 : 4883 : src = new_src;
5477 : : /* If we had a constant that is cheaper than what we are now
5478 : : setting SRC to, use that constant. We ignored it when we
5479 : : thought we could make this into a no-op. */
5480 : 2158 : if (src_const && COST (src_const, mode) < COST (src, mode)
5481 : 4883 : && validate_change (insn, &SET_SRC (sets[i].rtl),
5482 : : src_const, 0))
5483 : : src = src_const;
5484 : : }
5485 : : }
5486 : : }
5487 : :
5488 : : /* If we made a change, recompute SRC values. */
5489 : 181475920 : if (src != sets[i].src)
5490 : : {
5491 : 3032309 : do_not_record = 0;
5492 : 3032309 : hash_arg_in_memory = 0;
5493 : 3032309 : sets[i].src = src;
5494 : 3032309 : sets[i].src_hash = HASH (src, mode);
5495 : 3032309 : sets[i].src_volatile = do_not_record;
5496 : 3032309 : sets[i].src_in_memory = hash_arg_in_memory;
5497 : 3032309 : sets[i].src_elt = lookup (src, sets[i].src_hash, mode);
5498 : : }
5499 : :
5500 : : /* If this is a single SET, we are setting a register, and we have an
5501 : : equivalent constant, we want to add a REG_EQUAL note if the constant
5502 : : is different from the source. We don't want to do it for a constant
5503 : : pseudo since verifying that this pseudo hasn't been eliminated is a
5504 : : pain; moreover such a note won't help anything.
5505 : :
5506 : : Avoid a REG_EQUAL note for (CONST (MINUS (LABEL_REF) (LABEL_REF)))
5507 : : which can be created for a reference to a compile time computable
5508 : : entry in a jump table. */
5509 : 181475920 : if (n_sets == 1
5510 : 178783667 : && REG_P (dest)
5511 : 133573841 : && src_const
5512 : 27488315 : && !REG_P (src_const)
5513 : 27463093 : && !(GET_CODE (src_const) == SUBREG
5514 : 0 : && REG_P (SUBREG_REG (src_const)))
5515 : 27463093 : && !(GET_CODE (src_const) == CONST
5516 : 366537 : && GET_CODE (XEXP (src_const, 0)) == MINUS
5517 : 0 : && GET_CODE (XEXP (XEXP (src_const, 0), 0)) == LABEL_REF
5518 : 0 : && GET_CODE (XEXP (XEXP (src_const, 0), 1)) == LABEL_REF)
5519 : 208939013 : && !rtx_equal_p (src, src_const))
5520 : : {
5521 : : /* Make sure that the rtx is not shared. */
5522 : 7001485 : src_const = copy_rtx (src_const);
5523 : :
5524 : : /* Record the actual constant value in a REG_EQUAL note,
5525 : : making a new one if one does not already exist. */
5526 : 7001485 : set_unique_reg_note (insn, REG_EQUAL, src_const);
5527 : 7001485 : df_notes_rescan (insn);
5528 : : }
5529 : :
5530 : : /* Now deal with the destination. */
5531 : 181475920 : do_not_record = 0;
5532 : :
5533 : : /* Look within any ZERO_EXTRACT to the MEM or REG within it. */
5534 : 181475920 : while (GET_CODE (dest) == SUBREG
5535 : 181496735 : || GET_CODE (dest) == ZERO_EXTRACT
5536 : 364425296 : || GET_CODE (dest) == STRICT_LOW_PART)
5537 : 1458099 : dest = XEXP (dest, 0);
5538 : :
5539 : 181475920 : sets[i].inner_dest = dest;
5540 : :
5541 : 181475920 : if (MEM_P (dest))
5542 : : {
5543 : : #ifdef PUSH_ROUNDING
5544 : : /* Stack pushes invalidate the stack pointer. */
5545 : 26162509 : rtx addr = XEXP (dest, 0);
5546 : 26162509 : if (GET_RTX_CLASS (GET_CODE (addr)) == RTX_AUTOINC
5547 : 5433095 : && XEXP (addr, 0) == stack_pointer_rtx)
5548 : 5433095 : invalidate (stack_pointer_rtx, VOIDmode);
5549 : : #endif
5550 : 26162509 : dest = fold_rtx (dest, insn);
5551 : : }
5552 : :
5553 : : /* Compute the hash code of the destination now,
5554 : : before the effects of this instruction are recorded,
5555 : : since the register values used in the address computation
5556 : : are those before this instruction. */
5557 : 181475920 : sets[i].dest_hash = HASH (dest, mode);
5558 : :
5559 : : /* Don't enter a bit-field in the hash table
5560 : : because the value in it after the store
5561 : : may not equal what was stored, due to truncation. */
5562 : :
5563 : 181475920 : if (GET_CODE (SET_DEST (sets[i].rtl)) == ZERO_EXTRACT)
5564 : : {
5565 : 5458 : rtx width = XEXP (SET_DEST (sets[i].rtl), 1);
5566 : :
5567 : 5458 : if (src_const != 0 && CONST_INT_P (src_const)
5568 : 850 : && CONST_INT_P (width)
5569 : 850 : && INTVAL (width) < HOST_BITS_PER_WIDE_INT
5570 : 850 : && ! (INTVAL (src_const)
5571 : 850 : & (HOST_WIDE_INT_M1U << INTVAL (width))))
5572 : : /* Exception: if the value is constant,
5573 : : and it won't be truncated, record it. */
5574 : : ;
5575 : : else
5576 : : {
5577 : : /* This is chosen so that the destination will be invalidated
5578 : : but no new value will be recorded.
5579 : : We must invalidate because sometimes constant
5580 : : values can be recorded for bitfields. */
5581 : 4609 : sets[i].src_elt = 0;
5582 : 4609 : sets[i].src_volatile = 1;
5583 : 4609 : src_eqv = 0;
5584 : 4609 : src_eqv_elt = 0;
5585 : : }
5586 : : }
5587 : :
5588 : : /* If only one set in a JUMP_INSN and it is now a no-op, we can delete
5589 : : the insn. */
5590 : 181470462 : else if (n_sets == 1 && dest == pc_rtx && src == pc_rtx)
5591 : : {
5592 : : /* One less use of the label this insn used to jump to. */
5593 : 11843 : cse_cfg_altered |= delete_insn_and_edges (insn);
5594 : 11843 : cse_jumps_altered = true;
5595 : : /* No more processing for this set. */
5596 : 11843 : sets[i].rtl = 0;
5597 : : }
5598 : :
5599 : : /* Similarly for no-op moves. */
5600 : 181458619 : else if (noop_insn)
5601 : : {
5602 : 206841 : if (cfun->can_throw_non_call_exceptions && can_throw_internal (insn))
5603 : 0 : cse_cfg_altered = true;
5604 : 206841 : cse_cfg_altered |= delete_insn_and_edges (insn);
5605 : : /* No more processing for this set. */
5606 : 206841 : sets[i].rtl = 0;
5607 : : }
5608 : :
5609 : : /* If this SET is now setting PC to a label, we know it used to
5610 : : be a conditional or computed branch. */
5611 : 18463752 : else if (dest == pc_rtx && GET_CODE (src) == LABEL_REF
5612 : 181261894 : && !LABEL_REF_NONLOCAL_P (src))
5613 : : {
5614 : : /* We reemit the jump in as many cases as possible just in
5615 : : case the form of an unconditional jump is significantly
5616 : : different than a computed jump or conditional jump.
5617 : :
5618 : : If this insn has multiple sets, then reemitting the
5619 : : jump is nontrivial. So instead we just force rerecognition
5620 : : and hope for the best. */
5621 : 10116 : if (n_sets == 1)
5622 : : {
5623 : 10116 : rtx_jump_insn *new_rtx;
5624 : 10116 : rtx note;
5625 : :
5626 : 10116 : rtx_insn *seq = targetm.gen_jump (XEXP (src, 0));
5627 : 10116 : new_rtx = emit_jump_insn_before (seq, insn);
5628 : 10116 : JUMP_LABEL (new_rtx) = XEXP (src, 0);
5629 : 10116 : LABEL_NUSES (XEXP (src, 0))++;
5630 : :
5631 : : /* Make sure to copy over REG_NON_LOCAL_GOTO. */
5632 : 10116 : note = find_reg_note (insn, REG_NON_LOCAL_GOTO, 0);
5633 : 10116 : if (note)
5634 : : {
5635 : 0 : XEXP (note, 1) = NULL_RTX;
5636 : 0 : REG_NOTES (new_rtx) = note;
5637 : : }
5638 : :
5639 : 10116 : cse_cfg_altered |= delete_insn_and_edges (insn);
5640 : 10116 : insn = new_rtx;
5641 : : }
5642 : : else
5643 : 0 : INSN_CODE (insn) = -1;
5644 : :
5645 : : /* Do not bother deleting any unreachable code, let jump do it. */
5646 : 10116 : cse_jumps_altered = true;
5647 : 10116 : sets[i].rtl = 0;
5648 : : }
5649 : :
5650 : : /* If destination is volatile, invalidate it and then do no further
5651 : : processing for this assignment. */
5652 : :
5653 : 181241662 : else if (do_not_record)
5654 : : {
5655 : 52004118 : invalidate_dest (dest);
5656 : 52004118 : sets[i].rtl = 0;
5657 : : }
5658 : :
5659 : 181475920 : if (sets[i].rtl != 0 && dest != SET_DEST (sets[i].rtl))
5660 : : {
5661 : 1511875 : do_not_record = 0;
5662 : 1511875 : sets[i].dest_hash = HASH (SET_DEST (sets[i].rtl), mode);
5663 : 1511875 : if (do_not_record)
5664 : : {
5665 : 979 : invalidate_dest (SET_DEST (sets[i].rtl));
5666 : 979 : sets[i].rtl = 0;
5667 : : }
5668 : : }
5669 : : }
5670 : :
5671 : : /* Now enter all non-volatile source expressions in the hash table
5672 : : if they are not already present.
5673 : : Record their equivalence classes in src_elt.
5674 : : This way we can insert the corresponding destinations into
5675 : : the same classes even if the actual sources are no longer in them
5676 : : (having been invalidated). */
5677 : :
5678 : 4957737 : if (src_eqv && src_eqv_elt == 0 && sets[0].rtl != 0 && ! src_eqv_volatile
5679 : 347811116 : && ! rtx_equal_p (src_eqv, SET_DEST (sets[0].rtl)))
5680 : : {
5681 : 4118724 : struct table_elt *elt;
5682 : 4118724 : struct table_elt *classp = sets[0].src_elt;
5683 : 4118724 : rtx dest = SET_DEST (sets[0].rtl);
5684 : 4118724 : machine_mode eqvmode = GET_MODE (dest);
5685 : :
5686 : 4118724 : if (GET_CODE (dest) == STRICT_LOW_PART)
5687 : : {
5688 : 0 : eqvmode = GET_MODE (SUBREG_REG (XEXP (dest, 0)));
5689 : 0 : classp = 0;
5690 : : }
5691 : 4118724 : if (insert_regs (src_eqv, classp, false))
5692 : : {
5693 : 145204 : rehash_using_reg (src_eqv);
5694 : 145204 : src_eqv_hash = HASH (src_eqv, eqvmode);
5695 : : }
5696 : 4118724 : elt = insert (src_eqv, classp, src_eqv_hash, eqvmode);
5697 : 4118724 : elt->in_memory = src_eqv_in_memory;
5698 : 4118724 : src_eqv_elt = elt;
5699 : :
5700 : : /* Check to see if src_eqv_elt is the same as a set source which
5701 : : does not yet have an elt, and if so set the elt of the set source
5702 : : to src_eqv_elt. */
5703 : 8237448 : for (i = 0; i < n_sets; i++)
5704 : 8237448 : if (sets[i].rtl && sets[i].src_elt == 0
5705 : 8110460 : && rtx_equal_p (SET_SRC (sets[i].rtl), src_eqv))
5706 : 98301 : sets[i].src_elt = src_eqv_elt;
5707 : : }
5708 : :
5709 : 525168312 : for (i = 0; i < n_sets; i++)
5710 : 310717943 : if (sets[i].rtl && ! sets[i].src_volatile
5711 : 297409677 : && ! rtx_equal_p (SET_SRC (sets[i].rtl), SET_DEST (sets[i].rtl)))
5712 : : {
5713 : 115928743 : if (GET_CODE (SET_DEST (sets[i].rtl)) == STRICT_LOW_PART)
5714 : : {
5715 : : /* REG_EQUAL in setting a STRICT_LOW_PART
5716 : : gives an equivalent for the entire destination register,
5717 : : not just for the subreg being stored in now.
5718 : : This is a more interesting equivalence, so we arrange later
5719 : : to treat the entire reg as the destination. */
5720 : 15357 : sets[i].src_elt = src_eqv_elt;
5721 : 15357 : sets[i].src_hash = src_eqv_hash;
5722 : : }
5723 : : else
5724 : : {
5725 : : /* Insert source and constant equivalent into hash table, if not
5726 : : already present. */
5727 : 115913386 : struct table_elt *classp = src_eqv_elt;
5728 : 115913386 : rtx src = sets[i].src;
5729 : 115913386 : rtx dest = SET_DEST (sets[i].rtl);
5730 : 231826772 : machine_mode mode
5731 : 115913386 : = GET_MODE (src) == VOIDmode ? GET_MODE (dest) : GET_MODE (src);
5732 : :
5733 : : /* It's possible that we have a source value known to be
5734 : : constant but don't have a REG_EQUAL note on the insn.
5735 : : Lack of a note will mean src_eqv_elt will be NULL. This
5736 : : can happen where we've generated a SUBREG to access a
5737 : : CONST_INT that is already in a register in a wider mode.
5738 : : Ensure that the source expression is put in the proper
5739 : : constant class. */
5740 : 115913386 : if (!classp)
5741 : 110950163 : classp = sets[i].src_const_elt;
5742 : :
5743 : 115913386 : if (sets[i].src_elt == 0)
5744 : : {
5745 : 96032923 : struct table_elt *elt;
5746 : :
5747 : : /* Note that these insert_regs calls cannot remove
5748 : : any of the src_elt's, because they would have failed to
5749 : : match if not still valid. */
5750 : 96032923 : if (insert_regs (src, classp, false))
5751 : : {
5752 : 15864837 : rehash_using_reg (src);
5753 : 15864837 : sets[i].src_hash = HASH (src, mode);
5754 : : }
5755 : 96032923 : elt = insert (src, classp, sets[i].src_hash, mode);
5756 : 96032923 : elt->in_memory = sets[i].src_in_memory;
5757 : : /* If inline asm has any clobbers, ensure we only reuse
5758 : : existing inline asms and never try to put the ASM_OPERANDS
5759 : : into an insn that isn't inline asm. */
5760 : 96032923 : if (GET_CODE (src) == ASM_OPERANDS
5761 : 20293 : && GET_CODE (x) == PARALLEL)
5762 : 20275 : elt->cost = MAX_COST;
5763 : 96032923 : sets[i].src_elt = classp = elt;
5764 : : }
5765 : 138417749 : if (sets[i].src_const && sets[i].src_const_elt == 0
5766 : 13588347 : && src != sets[i].src_const
5767 : 118010972 : && ! rtx_equal_p (sets[i].src_const, src))
5768 : 2097584 : sets[i].src_elt = insert (sets[i].src_const, classp,
5769 : 2097584 : sets[i].src_const_hash, mode);
5770 : : }
5771 : : }
5772 : 65547177 : else if (sets[i].src_elt == 0)
5773 : : /* If we did not insert the source into the hash table (e.g., it was
5774 : : volatile), note the equivalence class for the REG_EQUAL value, if any,
5775 : : so that the destination goes into that class. */
5776 : 54023306 : sets[i].src_elt = src_eqv_elt;
5777 : :
5778 : : /* Record destination addresses in the hash table. This allows us to
5779 : : check if they are invalidated by other sets. */
5780 : 525168312 : for (i = 0; i < n_sets; i++)
5781 : : {
5782 : 181475920 : if (sets[i].rtl)
5783 : : {
5784 : 129242023 : rtx x = sets[i].inner_dest;
5785 : 129242023 : struct table_elt *elt;
5786 : 129242023 : machine_mode mode;
5787 : 129242023 : unsigned hash;
5788 : :
5789 : 129242023 : if (MEM_P (x))
5790 : : {
5791 : 19602880 : x = XEXP (x, 0);
5792 : 19602880 : mode = GET_MODE (x);
5793 : 19602880 : hash = HASH (x, mode);
5794 : 19602880 : elt = lookup (x, hash, mode);
5795 : 19602880 : if (!elt)
5796 : : {
5797 : 17124925 : if (insert_regs (x, NULL, false))
5798 : : {
5799 : 1963727 : rtx dest = SET_DEST (sets[i].rtl);
5800 : :
5801 : 1963727 : rehash_using_reg (x);
5802 : 1963727 : hash = HASH (x, mode);
5803 : 1963727 : sets[i].dest_hash = HASH (dest, GET_MODE (dest));
5804 : : }
5805 : 17124925 : elt = insert (x, NULL, hash, mode);
5806 : : }
5807 : :
5808 : 19602880 : sets[i].dest_addr_elt = elt;
5809 : : }
5810 : : else
5811 : 109639143 : sets[i].dest_addr_elt = NULL;
5812 : : }
5813 : : }
5814 : :
5815 : 343692392 : invalidate_from_clobbers (insn);
5816 : :
5817 : : /* Some registers are invalidated by subroutine calls. Memory is
5818 : : invalidated by non-constant calls. */
5819 : :
5820 : 343692392 : if (CALL_P (insn))
5821 : : {
5822 : 14773328 : if (!(RTL_CONST_OR_PURE_CALL_P (insn)))
5823 : 12520074 : invalidate_memory ();
5824 : : else
5825 : : /* For const/pure calls, invalidate any argument slots, because
5826 : : those are owned by the callee. */
5827 : 6586269 : for (tem = CALL_INSN_FUNCTION_USAGE (insn); tem; tem = XEXP (tem, 1))
5828 : 4333015 : if (GET_CODE (XEXP (tem, 0)) == USE
5829 : 4332877 : && MEM_P (XEXP (XEXP (tem, 0), 0)))
5830 : 16631 : invalidate (XEXP (XEXP (tem, 0), 0), VOIDmode);
5831 : 14773328 : invalidate_for_call (insn);
5832 : : }
5833 : :
5834 : : /* Now invalidate everything set by this instruction.
5835 : : If a SUBREG or other funny destination is being set,
5836 : : sets[i].rtl is still nonzero, so here we invalidate the reg
5837 : : a part of which is being set. */
5838 : :
5839 : 525168312 : for (i = 0; i < n_sets; i++)
5840 : 181475920 : if (sets[i].rtl)
5841 : : {
5842 : : /* We can't use the inner dest, because the mode associated with
5843 : : a ZERO_EXTRACT is significant. */
5844 : 129242023 : rtx dest = SET_DEST (sets[i].rtl);
5845 : :
5846 : : /* Needed for registers to remove the register from its
5847 : : previous quantity's chain.
5848 : : Needed for memory if this is a nonvarying address, unless
5849 : : we have just done an invalidate_memory that covers even those. */
5850 : 129242023 : if (REG_P (dest) || GET_CODE (dest) == SUBREG)
5851 : 109619166 : invalidate (dest, VOIDmode);
5852 : 19622857 : else if (MEM_P (dest))
5853 : 19602880 : invalidate (dest, VOIDmode);
5854 : 19977 : else if (GET_CODE (dest) == STRICT_LOW_PART
5855 : 4620 : || GET_CODE (dest) == ZERO_EXTRACT)
5856 : 19855 : invalidate (XEXP (dest, 0), GET_MODE (dest));
5857 : : }
5858 : :
5859 : : /* Don't cse over a call to setjmp; on some machines (eg VAX)
5860 : : the regs restored by the longjmp come from a later time
5861 : : than the setjmp. */
5862 : 343692392 : if (CALL_P (insn) && find_reg_note (insn, REG_SETJMP, NULL))
5863 : : {
5864 : 2034 : flush_hash_table ();
5865 : 2034 : goto done;
5866 : : }
5867 : :
5868 : : /* Make sure registers mentioned in destinations
5869 : : are safe for use in an expression to be inserted.
5870 : : This removes from the hash table
5871 : : any invalid entry that refers to one of these registers.
5872 : :
5873 : : We don't care about the return value from mention_regs because
5874 : : we are going to hash the SET_DEST values unconditionally. */
5875 : :
5876 : 525166278 : for (i = 0; i < n_sets; i++)
5877 : : {
5878 : 181475920 : if (sets[i].rtl)
5879 : : {
5880 : 129242023 : rtx x = SET_DEST (sets[i].rtl);
5881 : :
5882 : 129242023 : if (!REG_P (x))
5883 : 21041718 : mention_regs (x);
5884 : : else
5885 : : {
5886 : : /* We used to rely on all references to a register becoming
5887 : : inaccessible when a register changes to a new quantity,
5888 : : since that changes the hash code. However, that is not
5889 : : safe, since after HASH_SIZE new quantities we get a
5890 : : hash 'collision' of a register with its own invalid
5891 : : entries. And since SUBREGs have been changed not to
5892 : : change their hash code with the hash code of the register,
5893 : : it wouldn't work any longer at all. So we have to check
5894 : : for any invalid references lying around now.
5895 : : This code is similar to the REG case in mention_regs,
5896 : : but it knows that reg_tick has been incremented, and
5897 : : it leaves reg_in_table as -1 . */
5898 : 108200305 : unsigned int regno = REGNO (x);
5899 : 108200305 : unsigned int endregno = END_REGNO (x);
5900 : 108200305 : unsigned int i;
5901 : :
5902 : 216400610 : for (i = regno; i < endregno; i++)
5903 : : {
5904 : 108200305 : if (REG_IN_TABLE (i) >= 0)
5905 : : {
5906 : 12362735 : remove_invalid_refs (i);
5907 : 12362735 : REG_IN_TABLE (i) = -1;
5908 : : }
5909 : : }
5910 : : }
5911 : : }
5912 : : }
5913 : :
5914 : : /* We may have just removed some of the src_elt's from the hash table.
5915 : : So replace each one with the current head of the same class.
5916 : : Also check if destination addresses have been removed. */
5917 : :
5918 : 525166278 : for (i = 0; i < n_sets; i++)
5919 : 181475920 : if (sets[i].rtl)
5920 : : {
5921 : 129242023 : if (sets[i].dest_addr_elt
5922 : 129242023 : && sets[i].dest_addr_elt->first_same_value == 0)
5923 : : {
5924 : : /* The elt was removed, which means this destination is not
5925 : : valid after this instruction. */
5926 : 9 : sets[i].rtl = NULL_RTX;
5927 : : }
5928 : 129242014 : else if (sets[i].src_elt && sets[i].src_elt->first_same_value == 0)
5929 : : /* If elt was removed, find current head of same class,
5930 : : or 0 if nothing remains of that class. */
5931 : : {
5932 : 10410524 : struct table_elt *elt = sets[i].src_elt;
5933 : :
5934 : 10410524 : while (elt && elt->prev_same_value)
5935 : : elt = elt->prev_same_value;
5936 : :
5937 : 20720282 : while (elt && elt->first_same_value == 0)
5938 : 10353939 : elt = elt->next_same_value;
5939 : 10366343 : sets[i].src_elt = elt ? elt->first_same_value : 0;
5940 : : }
5941 : : }
5942 : :
5943 : : /* Now insert the destinations into their equivalence classes. */
5944 : :
5945 : 525166278 : for (i = 0; i < n_sets; i++)
5946 : 181475920 : if (sets[i].rtl)
5947 : : {
5948 : 129242014 : rtx dest = SET_DEST (sets[i].rtl);
5949 : 129242014 : struct table_elt *elt;
5950 : :
5951 : : /* Don't record value if we are not supposed to risk allocating
5952 : : floating-point values in registers that might be wider than
5953 : : memory. */
5954 : 152875994 : if ((flag_float_store
5955 : 12097 : && MEM_P (dest)
5956 : 4187 : && FLOAT_MODE_P (GET_MODE (dest)))
5957 : : /* Don't record BLKmode values, because we don't know the
5958 : : size of it, and can't be sure that other BLKmode values
5959 : : have the same or smaller size. */
5960 : 129239525 : || GET_MODE (dest) == BLKmode
5961 : : /* If we didn't put a REG_EQUAL value or a source into the hash
5962 : : table, there is no point is recording DEST. */
5963 : 258481539 : || sets[i].src_elt == 0)
5964 : 23633980 : continue;
5965 : :
5966 : : /* STRICT_LOW_PART isn't part of the value BEING set,
5967 : : and neither is the SUBREG inside it.
5968 : : Note that in this case SETS[I].SRC_ELT is really SRC_EQV_ELT. */
5969 : 105608034 : if (GET_CODE (dest) == STRICT_LOW_PART)
5970 : 0 : dest = SUBREG_REG (XEXP (dest, 0));
5971 : :
5972 : 105608034 : if (REG_P (dest) || GET_CODE (dest) == SUBREG)
5973 : : /* Registers must also be inserted into chains for quantities. */
5974 : 86324897 : if (insert_regs (dest, sets[i].src_elt, true))
5975 : : {
5976 : : /* If `insert_regs' changes something, the hash code must be
5977 : : recalculated. */
5978 : 85865747 : rehash_using_reg (dest);
5979 : 85865747 : sets[i].dest_hash = HASH (dest, GET_MODE (dest));
5980 : : }
5981 : :
5982 : : /* If DEST is a paradoxical SUBREG, don't record DEST since the bits
5983 : : outside the mode of GET_MODE (SUBREG_REG (dest)) are undefined. */
5984 : 105608034 : if (paradoxical_subreg_p (dest))
5985 : 62064 : continue;
5986 : :
5987 : 316637910 : elt = insert (dest, sets[i].src_elt,
5988 : 105545970 : sets[i].dest_hash, GET_MODE (dest));
5989 : :
5990 : : /* If this is a constant, insert the constant anchors with the
5991 : : equivalent register-offset expressions using register DEST. */
5992 : 105545970 : if (targetm.const_anchor
5993 : 0 : && REG_P (dest)
5994 : 0 : && SCALAR_INT_MODE_P (GET_MODE (dest))
5995 : 105545970 : && GET_CODE (sets[i].src_elt->exp) == CONST_INT)
5996 : 0 : insert_const_anchors (dest, sets[i].src_elt->exp, GET_MODE (dest));
5997 : :
5998 : 105545970 : elt->in_memory = (MEM_P (sets[i].inner_dest)
5999 : 105545970 : && !MEM_READONLY_P (sets[i].inner_dest));
6000 : :
6001 : : /* If we have (set (subreg:m1 (reg:m2 foo) 0) (bar:m1)), M1 is no
6002 : : narrower than M2, and both M1 and M2 are the same number of words,
6003 : : we are also doing (set (reg:m2 foo) (subreg:m2 (bar:m1) 0)) so
6004 : : make that equivalence as well.
6005 : :
6006 : : However, BAR may have equivalences for which gen_lowpart
6007 : : will produce a simpler value than gen_lowpart applied to
6008 : : BAR (e.g., if BAR was ZERO_EXTENDed from M2), so we will scan all
6009 : : BAR's equivalences. If we don't get a simplified form, make
6010 : : the SUBREG. It will not be used in an equivalence, but will
6011 : : cause two similar assignments to be detected.
6012 : :
6013 : : Note the loop below will find SUBREG_REG (DEST) since we have
6014 : : already entered SRC and DEST of the SET in the table. */
6015 : :
6016 : 105545970 : if (GET_CODE (dest) == SUBREG
6017 : : && (known_equal_after_align_down
6018 : 182879841 : (GET_MODE_SIZE (GET_MODE (SUBREG_REG (dest))) - 1,
6019 : 2660144 : GET_MODE_SIZE (GET_MODE (dest)) - 1,
6020 : 1330072 : UNITS_PER_WORD))
6021 : 73849 : && !partial_subreg_p (dest)
6022 : 105573976 : && sets[i].src_elt != 0)
6023 : : {
6024 : 28006 : machine_mode new_mode = GET_MODE (SUBREG_REG (dest));
6025 : 28006 : struct table_elt *elt, *classp = 0;
6026 : :
6027 : 105493 : for (elt = sets[i].src_elt->first_same_value; elt;
6028 : 77487 : elt = elt->next_same_value)
6029 : : {
6030 : 77487 : rtx new_src = 0;
6031 : 77487 : unsigned src_hash;
6032 : 77487 : struct table_elt *src_elt;
6033 : :
6034 : : /* Ignore invalid entries. */
6035 : 77487 : if (!REG_P (elt->exp)
6036 : 77487 : && ! exp_equiv_p (elt->exp, elt->exp, 1, false))
6037 : 0 : continue;
6038 : :
6039 : : /* We may have already been playing subreg games. If the
6040 : : mode is already correct for the destination, use it. */
6041 : 77487 : if (GET_MODE (elt->exp) == new_mode)
6042 : : new_src = elt->exp;
6043 : : else
6044 : : {
6045 : 77487 : poly_uint64 byte
6046 : 77487 : = subreg_lowpart_offset (new_mode, GET_MODE (dest));
6047 : 77487 : new_src = simplify_gen_subreg (new_mode, elt->exp,
6048 : 77487 : GET_MODE (dest), byte);
6049 : : }
6050 : :
6051 : : /* The call to simplify_gen_subreg fails if the value
6052 : : is VOIDmode, yet we can't do any simplification, e.g.
6053 : : for EXPR_LISTs denoting function call results.
6054 : : It is invalid to construct a SUBREG with a VOIDmode
6055 : : SUBREG_REG, hence a zero new_src means we can't do
6056 : : this substitution. */
6057 : 77487 : if (! new_src)
6058 : 6 : continue;
6059 : :
6060 : 77481 : src_hash = HASH (new_src, new_mode);
6061 : 77481 : src_elt = lookup (new_src, src_hash, new_mode);
6062 : :
6063 : : /* Put the new source in the hash table is if isn't
6064 : : already. */
6065 : 77481 : if (src_elt == 0)
6066 : : {
6067 : 32538 : if (insert_regs (new_src, classp, false))
6068 : : {
6069 : 0 : rehash_using_reg (new_src);
6070 : 0 : src_hash = HASH (new_src, new_mode);
6071 : : }
6072 : 32538 : src_elt = insert (new_src, classp, src_hash, new_mode);
6073 : 32538 : src_elt->in_memory = elt->in_memory;
6074 : 32538 : if (GET_CODE (new_src) == ASM_OPERANDS
6075 : 0 : && elt->cost == MAX_COST)
6076 : 0 : src_elt->cost = MAX_COST;
6077 : : }
6078 : 44943 : else if (classp && classp != src_elt->first_same_value)
6079 : : /* Show that two things that we've seen before are
6080 : : actually the same. */
6081 : 64 : merge_equiv_classes (src_elt, classp);
6082 : :
6083 : 77481 : classp = src_elt->first_same_value;
6084 : : /* Ignore invalid entries. */
6085 : 77481 : while (classp
6086 : 77481 : && !REG_P (classp->exp)
6087 : 125678 : && ! exp_equiv_p (classp->exp, classp->exp, 1, false))
6088 : 0 : classp = classp->next_same_value;
6089 : : }
6090 : : }
6091 : : }
6092 : :
6093 : : /* Special handling for (set REG0 REG1) where REG0 is the
6094 : : "cheapest", cheaper than REG1. After cse, REG1 will probably not
6095 : : be used in the sequel, so (if easily done) change this insn to
6096 : : (set REG1 REG0) and replace REG1 with REG0 in the previous insn
6097 : : that computed their value. Then REG1 will become a dead store
6098 : : and won't cloud the situation for later optimizations.
6099 : :
6100 : : Do not make this change if REG1 is a hard register, because it will
6101 : : then be used in the sequel and we may be changing a two-operand insn
6102 : : into a three-operand insn.
6103 : :
6104 : : Also do not do this if we are operating on a copy of INSN. */
6105 : :
6106 : 522474025 : if (n_sets == 1 && sets[0].rtl)
6107 : 126823980 : try_back_substitute_reg (sets[0].rtl, insn);
6108 : :
6109 : 343692392 : done:;
6110 : 343692392 : }
6111 : :
6112 : : /* Remove from the hash table all expressions that reference memory. */
6113 : :
6114 : : static void
6115 : 12520074 : invalidate_memory (void)
6116 : : {
6117 : 12520074 : int i;
6118 : 12520074 : struct table_elt *p, *next;
6119 : :
6120 : 413162442 : for (i = 0; i < HASH_SIZE; i++)
6121 : 577152413 : for (p = table[i]; p; p = next)
6122 : : {
6123 : 176510045 : next = p->next_same_hash;
6124 : 176510045 : if (p->in_memory)
6125 : 18209289 : remove_from_table (p, i);
6126 : : }
6127 : 12520074 : }
6128 : :
6129 : : /* Perform invalidation on the basis of everything about INSN,
6130 : : except for invalidating the actual places that are SET in it.
6131 : : This includes the places CLOBBERed, and anything that might
6132 : : alias with something that is SET or CLOBBERed. */
6133 : :
6134 : : static void
6135 : 343692392 : invalidate_from_clobbers (rtx_insn *insn)
6136 : : {
6137 : 343692392 : rtx x = PATTERN (insn);
6138 : :
6139 : 343692392 : if (GET_CODE (x) == CLOBBER)
6140 : : {
6141 : 77631 : rtx ref = XEXP (x, 0);
6142 : 77631 : if (ref)
6143 : : {
6144 : 77631 : if (REG_P (ref) || GET_CODE (ref) == SUBREG
6145 : 12708 : || MEM_P (ref))
6146 : 77631 : invalidate (ref, VOIDmode);
6147 : 0 : else if (GET_CODE (ref) == STRICT_LOW_PART
6148 : 0 : || GET_CODE (ref) == ZERO_EXTRACT)
6149 : 0 : invalidate (XEXP (ref, 0), GET_MODE (ref));
6150 : : }
6151 : : }
6152 : 343614761 : else if (GET_CODE (x) == PARALLEL)
6153 : : {
6154 : 28062351 : int i;
6155 : 85527122 : for (i = XVECLEN (x, 0) - 1; i >= 0; i--)
6156 : : {
6157 : 57464771 : rtx y = XVECEXP (x, 0, i);
6158 : 57464771 : if (GET_CODE (y) == CLOBBER)
6159 : : {
6160 : 27615792 : rtx ref = XEXP (y, 0);
6161 : 27615792 : if (REG_P (ref) || GET_CODE (ref) == SUBREG
6162 : 261196 : || MEM_P (ref))
6163 : 27413688 : invalidate (ref, VOIDmode);
6164 : 202104 : else if (GET_CODE (ref) == STRICT_LOW_PART
6165 : 202104 : || GET_CODE (ref) == ZERO_EXTRACT)
6166 : 0 : invalidate (XEXP (ref, 0), GET_MODE (ref));
6167 : : }
6168 : : }
6169 : : }
6170 : 343692392 : }
6171 : :
6172 : : /* Perform invalidation on the basis of everything about INSN.
6173 : : This includes the places CLOBBERed, and anything that might
6174 : : alias with something that is SET or CLOBBERed. */
6175 : :
6176 : : static void
6177 : 343692392 : invalidate_from_sets_and_clobbers (rtx_insn *insn)
6178 : : {
6179 : 343692392 : rtx tem;
6180 : 343692392 : rtx x = PATTERN (insn);
6181 : :
6182 : 343692392 : if (CALL_P (insn))
6183 : : {
6184 : 41613203 : for (tem = CALL_INSN_FUNCTION_USAGE (insn); tem; tem = XEXP (tem, 1))
6185 : : {
6186 : 26839875 : rtx temx = XEXP (tem, 0);
6187 : 26839875 : if (GET_CODE (temx) == CLOBBER)
6188 : 864474 : invalidate (SET_DEST (temx), VOIDmode);
6189 : : }
6190 : : }
6191 : :
6192 : : /* Ensure we invalidate the destination register of a CALL insn.
6193 : : This is necessary for machines where this register is a fixed_reg,
6194 : : because no other code would invalidate it. */
6195 : 343692392 : if (GET_CODE (x) == SET && GET_CODE (SET_SRC (x)) == CALL)
6196 : 6874453 : invalidate (SET_DEST (x), VOIDmode);
6197 : :
6198 : 336817939 : else if (GET_CODE (x) == PARALLEL)
6199 : : {
6200 : 28718466 : int i;
6201 : :
6202 : 87501214 : for (i = XVECLEN (x, 0) - 1; i >= 0; i--)
6203 : : {
6204 : 58782748 : rtx y = XVECEXP (x, 0, i);
6205 : 58782748 : if (GET_CODE (y) == CLOBBER)
6206 : : {
6207 : 28277654 : rtx clobbered = XEXP (y, 0);
6208 : :
6209 : 28277654 : if (REG_P (clobbered)
6210 : 266939 : || GET_CODE (clobbered) == SUBREG)
6211 : 28010715 : invalidate (clobbered, VOIDmode);
6212 : 266939 : else if (GET_CODE (clobbered) == STRICT_LOW_PART
6213 : 266939 : || GET_CODE (clobbered) == ZERO_EXTRACT)
6214 : 0 : invalidate (XEXP (clobbered, 0), GET_MODE (clobbered));
6215 : : }
6216 : 30505094 : else if (GET_CODE (y) == SET && GET_CODE (SET_SRC (y)) == CALL)
6217 : 10894 : invalidate (SET_DEST (y), VOIDmode);
6218 : : }
6219 : : }
6220 : 343692392 : }
6221 : :
6222 : : static rtx cse_process_note (rtx);
6223 : :
6224 : : /* A simplify_replace_fn_rtx callback for cse_process_note. Process X,
6225 : : part of the REG_NOTES of an insn. Replace any registers with either
6226 : : an equivalent constant or the canonical form of the register.
6227 : : Only replace addresses if the containing MEM remains valid.
6228 : :
6229 : : Return the replacement for X, or null if it should be simplified
6230 : : recursively. */
6231 : :
6232 : : static rtx
6233 : 26348887 : cse_process_note_1 (rtx x, const_rtx, void *)
6234 : : {
6235 : 26348887 : if (MEM_P (x))
6236 : : {
6237 : 1958166 : validate_change (x, &XEXP (x, 0), cse_process_note (XEXP (x, 0)), false);
6238 : 979083 : return x;
6239 : : }
6240 : :
6241 : 25369804 : if (REG_P (x))
6242 : : {
6243 : 5520319 : int i = REG_QTY (REGNO (x));
6244 : :
6245 : : /* Return a constant or a constant register. */
6246 : 5520319 : if (REGNO_QTY_VALID_P (REGNO (x)))
6247 : : {
6248 : 1424409 : struct qty_table_elem *ent = &qty_table[i];
6249 : :
6250 : 1424409 : if (ent->const_rtx != NULL_RTX
6251 : 21239 : && (CONSTANT_P (ent->const_rtx)
6252 : 16698 : || REG_P (ent->const_rtx)))
6253 : : {
6254 : 4541 : rtx new_rtx = gen_lowpart (GET_MODE (x), ent->const_rtx);
6255 : 4541 : if (new_rtx)
6256 : 4541 : return copy_rtx (new_rtx);
6257 : : }
6258 : : }
6259 : :
6260 : : /* Otherwise, canonicalize this register. */
6261 : 5515778 : return canon_reg (x, NULL);
6262 : : }
6263 : :
6264 : : return NULL_RTX;
6265 : : }
6266 : :
6267 : : /* Process X, part of the REG_NOTES of an insn. Replace any registers in it
6268 : : with either an equivalent constant or the canonical form of the register.
6269 : : Only replace addresses if the containing MEM remains valid. */
6270 : :
6271 : : static rtx
6272 : 9135022 : cse_process_note (rtx x)
6273 : : {
6274 : 979083 : return simplify_replace_fn_rtx (x, NULL_RTX, cse_process_note_1, NULL);
6275 : : }
6276 : :
6277 : :
6278 : : /* Find a path in the CFG, starting with FIRST_BB to perform CSE on.
6279 : :
6280 : : DATA is a pointer to a struct cse_basic_block_data, that is used to
6281 : : describe the path.
6282 : : It is filled with a queue of basic blocks, starting with FIRST_BB
6283 : : and following a trace through the CFG.
6284 : :
6285 : : If all paths starting at FIRST_BB have been followed, or no new path
6286 : : starting at FIRST_BB can be constructed, this function returns FALSE.
6287 : : Otherwise, DATA->path is filled and the function returns TRUE indicating
6288 : : that a path to follow was found.
6289 : :
6290 : : If FOLLOW_JUMPS is false, the maximum path length is 1 and the only
6291 : : block in the path will be FIRST_BB. */
6292 : :
6293 : : static bool
6294 : 36483768 : cse_find_path (basic_block first_bb, struct cse_basic_block_data *data,
6295 : : int follow_jumps)
6296 : : {
6297 : 36483768 : basic_block bb;
6298 : 36483768 : edge e;
6299 : 36483768 : int path_size;
6300 : :
6301 : 36483768 : bitmap_set_bit (cse_visited_basic_blocks, first_bb->index);
6302 : :
6303 : : /* See if there is a previous path. */
6304 : 36483768 : path_size = data->path_size;
6305 : :
6306 : : /* There is a previous path. Make sure it started with FIRST_BB. */
6307 : 36483768 : if (path_size)
6308 : 19642680 : gcc_assert (data->path[0].bb == first_bb);
6309 : :
6310 : : /* There was only one basic block in the last path. Clear the path and
6311 : : return, so that paths starting at another basic block can be tried. */
6312 : 19642680 : if (path_size == 1)
6313 : : {
6314 : 13117099 : path_size = 0;
6315 : 13117099 : goto done;
6316 : : }
6317 : :
6318 : : /* If the path was empty from the beginning, construct a new path. */
6319 : 23366669 : if (path_size == 0)
6320 : 16841088 : data->path[path_size++].bb = first_bb;
6321 : : else
6322 : : {
6323 : : /* Otherwise, path_size must be equal to or greater than 2, because
6324 : : a previous path exists that is at least two basic blocks long.
6325 : :
6326 : : Update the previous branch path, if any. If the last branch was
6327 : : previously along the branch edge, take the fallthrough edge now. */
6328 : 14271487 : while (path_size >= 2)
6329 : : {
6330 : 10547498 : basic_block last_bb_in_path, previous_bb_in_path;
6331 : 10547498 : edge e;
6332 : :
6333 : 10547498 : --path_size;
6334 : 10547498 : last_bb_in_path = data->path[path_size].bb;
6335 : 10547498 : previous_bb_in_path = data->path[path_size - 1].bb;
6336 : :
6337 : : /* If we previously followed a path along the branch edge, try
6338 : : the fallthru edge now. */
6339 : 18293404 : if (EDGE_COUNT (previous_bb_in_path->succs) == 2
6340 : 10250536 : && any_condjump_p (BB_END (previous_bb_in_path))
6341 : 10250536 : && (e = find_edge (previous_bb_in_path, last_bb_in_path))
6342 : 20798034 : && e == BRANCH_EDGE (previous_bb_in_path))
6343 : : {
6344 : 3752632 : bb = FALLTHRU_EDGE (previous_bb_in_path)->dest;
6345 : 3752632 : if (bb != EXIT_BLOCK_PTR_FOR_FN (cfun)
6346 : 3752632 : && single_pred_p (bb)
6347 : : /* We used to assert here that we would only see blocks
6348 : : that we have not visited yet. But we may end up
6349 : : visiting basic blocks twice if the CFG has changed
6350 : : in this run of cse_main, because when the CFG changes
6351 : : the topological sort of the CFG also changes. A basic
6352 : : blocks that previously had more than two predecessors
6353 : : may now have a single predecessor, and become part of
6354 : : a path that starts at another basic block.
6355 : :
6356 : : We still want to visit each basic block only once, so
6357 : : halt the path here if we have already visited BB. */
6358 : 6554224 : && !bitmap_bit_p (cse_visited_basic_blocks, bb->index))
6359 : : {
6360 : 2801592 : bitmap_set_bit (cse_visited_basic_blocks, bb->index);
6361 : 2801592 : data->path[path_size++].bb = bb;
6362 : 2801592 : break;
6363 : : }
6364 : : }
6365 : :
6366 : 7745906 : data->path[path_size].bb = NULL;
6367 : : }
6368 : :
6369 : : /* If only one block remains in the path, bail. */
6370 : 6525581 : if (path_size == 1)
6371 : : {
6372 : 3723989 : path_size = 0;
6373 : 3723989 : goto done;
6374 : : }
6375 : : }
6376 : :
6377 : : /* Extend the path if possible. */
6378 : 19642680 : if (follow_jumps)
6379 : : {
6380 : 11370723 : bb = data->path[path_size - 1].bb;
6381 : 19119661 : while (bb && path_size < param_max_cse_path_length)
6382 : : {
6383 : 18962630 : if (single_succ_p (bb))
6384 : 8385487 : e = single_succ_edge (bb);
6385 : 10577143 : else if (EDGE_COUNT (bb->succs) == 2
6386 : 10567992 : && any_condjump_p (BB_END (bb)))
6387 : : {
6388 : : /* First try to follow the branch. If that doesn't lead
6389 : : to a useful path, follow the fallthru edge. */
6390 : 8300044 : e = BRANCH_EDGE (bb);
6391 : 8300044 : if (!single_pred_p (e->dest))
6392 : 4536497 : e = FALLTHRU_EDGE (bb);
6393 : : }
6394 : : else
6395 : : e = NULL;
6396 : :
6397 : 16685531 : if (e
6398 : 16685531 : && !((e->flags & EDGE_ABNORMAL_CALL) && cfun->has_nonlocal_label)
6399 : 16684486 : && e->dest != EXIT_BLOCK_PTR_FOR_FN (cfun)
6400 : 14630847 : && single_pred_p (e->dest)
6401 : : /* Avoid visiting basic blocks twice. The large comment
6402 : : above explains why this can happen. */
6403 : 24434486 : && !bitmap_bit_p (cse_visited_basic_blocks, e->dest->index))
6404 : : {
6405 : 7748938 : basic_block bb2 = e->dest;
6406 : 7748938 : bitmap_set_bit (cse_visited_basic_blocks, bb2->index);
6407 : 7748938 : data->path[path_size++].bb = bb2;
6408 : 7748938 : bb = bb2;
6409 : : }
6410 : : else
6411 : : bb = NULL;
6412 : : }
6413 : : }
6414 : :
6415 : 8271957 : done:
6416 : 36483768 : data->path_size = path_size;
6417 : 36483768 : return path_size != 0;
6418 : : }
6419 : :
6420 : : /* Dump the path in DATA to file F. NSETS is the number of sets
6421 : : in the path. */
6422 : :
6423 : : static void
6424 : 327 : cse_dump_path (struct cse_basic_block_data *data, int nsets, FILE *f)
6425 : : {
6426 : 327 : int path_entry;
6427 : :
6428 : 327 : fprintf (f, ";; Following path with %d sets: ", nsets);
6429 : 1149 : for (path_entry = 0; path_entry < data->path_size; path_entry++)
6430 : 495 : fprintf (f, "%d ", (data->path[path_entry].bb)->index);
6431 : 327 : fputc ('\n', f);
6432 : 327 : fflush (f);
6433 : 327 : }
6434 : :
6435 : :
6436 : : /* Return true if BB has exception handling successor edges. */
6437 : :
6438 : : static bool
6439 : 9045142 : have_eh_succ_edges (basic_block bb)
6440 : : {
6441 : 9045142 : edge e;
6442 : 9045142 : edge_iterator ei;
6443 : :
6444 : 21223731 : FOR_EACH_EDGE (e, ei, bb->succs)
6445 : 13203074 : if (e->flags & EDGE_EH)
6446 : : return true;
6447 : :
6448 : : return false;
6449 : : }
6450 : :
6451 : :
6452 : : /* Scan to the end of the path described by DATA. Return an estimate of
6453 : : the total number of SETs of all insns in the path. */
6454 : :
6455 : : static void
6456 : 19642680 : cse_prescan_path (struct cse_basic_block_data *data)
6457 : : {
6458 : 19642680 : int nsets = 0;
6459 : 19642680 : int path_size = data->path_size;
6460 : 19642680 : int path_entry;
6461 : :
6462 : : /* Scan to end of each basic block in the path. */
6463 : 53234773 : for (path_entry = 0; path_entry < path_size; path_entry++)
6464 : : {
6465 : 33592093 : basic_block bb;
6466 : 33592093 : rtx_insn *insn;
6467 : :
6468 : 33592093 : bb = data->path[path_entry].bb;
6469 : :
6470 : 430888302 : FOR_BB_INSNS (bb, insn)
6471 : : {
6472 : 397296209 : if (!INSN_P (insn))
6473 : 53591812 : continue;
6474 : :
6475 : : /* A PARALLEL can have lots of SETs in it,
6476 : : especially if it is really an ASM_OPERANDS. */
6477 : 343704397 : if (GET_CODE (PATTERN (insn)) == PARALLEL)
6478 : 28722602 : nsets += XVECLEN (PATTERN (insn), 0);
6479 : : else
6480 : 314981795 : nsets += 1;
6481 : : }
6482 : : }
6483 : :
6484 : 19642680 : data->nsets = nsets;
6485 : 19642680 : }
6486 : :
6487 : : /* Return true if the pattern of INSN uses a LABEL_REF for which
6488 : : there isn't a REG_LABEL_OPERAND note. */
6489 : :
6490 : : static bool
6491 : 343520225 : check_for_label_ref (rtx_insn *insn)
6492 : : {
6493 : : /* If this insn uses a LABEL_REF and there isn't a REG_LABEL_OPERAND
6494 : : note for it, we must rerun jump since it needs to place the note. If
6495 : : this is a LABEL_REF for a CODE_LABEL that isn't in the insn chain,
6496 : : don't do this since no REG_LABEL_OPERAND will be added. */
6497 : 343520225 : subrtx_iterator::array_type array;
6498 : 1750487562 : FOR_EACH_SUBRTX (iter, array, PATTERN (insn), ALL)
6499 : : {
6500 : 1406968679 : const_rtx x = *iter;
6501 : 1406968679 : if (GET_CODE (x) == LABEL_REF
6502 : 18497580 : && !LABEL_REF_NONLOCAL_P (x)
6503 : 18496753 : && (!JUMP_P (insn)
6504 : 18457856 : || !label_is_jump_target_p (label_ref_label (x), insn))
6505 : 38898 : && LABEL_P (label_ref_label (x))
6506 : 38557 : && INSN_UID (label_ref_label (x)) != 0
6507 : 1407007236 : && !find_reg_note (insn, REG_LABEL_OPERAND, label_ref_label (x)))
6508 : 1342 : return true;
6509 : : }
6510 : 343518883 : return false;
6511 : 343520225 : }
6512 : :
6513 : : /* Process a single extended basic block described by EBB_DATA. */
6514 : :
6515 : : static void
6516 : 19149287 : cse_extended_basic_block (struct cse_basic_block_data *ebb_data)
6517 : : {
6518 : 19149287 : int path_size = ebb_data->path_size;
6519 : 19149287 : int path_entry;
6520 : 19149287 : int num_insns = 0;
6521 : :
6522 : : /* Allocate the space needed by qty_table. */
6523 : 19149287 : qty_table = XNEWVEC (struct qty_table_elem, max_qty);
6524 : :
6525 : 19149287 : new_basic_block ();
6526 : 19149287 : cse_ebb_live_in = df_get_live_in (ebb_data->path[0].bb);
6527 : 19149287 : cse_ebb_live_out = df_get_live_out (ebb_data->path[path_size - 1].bb);
6528 : 52244815 : for (path_entry = 0; path_entry < path_size; path_entry++)
6529 : : {
6530 : 33095528 : basic_block bb;
6531 : 33095528 : rtx_insn *insn;
6532 : :
6533 : 33095528 : bb = ebb_data->path[path_entry].bb;
6534 : :
6535 : : /* Invalidate recorded information for eh regs if there is an EH
6536 : : edge pointing to that bb. */
6537 : 33095528 : if (bb_has_eh_pred (bb))
6538 : : {
6539 : 510913 : df_ref def;
6540 : :
6541 : 2043652 : FOR_EACH_ARTIFICIAL_DEF (def, bb->index)
6542 : 1021826 : if (DF_REF_FLAGS (def) & DF_REF_AT_TOP)
6543 : 1021826 : invalidate (DF_REF_REG (def), GET_MODE (DF_REF_REG (def)));
6544 : : }
6545 : :
6546 : 33095528 : optimize_this_for_speed_p = optimize_bb_for_speed_p (bb);
6547 : 429513343 : FOR_BB_INSNS (bb, insn)
6548 : : {
6549 : : /* If we have processed 1,000 insns, flush the hash table to
6550 : : avoid extreme quadratic behavior. We must not include NOTEs
6551 : : in the count since there may be more of them when generating
6552 : : debugging information. If we clear the table at different
6553 : : times, code generated with -g -O might be different than code
6554 : : generated with -O but not -g.
6555 : :
6556 : : FIXME: This is a real kludge and needs to be done some other
6557 : : way. */
6558 : 396417815 : if (NONDEBUG_INSN_P (insn)
6559 : 396417815 : && num_insns++ > param_max_cse_insns)
6560 : : {
6561 : 1832 : flush_hash_table ();
6562 : 1832 : num_insns = 0;
6563 : : }
6564 : :
6565 : 396417815 : if (INSN_P (insn))
6566 : : {
6567 : : /* Process notes first so we have all notes in canonical forms
6568 : : when looking for duplicate operations. */
6569 : 343692392 : bool changed = false;
6570 : 563315340 : for (rtx note = REG_NOTES (insn); note; note = XEXP (note, 1))
6571 : 219622948 : if (REG_NOTE_KIND (note) == REG_EQUAL)
6572 : : {
6573 : 8155939 : rtx newval = cse_process_note (XEXP (note, 0));
6574 : 8155939 : if (newval != XEXP (note, 0))
6575 : : {
6576 : 33882 : XEXP (note, 0) = newval;
6577 : 33882 : changed = true;
6578 : : }
6579 : : }
6580 : 343692392 : if (changed)
6581 : 33882 : df_notes_rescan (insn);
6582 : :
6583 : 343692392 : cse_insn (insn);
6584 : :
6585 : : /* If we haven't already found an insn where we added a LABEL_REF,
6586 : : check this one. */
6587 : 343692392 : if (INSN_P (insn) && !recorded_label_ref
6588 : 687212617 : && check_for_label_ref (insn))
6589 : 1342 : recorded_label_ref = true;
6590 : : }
6591 : : }
6592 : :
6593 : : /* With non-call exceptions, we are not always able to update
6594 : : the CFG properly inside cse_insn. So clean up possibly
6595 : : redundant EH edges here. */
6596 : 33095528 : if (cfun->can_throw_non_call_exceptions && have_eh_succ_edges (bb))
6597 : 1024485 : cse_cfg_altered |= purge_dead_edges (bb);
6598 : :
6599 : : /* If we changed a conditional jump, we may have terminated
6600 : : the path we are following. Check that by verifying that
6601 : : the edge we would take still exists. If the edge does
6602 : : not exist anymore, purge the remainder of the path.
6603 : : Note that this will cause us to return to the caller. */
6604 : 33095528 : if (path_entry < path_size - 1)
6605 : : {
6606 : 13948987 : basic_block next_bb = ebb_data->path[path_entry + 1].bb;
6607 : 13948987 : if (!find_edge (bb, next_bb))
6608 : : {
6609 : 3032 : do
6610 : : {
6611 : 3032 : path_size--;
6612 : :
6613 : : /* If we truncate the path, we must also reset the
6614 : : visited bit on the remaining blocks in the path,
6615 : : or we will never visit them at all. */
6616 : 3032 : bitmap_clear_bit (cse_visited_basic_blocks,
6617 : 3032 : ebb_data->path[path_size].bb->index);
6618 : 3032 : ebb_data->path[path_size].bb = NULL;
6619 : : }
6620 : 3032 : while (path_size - 1 != path_entry);
6621 : 2746 : ebb_data->path_size = path_size;
6622 : : }
6623 : : }
6624 : :
6625 : : /* If this is a conditional jump insn, record any known
6626 : : equivalences due to the condition being tested. */
6627 : 33095528 : insn = BB_END (bb);
6628 : 33095528 : if (path_entry < path_size - 1
6629 : 46734492 : && EDGE_COUNT (bb->succs) == 2
6630 : 13638964 : && JUMP_P (insn)
6631 : 13638964 : && single_set (insn)
6632 : 13638964 : && any_condjump_p (insn)
6633 : : /* single_set may return non-NULL even for multiple sets
6634 : : if there are REG_UNUSED notes. record_jump_equiv only
6635 : : looks at pc_set and doesn't consider other sets that
6636 : : could affect the value, and the recorded equivalence
6637 : : can extend the lifetime of the compared REG, so use
6638 : : also !multiple_sets check to verify it is exactly one
6639 : : set. */
6640 : 46734492 : && !multiple_sets (insn))
6641 : : {
6642 : 13638964 : basic_block next_bb = ebb_data->path[path_entry + 1].bb;
6643 : 13638964 : bool taken = (next_bb == BRANCH_EDGE (bb)->dest);
6644 : 13638964 : record_jump_equiv (insn, taken);
6645 : : }
6646 : : }
6647 : :
6648 : 19149287 : gcc_assert (next_qty <= max_qty);
6649 : :
6650 : 19149287 : free (qty_table);
6651 : 19149287 : }
6652 : :
6653 : :
6654 : : /* Perform cse on the instructions of a function.
6655 : : F is the first instruction.
6656 : : NREGS is one plus the highest pseudo-reg number used in the instruction.
6657 : :
6658 : : Return 2 if jump optimizations should be redone due to simplifications
6659 : : in conditional jump instructions.
6660 : : Return 1 if the CFG should be cleaned up because it has been modified.
6661 : : Return 0 otherwise. */
6662 : :
6663 : : static int
6664 : 2201041 : cse_main (rtx_insn *f ATTRIBUTE_UNUSED, int nregs)
6665 : : {
6666 : 2201041 : struct cse_basic_block_data ebb_data;
6667 : 2201041 : basic_block bb;
6668 : 2201041 : int *rc_order = XNEWVEC (int, last_basic_block_for_fn (cfun));
6669 : 2201041 : int i, n_blocks;
6670 : :
6671 : : /* CSE doesn't use dominane info but can invalidate it in different ways.
6672 : : For simplicity free dominance info here. */
6673 : 2201041 : free_dominance_info (CDI_DOMINATORS);
6674 : :
6675 : 2201041 : df_set_flags (DF_LR_RUN_DCE);
6676 : 2201041 : df_note_add_problem ();
6677 : 2201041 : df_analyze ();
6678 : 2201041 : df_set_flags (DF_DEFER_INSN_RESCAN);
6679 : :
6680 : 2201041 : reg_scan (get_insns (), max_reg_num ());
6681 : 2201041 : init_cse_reg_info (nregs);
6682 : :
6683 : 2201041 : ebb_data.path = XNEWVEC (struct branch_path,
6684 : : param_max_cse_path_length);
6685 : :
6686 : 2201041 : cse_cfg_altered = false;
6687 : 2201041 : cse_jumps_altered = false;
6688 : 2201041 : recorded_label_ref = false;
6689 : 2201041 : ebb_data.path_size = 0;
6690 : 2201041 : ebb_data.nsets = 0;
6691 : 2201041 : rtl_hooks = cse_rtl_hooks;
6692 : :
6693 : 2201041 : init_recog ();
6694 : 2201041 : init_alias_analysis ();
6695 : :
6696 : 2201041 : reg_eqv_table = XNEWVEC (struct reg_eqv_elem, nregs);
6697 : :
6698 : : /* Set up the table of already visited basic blocks. */
6699 : 2201041 : cse_visited_basic_blocks = sbitmap_alloc (last_basic_block_for_fn (cfun));
6700 : 2201041 : bitmap_clear (cse_visited_basic_blocks);
6701 : :
6702 : : /* Loop over basic blocks in reverse completion order (RPO),
6703 : : excluding the ENTRY and EXIT blocks. */
6704 : 2201041 : n_blocks = pre_and_rev_post_order_compute (NULL, rc_order, false);
6705 : 2201041 : i = 0;
6706 : 21243170 : while (i < n_blocks)
6707 : : {
6708 : : /* Find the first block in the RPO queue that we have not yet
6709 : : processed before. */
6710 : 26996530 : do
6711 : : {
6712 : 26996530 : bb = BASIC_BLOCK_FOR_FN (cfun, rc_order[i++]);
6713 : : }
6714 : 26996530 : while (bitmap_bit_p (cse_visited_basic_blocks, bb->index)
6715 : 43837618 : && i < n_blocks);
6716 : :
6717 : : /* Find all paths starting with BB, and process them. */
6718 : 36483768 : while (cse_find_path (bb, &ebb_data, flag_cse_follow_jumps))
6719 : : {
6720 : : /* Pre-scan the path. */
6721 : 19642680 : cse_prescan_path (&ebb_data);
6722 : :
6723 : : /* If this basic block has no sets, skip it. */
6724 : 19642680 : if (ebb_data.nsets == 0)
6725 : 493393 : continue;
6726 : :
6727 : : /* Get a reasonable estimate for the maximum number of qty's
6728 : : needed for this path. For this, we take the number of sets
6729 : : and multiply that by MAX_RECOG_OPERANDS. */
6730 : 19149287 : max_qty = ebb_data.nsets * MAX_RECOG_OPERANDS;
6731 : :
6732 : : /* Dump the path we're about to process. */
6733 : 19149287 : if (dump_file)
6734 : 327 : cse_dump_path (&ebb_data, ebb_data.nsets, dump_file);
6735 : :
6736 : 19149287 : cse_extended_basic_block (&ebb_data);
6737 : : }
6738 : : }
6739 : :
6740 : : /* Clean up. */
6741 : 2201041 : end_alias_analysis ();
6742 : 2201041 : free (reg_eqv_table);
6743 : 2201041 : free (ebb_data.path);
6744 : 2201041 : sbitmap_free (cse_visited_basic_blocks);
6745 : 2201041 : free (rc_order);
6746 : 2201041 : rtl_hooks = general_rtl_hooks;
6747 : :
6748 : 2201041 : if (cse_jumps_altered || recorded_label_ref)
6749 : : return 2;
6750 : 2193448 : else if (cse_cfg_altered)
6751 : : return 1;
6752 : : else
6753 : 2183424 : return 0;
6754 : : }
6755 : :
6756 : : /* Count the number of times registers are used (not set) in X.
6757 : : COUNTS is an array in which we accumulate the count, INCR is how much
6758 : : we count each register usage.
6759 : :
6760 : : Don't count a usage of DEST, which is the SET_DEST of a SET which
6761 : : contains X in its SET_SRC. This is because such a SET does not
6762 : : modify the liveness of DEST.
6763 : : DEST is set to pc_rtx for a trapping insn, or for an insn with side effects.
6764 : : We must then count uses of a SET_DEST regardless, because the insn can't be
6765 : : deleted here. */
6766 : :
6767 : : static void
6768 : 2228168282 : count_reg_usage (rtx x, int *counts, rtx dest, int incr)
6769 : : {
6770 : 2673954495 : enum rtx_code code;
6771 : 2673954495 : rtx note;
6772 : 2673954495 : const char *fmt;
6773 : 2673954495 : int i, j;
6774 : :
6775 : 2673954495 : if (x == 0)
6776 : : return;
6777 : :
6778 : 2645974551 : switch (code = GET_CODE (x))
6779 : : {
6780 : 501941743 : case REG:
6781 : 501941743 : if (x != dest)
6782 : 483755985 : counts[REGNO (x)] += incr;
6783 : : return;
6784 : :
6785 : : case PC:
6786 : : case CONST:
6787 : : CASE_CONST_ANY:
6788 : : case SYMBOL_REF:
6789 : : case LABEL_REF:
6790 : : return;
6791 : :
6792 : 139339364 : case CLOBBER:
6793 : : /* If we are clobbering a MEM, mark any registers inside the address
6794 : : as being used. */
6795 : 139339364 : if (MEM_P (XEXP (x, 0)))
6796 : 209641 : count_reg_usage (XEXP (XEXP (x, 0), 0), counts, NULL_RTX, incr);
6797 : : return;
6798 : :
6799 : 370744380 : case SET:
6800 : : /* Unless we are setting a REG, count everything in SET_DEST. */
6801 : 370744380 : if (!REG_P (SET_DEST (x)))
6802 : 89024690 : count_reg_usage (SET_DEST (x), counts, NULL_RTX, incr);
6803 : 370744380 : count_reg_usage (SET_SRC (x), counts,
6804 : : dest ? dest : SET_DEST (x),
6805 : : incr);
6806 : 370744380 : return;
6807 : :
6808 : : case DEBUG_INSN:
6809 : : return;
6810 : :
6811 : 390236526 : case CALL_INSN:
6812 : 390236526 : case INSN:
6813 : 390236526 : case JUMP_INSN:
6814 : : /* We expect dest to be NULL_RTX here. If the insn may throw,
6815 : : or if it cannot be deleted due to side-effects, mark this fact
6816 : : by setting DEST to pc_rtx. */
6817 : 152257019 : if ((!cfun->can_delete_dead_exceptions && !insn_nothrow_p (x))
6818 : 525194426 : || side_effects_p (PATTERN (x)))
6819 : 51967824 : dest = pc_rtx;
6820 : 390236526 : if (code == CALL_INSN)
6821 : 27979944 : count_reg_usage (CALL_INSN_FUNCTION_USAGE (x), counts, dest, incr);
6822 : 390236526 : count_reg_usage (PATTERN (x), counts, dest, incr);
6823 : :
6824 : : /* Things used in a REG_EQUAL note aren't dead since loop may try to
6825 : : use them. */
6826 : :
6827 : 390236526 : note = find_reg_equal_equiv_note (x);
6828 : 390236526 : if (note)
6829 : : {
6830 : 20823191 : rtx eqv = XEXP (note, 0);
6831 : :
6832 : 20823191 : if (GET_CODE (eqv) == EXPR_LIST)
6833 : : /* This REG_EQUAL note describes the result of a function call.
6834 : : Process all the arguments. */
6835 : 0 : do
6836 : : {
6837 : 0 : count_reg_usage (XEXP (eqv, 0), counts, dest, incr);
6838 : 0 : eqv = XEXP (eqv, 1);
6839 : : }
6840 : 0 : while (eqv && GET_CODE (eqv) == EXPR_LIST);
6841 : : else
6842 : : count_reg_usage (eqv, counts, dest, incr);
6843 : : }
6844 : : return;
6845 : :
6846 : 54009001 : case EXPR_LIST:
6847 : 54009001 : if (REG_NOTE_KIND (x) == REG_EQUAL
6848 : 54009001 : || (REG_NOTE_KIND (x) != REG_NONNEG && GET_CODE (XEXP (x,0)) == USE)
6849 : : /* FUNCTION_USAGE expression lists may include (CLOBBER (mem /u)),
6850 : : involving registers in the address. */
6851 : 3377706 : || GET_CODE (XEXP (x, 0)) == CLOBBER)
6852 : 53513248 : count_reg_usage (XEXP (x, 0), counts, NULL_RTX, incr);
6853 : :
6854 : 54009001 : count_reg_usage (XEXP (x, 1), counts, NULL_RTX, incr);
6855 : 54009001 : return;
6856 : :
6857 : 665053 : case ASM_OPERANDS:
6858 : : /* Iterate over just the inputs, not the constraints as well. */
6859 : 1253467 : for (i = ASM_OPERANDS_INPUT_LENGTH (x) - 1; i >= 0; i--)
6860 : 588414 : count_reg_usage (ASM_OPERANDS_INPUT (x, i), counts, dest, incr);
6861 : : return;
6862 : :
6863 : 0 : case INSN_LIST:
6864 : 0 : case INT_LIST:
6865 : 0 : gcc_unreachable ();
6866 : :
6867 : 661374850 : default:
6868 : 661374850 : break;
6869 : : }
6870 : :
6871 : 661374850 : fmt = GET_RTX_FORMAT (code);
6872 : 1838552981 : for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
6873 : : {
6874 : 1177178131 : if (fmt[i] == 'e')
6875 : 900612128 : count_reg_usage (XEXP (x, i), counts, dest, incr);
6876 : 276566003 : else if (fmt[i] == 'E')
6877 : 195511975 : for (j = XVECLEN (x, i) - 1; j >= 0; j--)
6878 : 130957112 : count_reg_usage (XVECEXP (x, i, j), counts, dest, incr);
6879 : : }
6880 : : }
6881 : :
6882 : : /* Return true if X is a dead register. */
6883 : :
6884 : : static inline bool
6885 : 679661686 : is_dead_reg (const_rtx x, int *counts)
6886 : : {
6887 : 679661686 : return (REG_P (x)
6888 : 320358547 : && REGNO (x) >= FIRST_PSEUDO_REGISTER
6889 : 199699010 : && counts[REGNO (x)] == 0);
6890 : : }
6891 : :
6892 : : /* Return true if set is live. */
6893 : : static bool
6894 : 349918047 : set_live_p (rtx set, int *counts)
6895 : : {
6896 : 349918047 : if (set_noop_p (set))
6897 : : return false;
6898 : :
6899 : 349901505 : if (!is_dead_reg (SET_DEST (set), counts)
6900 : 8021292 : || side_effects_p (SET_SRC (set)))
6901 : 341940932 : return true;
6902 : :
6903 : : return false;
6904 : : }
6905 : :
6906 : : /* Return true if insn is live. */
6907 : :
6908 : : static bool
6909 : 627201500 : insn_live_p (rtx_insn *insn, int *counts)
6910 : : {
6911 : 627201500 : int i;
6912 : 627201500 : if (!cfun->can_delete_dead_exceptions && !insn_nothrow_p (insn))
6913 : : return true;
6914 : 609591475 : else if (GET_CODE (PATTERN (insn)) == SET)
6915 : 294393229 : return set_live_p (PATTERN (insn), counts);
6916 : 315198246 : else if (GET_CODE (PATTERN (insn)) == PARALLEL)
6917 : : {
6918 : 112589399 : for (i = XVECLEN (PATTERN (insn), 0) - 1; i >= 0; i--)
6919 : : {
6920 : 112123752 : rtx elt = XVECEXP (PATTERN (insn), 0, i);
6921 : :
6922 : 112123752 : if (GET_CODE (elt) == SET)
6923 : : {
6924 : 55524818 : if (set_live_p (elt, counts))
6925 : : return true;
6926 : : }
6927 : 56598934 : else if (GET_CODE (elt) != CLOBBER && GET_CODE (elt) != USE)
6928 : : return true;
6929 : : }
6930 : : return false;
6931 : : }
6932 : 259544488 : else if (DEBUG_INSN_P (insn))
6933 : : {
6934 : 244384846 : if (DEBUG_MARKER_INSN_P (insn))
6935 : : return true;
6936 : :
6937 : 183930514 : if (DEBUG_BIND_INSN_P (insn)
6938 : 183930514 : && TREE_VISITED (INSN_VAR_LOCATION_DECL (insn)))
6939 : : return false;
6940 : :
6941 : : return true;
6942 : : }
6943 : : else
6944 : : return true;
6945 : : }
6946 : :
6947 : : /* Count the number of stores into pseudo. Callback for note_stores. */
6948 : :
6949 : : static void
6950 : 240144198 : count_stores (rtx x, const_rtx set ATTRIBUTE_UNUSED, void *data)
6951 : : {
6952 : 240144198 : int *counts = (int *) data;
6953 : 240144198 : if (REG_P (x) && REGNO (x) >= FIRST_PSEUDO_REGISTER)
6954 : 90934999 : counts[REGNO (x)]++;
6955 : 240144198 : }
6956 : :
6957 : : /* Return if DEBUG_INSN pattern PAT needs to be reset because some dead
6958 : : pseudo doesn't have a replacement. COUNTS[X] is zero if register X
6959 : : is dead and REPLACEMENTS[X] is null if it has no replacemenet.
6960 : : Set *SEEN_REPL to true if we see a dead register that does have
6961 : : a replacement. */
6962 : :
6963 : : static bool
6964 : 183950002 : is_dead_debug_insn (const_rtx pat, int *counts, rtx *replacements,
6965 : : bool *seen_repl)
6966 : : {
6967 : 183950002 : subrtx_iterator::array_type array;
6968 : 509989124 : FOR_EACH_SUBRTX (iter, array, pat, NONCONST)
6969 : : {
6970 : 326065171 : const_rtx x = *iter;
6971 : 379894020 : if (is_dead_reg (x, counts))
6972 : : {
6973 : 49623 : if (replacements && replacements[REGNO (x)] != NULL_RTX)
6974 : 23574 : *seen_repl = true;
6975 : : else
6976 : 26049 : return true;
6977 : : }
6978 : : }
6979 : 183923953 : return false;
6980 : 183950002 : }
6981 : :
6982 : : /* Replace a dead pseudo in a DEBUG_INSN with replacement DEBUG_EXPR.
6983 : : Callback for simplify_replace_fn_rtx. */
6984 : :
6985 : : static rtx
6986 : 37503 : replace_dead_reg (rtx x, const_rtx old_rtx ATTRIBUTE_UNUSED, void *data)
6987 : : {
6988 : 37503 : rtx *replacements = (rtx *) data;
6989 : :
6990 : 37503 : if (REG_P (x)
6991 : 24479 : && REGNO (x) >= FIRST_PSEUDO_REGISTER
6992 : 61976 : && replacements[REGNO (x)] != NULL_RTX)
6993 : : {
6994 : 23574 : if (GET_MODE (x) == GET_MODE (replacements[REGNO (x)]))
6995 : : return replacements[REGNO (x)];
6996 : 0 : return lowpart_subreg (GET_MODE (x), replacements[REGNO (x)],
6997 : 0 : GET_MODE (replacements[REGNO (x)]));
6998 : : }
6999 : : return NULL_RTX;
7000 : : }
7001 : :
7002 : : /* Scan all the insns and delete any that are dead; i.e., they store a register
7003 : : that is never used or they copy a register to itself.
7004 : :
7005 : : This is used to remove insns made obviously dead by cse, loop or other
7006 : : optimizations. It improves the heuristics in loop since it won't try to
7007 : : move dead invariants out of loops or make givs for dead quantities. The
7008 : : remaining passes of the compilation are also sped up. */
7009 : :
7010 : : int
7011 : 6128951 : delete_trivially_dead_insns (rtx_insn *insns, int nreg)
7012 : : {
7013 : 6128951 : int *counts;
7014 : 6128951 : rtx_insn *insn, *prev;
7015 : 6128951 : rtx *replacements = NULL;
7016 : 6128951 : int ndead = 0;
7017 : :
7018 : 6128951 : timevar_push (TV_DELETE_TRIVIALLY_DEAD);
7019 : : /* First count the number of times each register is used. */
7020 : 6128951 : if (MAY_HAVE_DEBUG_BIND_INSNS)
7021 : : {
7022 : 2549229 : counts = XCNEWVEC (int, nreg * 3);
7023 : 533049857 : for (insn = insns; insn; insn = NEXT_INSN (insn))
7024 : 530500628 : if (DEBUG_BIND_INSN_P (insn))
7025 : : {
7026 : 184241420 : count_reg_usage (INSN_VAR_LOCATION_LOC (insn), counts + nreg,
7027 : : NULL_RTX, 1);
7028 : 184241420 : TREE_VISITED (INSN_VAR_LOCATION_DECL (insn)) = 0;
7029 : : }
7030 : 346259208 : else if (INSN_P (insn))
7031 : : {
7032 : 278522512 : count_reg_usage (insn, counts, NULL_RTX, 1);
7033 : 278522512 : note_stores (insn, count_stores, counts + nreg * 2);
7034 : : }
7035 : : /* If there can be debug insns, COUNTS are 3 consecutive arrays.
7036 : : First one counts how many times each pseudo is used outside
7037 : : of debug insns, second counts how many times each pseudo is
7038 : : used in debug insns and third counts how many times a pseudo
7039 : : is stored. */
7040 : : }
7041 : : else
7042 : : {
7043 : 3579722 : counts = XCNEWVEC (int, nreg);
7044 : 216149039 : for (insn = insns; insn; insn = NEXT_INSN (insn))
7045 : 208989595 : if (INSN_P (insn))
7046 : 164437568 : count_reg_usage (insn, counts, NULL_RTX, 1);
7047 : : /* If no debug insns can be present, COUNTS is just an array
7048 : : which counts how many times each pseudo is used. */
7049 : : }
7050 : : /* Pseudo PIC register should be considered as used due to possible
7051 : : new usages generated. */
7052 : 6128951 : if (!reload_completed
7053 : 6128951 : && pic_offset_table_rtx
7054 : 6342538 : && REGNO (pic_offset_table_rtx) >= FIRST_PSEUDO_REGISTER)
7055 : 213587 : counts[REGNO (pic_offset_table_rtx)]++;
7056 : : /* Go from the last insn to the first and delete insns that only set unused
7057 : : registers or copy a register to itself. As we delete an insn, remove
7058 : : usage counts for registers it uses.
7059 : :
7060 : : The first jump optimization pass may leave a real insn as the last
7061 : : insn in the function. We must not skip that insn or we may end
7062 : : up deleting code that is not really dead.
7063 : :
7064 : : If some otherwise unused register is only used in DEBUG_INSNs,
7065 : : try to create a DEBUG_EXPR temporary and emit a DEBUG_INSN before
7066 : : the setter. Then go through DEBUG_INSNs and if a DEBUG_EXPR
7067 : : has been created for the unused register, replace it with
7068 : : the DEBUG_EXPR, otherwise reset the DEBUG_INSN. */
7069 : 6128951 : auto_vec<tree, 32> later_debug_set_vars;
7070 : 745619174 : for (insn = get_last_insn (); insn; insn = prev)
7071 : : {
7072 : 739490223 : int live_insn = 0;
7073 : :
7074 : 739490223 : prev = PREV_INSN (insn);
7075 : 739490223 : if (!INSN_P (insn))
7076 : 112288723 : continue;
7077 : :
7078 : 627201500 : live_insn = insn_live_p (insn, counts);
7079 : :
7080 : : /* If this is a dead insn, delete it and show registers in it aren't
7081 : : being used. */
7082 : :
7083 : 627201500 : if (! live_insn && dbg_cnt (delete_trivial_dead))
7084 : : {
7085 : 8038458 : if (DEBUG_INSN_P (insn))
7086 : : {
7087 : 307680 : if (DEBUG_BIND_INSN_P (insn))
7088 : 307680 : count_reg_usage (INSN_VAR_LOCATION_LOC (insn), counts + nreg,
7089 : : NULL_RTX, -1);
7090 : : }
7091 : : else
7092 : : {
7093 : 7730778 : rtx set;
7094 : 7730778 : if (MAY_HAVE_DEBUG_BIND_INSNS
7095 : 3695010 : && (set = single_set (insn)) != NULL_RTX
7096 : 3695010 : && is_dead_reg (SET_DEST (set), counts)
7097 : : /* Used at least once in some DEBUG_INSN. */
7098 : 3689109 : && counts[REGNO (SET_DEST (set)) + nreg] > 0
7099 : : /* And set exactly once. */
7100 : 18386 : && counts[REGNO (SET_DEST (set)) + nreg * 2] == 1
7101 : 16263 : && !side_effects_p (SET_SRC (set))
7102 : 7747041 : && asm_noperands (PATTERN (insn)) < 0)
7103 : : {
7104 : 16262 : rtx dval, bind_var_loc;
7105 : 16262 : rtx_insn *bind;
7106 : :
7107 : : /* Create DEBUG_EXPR (and DEBUG_EXPR_DECL). */
7108 : 16262 : dval = make_debug_expr_from_rtl (SET_DEST (set));
7109 : :
7110 : : /* Emit a debug bind insn before the insn in which
7111 : : reg dies. */
7112 : 16262 : bind_var_loc =
7113 : 16262 : gen_rtx_VAR_LOCATION (GET_MODE (SET_DEST (set)),
7114 : : DEBUG_EXPR_TREE_DECL (dval),
7115 : : SET_SRC (set),
7116 : : VAR_INIT_STATUS_INITIALIZED);
7117 : 16262 : count_reg_usage (bind_var_loc, counts + nreg, NULL_RTX, 1);
7118 : :
7119 : 16262 : bind = emit_debug_insn_before (bind_var_loc, insn);
7120 : 16262 : df_insn_rescan (bind);
7121 : :
7122 : 16262 : if (replacements == NULL)
7123 : 7827 : replacements = XCNEWVEC (rtx, nreg);
7124 : 16262 : replacements[REGNO (SET_DEST (set))] = dval;
7125 : : }
7126 : :
7127 : 7730778 : count_reg_usage (insn, counts, NULL_RTX, -1);
7128 : 7730778 : ndead++;
7129 : : }
7130 : 8038458 : cse_cfg_altered |= delete_insn_and_edges (insn);
7131 : : }
7132 : : else
7133 : : {
7134 : 619163042 : if (!DEBUG_INSN_P (insn) || DEBUG_MARKER_INSN_P (insn))
7135 : : {
7136 : 1489362434 : for (tree var : later_debug_set_vars)
7137 : 183674528 : TREE_VISITED (var) = 0;
7138 : 435229302 : later_debug_set_vars.truncate (0);
7139 : : }
7140 : 183933740 : else if (DEBUG_BIND_INSN_P (insn)
7141 : 183933740 : && !TREE_VISITED (INSN_VAR_LOCATION_DECL (insn)))
7142 : : {
7143 : 183927596 : later_debug_set_vars.safe_push (INSN_VAR_LOCATION_DECL (insn));
7144 : 183927596 : TREE_VISITED (INSN_VAR_LOCATION_DECL (insn)) = 1;
7145 : : }
7146 : : }
7147 : : }
7148 : :
7149 : 6128951 : if (MAY_HAVE_DEBUG_BIND_INSNS)
7150 : : {
7151 : 529063429 : for (insn = get_last_insn (); insn; insn = PREV_INSN (insn))
7152 : 526514200 : if (DEBUG_BIND_INSN_P (insn))
7153 : : {
7154 : : /* If this debug insn references a dead register that wasn't replaced
7155 : : with an DEBUG_EXPR, reset the DEBUG_INSN. */
7156 : 183950002 : bool seen_repl = false;
7157 : 183950002 : if (is_dead_debug_insn (INSN_VAR_LOCATION_LOC (insn),
7158 : : counts, replacements, &seen_repl))
7159 : : {
7160 : 26049 : INSN_VAR_LOCATION_LOC (insn) = gen_rtx_UNKNOWN_VAR_LOC ();
7161 : 26049 : df_insn_rescan (insn);
7162 : : }
7163 : 183923953 : else if (seen_repl)
7164 : : {
7165 : 23485 : INSN_VAR_LOCATION_LOC (insn)
7166 : 23485 : = simplify_replace_fn_rtx (INSN_VAR_LOCATION_LOC (insn),
7167 : : NULL_RTX, replace_dead_reg,
7168 : : replacements);
7169 : 23485 : df_insn_rescan (insn);
7170 : : }
7171 : : }
7172 : 2549229 : free (replacements);
7173 : : }
7174 : :
7175 : 6128951 : if (dump_file && ndead)
7176 : 24 : fprintf (dump_file, "Deleted %i trivially dead insns\n",
7177 : : ndead);
7178 : : /* Clean up. */
7179 : 6128951 : free (counts);
7180 : 6128951 : timevar_pop (TV_DELETE_TRIVIALLY_DEAD);
7181 : 6128951 : return ndead;
7182 : 6128951 : }
7183 : :
7184 : : /* If LOC contains references to NEWREG in a different mode, change them
7185 : : to use NEWREG instead. */
7186 : :
7187 : : static void
7188 : 53974 : cse_change_cc_mode (subrtx_ptr_iterator::array_type &array,
7189 : : rtx *loc, rtx_insn *insn, rtx newreg)
7190 : : {
7191 : 318058 : FOR_EACH_SUBRTX_PTR (iter, array, loc, NONCONST)
7192 : : {
7193 : 264084 : rtx *loc = *iter;
7194 : 264084 : rtx x = *loc;
7195 : 264084 : if (x
7196 : 237097 : && REG_P (x)
7197 : 57530 : && REGNO (x) == REGNO (newreg)
7198 : 307537 : && GET_MODE (x) != GET_MODE (newreg))
7199 : : {
7200 : 43453 : validate_change (insn, loc, newreg, 1);
7201 : 43453 : iter.skip_subrtxes ();
7202 : : }
7203 : : }
7204 : 53974 : }
7205 : :
7206 : : /* Change the mode of any reference to the register REGNO (NEWREG) to
7207 : : GET_MODE (NEWREG) in INSN. */
7208 : :
7209 : : static void
7210 : 26987 : cse_change_cc_mode_insn (rtx_insn *insn, rtx newreg)
7211 : : {
7212 : 26987 : int success;
7213 : :
7214 : 26987 : if (!INSN_P (insn))
7215 : 0 : return;
7216 : :
7217 : 26987 : subrtx_ptr_iterator::array_type array;
7218 : 26987 : cse_change_cc_mode (array, &PATTERN (insn), insn, newreg);
7219 : 26987 : cse_change_cc_mode (array, ®_NOTES (insn), insn, newreg);
7220 : :
7221 : : /* If the following assertion was triggered, there is most probably
7222 : : something wrong with the cc_modes_compatible back end function.
7223 : : CC modes only can be considered compatible if the insn - with the mode
7224 : : replaced by any of the compatible modes - can still be recognized. */
7225 : 26987 : success = apply_change_group ();
7226 : 26987 : gcc_assert (success);
7227 : 26987 : }
7228 : :
7229 : : /* Change the mode of any reference to the register REGNO (NEWREG) to
7230 : : GET_MODE (NEWREG), starting at START. Stop before END. Stop at
7231 : : any instruction which modifies NEWREG. */
7232 : :
7233 : : static void
7234 : 16818 : cse_change_cc_mode_insns (rtx_insn *start, rtx_insn *end, rtx newreg)
7235 : : {
7236 : 16818 : rtx_insn *insn;
7237 : :
7238 : 34157 : for (insn = start; insn != end; insn = NEXT_INSN (insn))
7239 : : {
7240 : 17770 : if (! INSN_P (insn))
7241 : 0 : continue;
7242 : :
7243 : 17770 : if (reg_set_p (newreg, insn))
7244 : : return;
7245 : :
7246 : 17339 : cse_change_cc_mode_insn (insn, newreg);
7247 : : }
7248 : : }
7249 : :
7250 : : /* BB is a basic block which finishes with CC_REG as a condition code
7251 : : register which is set to CC_SRC. Look through the successors of BB
7252 : : to find blocks which have a single predecessor (i.e., this one),
7253 : : and look through those blocks for an assignment to CC_REG which is
7254 : : equivalent to CC_SRC. CAN_CHANGE_MODE indicates whether we are
7255 : : permitted to change the mode of CC_SRC to a compatible mode. This
7256 : : returns VOIDmode if no equivalent assignments were found.
7257 : : Otherwise it returns the mode which CC_SRC should wind up with.
7258 : : ORIG_BB should be the same as BB in the outermost cse_cc_succs call,
7259 : : but is passed unmodified down to recursive calls in order to prevent
7260 : : endless recursion.
7261 : :
7262 : : The main complexity in this function is handling the mode issues.
7263 : : We may have more than one duplicate which we can eliminate, and we
7264 : : try to find a mode which will work for multiple duplicates. */
7265 : :
7266 : : static machine_mode
7267 : 5124991 : cse_cc_succs (basic_block bb, basic_block orig_bb, rtx cc_reg, rtx cc_src,
7268 : : bool can_change_mode)
7269 : : {
7270 : 5124991 : bool found_equiv;
7271 : 5124991 : machine_mode mode;
7272 : 5124991 : unsigned int insn_count;
7273 : 5124991 : edge e;
7274 : 5124991 : rtx_insn *insns[2];
7275 : 5124991 : machine_mode modes[2];
7276 : 5124991 : rtx_insn *last_insns[2];
7277 : 5124991 : unsigned int i;
7278 : 5124991 : rtx newreg;
7279 : 5124991 : edge_iterator ei;
7280 : :
7281 : : /* We expect to have two successors. Look at both before picking
7282 : : the final mode for the comparison. If we have more successors
7283 : : (i.e., some sort of table jump, although that seems unlikely),
7284 : : then we require all beyond the first two to use the same
7285 : : mode. */
7286 : :
7287 : 5124991 : found_equiv = false;
7288 : 5124991 : mode = GET_MODE (cc_src);
7289 : 5124991 : insn_count = 0;
7290 : 14470102 : FOR_EACH_EDGE (e, ei, bb->succs)
7291 : : {
7292 : 9345111 : rtx_insn *insn;
7293 : 9345111 : rtx_insn *end;
7294 : :
7295 : 9345111 : if (e->flags & EDGE_COMPLEX)
7296 : 33635 : continue;
7297 : :
7298 : 9311476 : if (EDGE_COUNT (e->dest->preds) != 1
7299 : 5196974 : || e->dest == EXIT_BLOCK_PTR_FOR_FN (cfun)
7300 : : /* Avoid endless recursion on unreachable blocks. */
7301 : 14415817 : || e->dest == orig_bb)
7302 : 4207135 : continue;
7303 : :
7304 : 5104341 : end = NEXT_INSN (BB_END (e->dest));
7305 : 29665739 : for (insn = BB_HEAD (e->dest); insn != end; insn = NEXT_INSN (insn))
7306 : : {
7307 : 28572914 : rtx set;
7308 : :
7309 : 28572914 : if (! INSN_P (insn))
7310 : 6948784 : continue;
7311 : :
7312 : : /* If CC_SRC is modified, we have to stop looking for
7313 : : something which uses it. */
7314 : 21624130 : if (modified_in_p (cc_src, insn))
7315 : : break;
7316 : :
7317 : : /* Check whether INSN sets CC_REG to CC_SRC. */
7318 : 21168919 : set = single_set (insn);
7319 : 21168919 : if (set
7320 : 10248004 : && REG_P (SET_DEST (set))
7321 : 30149538 : && REGNO (SET_DEST (set)) == REGNO (cc_reg))
7322 : : {
7323 : 1233954 : bool found;
7324 : 1233954 : machine_mode set_mode;
7325 : 1233954 : machine_mode comp_mode;
7326 : :
7327 : 1233954 : found = false;
7328 : 1233954 : set_mode = GET_MODE (SET_SRC (set));
7329 : 1233954 : comp_mode = set_mode;
7330 : 1233954 : if (rtx_equal_p (cc_src, SET_SRC (set)))
7331 : : found = true;
7332 : 1227662 : else if (GET_CODE (cc_src) == COMPARE
7333 : 1159084 : && GET_CODE (SET_SRC (set)) == COMPARE
7334 : 1110529 : && mode != set_mode
7335 : 318606 : && rtx_equal_p (XEXP (cc_src, 0),
7336 : 318606 : XEXP (SET_SRC (set), 0))
7337 : 1278941 : && rtx_equal_p (XEXP (cc_src, 1),
7338 : 51279 : XEXP (SET_SRC (set), 1)))
7339 : :
7340 : : {
7341 : 16822 : comp_mode = targetm.cc_modes_compatible (mode, set_mode);
7342 : 16822 : if (comp_mode != VOIDmode
7343 : 16822 : && (can_change_mode || comp_mode == mode))
7344 : : found = true;
7345 : : }
7346 : :
7347 : 23110 : if (found)
7348 : : {
7349 : 23110 : found_equiv = true;
7350 : 23110 : if (insn_count < ARRAY_SIZE (insns))
7351 : : {
7352 : 23110 : insns[insn_count] = insn;
7353 : 23110 : modes[insn_count] = set_mode;
7354 : 23110 : last_insns[insn_count] = end;
7355 : 23110 : ++insn_count;
7356 : :
7357 : 23110 : if (mode != comp_mode)
7358 : : {
7359 : 9648 : gcc_assert (can_change_mode);
7360 : 9648 : mode = comp_mode;
7361 : :
7362 : : /* The modified insn will be re-recognized later. */
7363 : 9648 : PUT_MODE (cc_src, mode);
7364 : : }
7365 : : }
7366 : : else
7367 : : {
7368 : 0 : if (set_mode != mode)
7369 : : {
7370 : : /* We found a matching expression in the
7371 : : wrong mode, but we don't have room to
7372 : : store it in the array. Punt. This case
7373 : : should be rare. */
7374 : : break;
7375 : : }
7376 : : /* INSN sets CC_REG to a value equal to CC_SRC
7377 : : with the right mode. We can simply delete
7378 : : it. */
7379 : 0 : delete_insn (insn);
7380 : : }
7381 : :
7382 : : /* We found an instruction to delete. Keep looking,
7383 : : in the hopes of finding a three-way jump. */
7384 : 23110 : continue;
7385 : : }
7386 : :
7387 : : /* We found an instruction which sets the condition
7388 : : code, so don't look any farther. */
7389 : : break;
7390 : : }
7391 : :
7392 : : /* If INSN sets CC_REG in some other way, don't look any
7393 : : farther. */
7394 : 19934965 : if (reg_set_p (cc_reg, insn))
7395 : : break;
7396 : : }
7397 : :
7398 : : /* If we fell off the bottom of the block, we can keep looking
7399 : : through successors. We pass CAN_CHANGE_MODE as false because
7400 : : we aren't prepared to handle compatibility between the
7401 : : further blocks and this block. */
7402 : 5104341 : if (insn == end)
7403 : : {
7404 : 1092825 : machine_mode submode;
7405 : :
7406 : 1092825 : submode = cse_cc_succs (e->dest, orig_bb, cc_reg, cc_src, false);
7407 : 1092825 : if (submode != VOIDmode)
7408 : : {
7409 : 2 : gcc_assert (submode == mode);
7410 : : found_equiv = true;
7411 : : can_change_mode = false;
7412 : : }
7413 : : }
7414 : : }
7415 : :
7416 : 5124991 : if (! found_equiv)
7417 : : return VOIDmode;
7418 : :
7419 : : /* Now INSN_COUNT is the number of instructions we found which set
7420 : : CC_REG to a value equivalent to CC_SRC. The instructions are in
7421 : : INSNS. The modes used by those instructions are in MODES. */
7422 : :
7423 : : newreg = NULL_RTX;
7424 : 46222 : for (i = 0; i < insn_count; ++i)
7425 : : {
7426 : 23110 : if (modes[i] != mode)
7427 : : {
7428 : : /* We need to change the mode of CC_REG in INSNS[i] and
7429 : : subsequent instructions. */
7430 : 7170 : if (! newreg)
7431 : : {
7432 : 7170 : if (GET_MODE (cc_reg) == mode)
7433 : : newreg = cc_reg;
7434 : : else
7435 : 6094 : newreg = gen_rtx_REG (mode, REGNO (cc_reg));
7436 : : }
7437 : 7170 : cse_change_cc_mode_insns (NEXT_INSN (insns[i]), last_insns[i],
7438 : : newreg);
7439 : : }
7440 : :
7441 : 23110 : cse_cfg_altered |= delete_insn_and_edges (insns[i]);
7442 : : }
7443 : :
7444 : : return mode;
7445 : : }
7446 : :
7447 : : /* If we have a fixed condition code register (or two), walk through
7448 : : the instructions and try to eliminate duplicate assignments. */
7449 : :
7450 : : static void
7451 : 924761 : cse_condition_code_reg (void)
7452 : : {
7453 : 924761 : unsigned int cc_regno_1;
7454 : 924761 : unsigned int cc_regno_2;
7455 : 924761 : rtx cc_reg_1;
7456 : 924761 : rtx cc_reg_2;
7457 : 924761 : basic_block bb;
7458 : :
7459 : 924761 : if (! targetm.fixed_condition_code_regs (&cc_regno_1, &cc_regno_2))
7460 : 0 : return;
7461 : :
7462 : 924761 : cc_reg_1 = gen_rtx_REG (CCmode, cc_regno_1);
7463 : 924761 : if (cc_regno_2 != INVALID_REGNUM)
7464 : 0 : cc_reg_2 = gen_rtx_REG (CCmode, cc_regno_2);
7465 : : else
7466 : : cc_reg_2 = NULL_RTX;
7467 : :
7468 : 10025452 : FOR_EACH_BB_FN (bb, cfun)
7469 : : {
7470 : 9100691 : rtx_insn *last_insn;
7471 : 9100691 : rtx cc_reg;
7472 : 9100691 : rtx_insn *insn;
7473 : 9100691 : rtx_insn *cc_src_insn;
7474 : 9100691 : rtx cc_src;
7475 : 9100691 : machine_mode mode;
7476 : 9100691 : machine_mode orig_mode;
7477 : :
7478 : : /* Look for blocks which end with a conditional jump based on a
7479 : : condition code register. Then look for the instruction which
7480 : : sets the condition code register. Then look through the
7481 : : successor blocks for instructions which set the condition
7482 : : code register to the same value. There are other possible
7483 : : uses of the condition code register, but these are by far the
7484 : : most common and the ones which we are most likely to be able
7485 : : to optimize. */
7486 : :
7487 : 9100691 : last_insn = BB_END (bb);
7488 : 9100691 : if (!JUMP_P (last_insn))
7489 : 4923796 : continue;
7490 : :
7491 : 4176895 : if (reg_referenced_p (cc_reg_1, PATTERN (last_insn)))
7492 : : cc_reg = cc_reg_1;
7493 : 14306 : else if (cc_reg_2 && reg_referenced_p (cc_reg_2, PATTERN (last_insn)))
7494 : : cc_reg = cc_reg_2;
7495 : : else
7496 : 14306 : continue;
7497 : :
7498 : 4162589 : cc_src_insn = NULL;
7499 : 4162589 : cc_src = NULL_RTX;
7500 : 4311888 : for (insn = PREV_INSN (last_insn);
7501 : 4311888 : insn && insn != PREV_INSN (BB_HEAD (bb));
7502 : 149299 : insn = PREV_INSN (insn))
7503 : : {
7504 : 4198615 : rtx set;
7505 : :
7506 : 4198615 : if (! INSN_P (insn))
7507 : 120535 : continue;
7508 : 4078080 : set = single_set (insn);
7509 : 4078080 : if (set
7510 : 4039126 : && REG_P (SET_DEST (set))
7511 : 8116370 : && REGNO (SET_DEST (set)) == REGNO (cc_reg))
7512 : : {
7513 : 4032187 : cc_src_insn = insn;
7514 : 4032187 : cc_src = SET_SRC (set);
7515 : 4032187 : break;
7516 : : }
7517 : 45893 : else if (reg_set_p (cc_reg, insn))
7518 : : break;
7519 : : }
7520 : :
7521 : 4162589 : if (! cc_src_insn)
7522 : 130402 : continue;
7523 : :
7524 : 4032187 : if (modified_between_p (cc_src, cc_src_insn, NEXT_INSN (last_insn)))
7525 : 21 : continue;
7526 : :
7527 : : /* Now CC_REG is a condition code register used for a
7528 : : conditional jump at the end of the block, and CC_SRC, in
7529 : : CC_SRC_INSN, is the value to which that condition code
7530 : : register is set, and CC_SRC is still meaningful at the end of
7531 : : the basic block. */
7532 : :
7533 : 4032166 : orig_mode = GET_MODE (cc_src);
7534 : 4032166 : mode = cse_cc_succs (bb, bb, cc_reg, cc_src, true);
7535 : 4032166 : if (mode != VOIDmode)
7536 : : {
7537 : 23110 : gcc_assert (mode == GET_MODE (cc_src));
7538 : 23110 : if (mode != orig_mode)
7539 : : {
7540 : 9648 : rtx newreg = gen_rtx_REG (mode, REGNO (cc_reg));
7541 : :
7542 : 9648 : cse_change_cc_mode_insn (cc_src_insn, newreg);
7543 : :
7544 : : /* Do the same in the following insns that use the
7545 : : current value of CC_REG within BB. */
7546 : 9648 : cse_change_cc_mode_insns (NEXT_INSN (cc_src_insn),
7547 : : NEXT_INSN (last_insn),
7548 : : newreg);
7549 : : }
7550 : : }
7551 : : }
7552 : : }
7553 : :
7554 : :
7555 : : /* Perform common subexpression elimination. Nonzero value from
7556 : : `cse_main' means that jumps were simplified and some code may now
7557 : : be unreachable, so do jump optimization again. */
7558 : : static unsigned int
7559 : 999232 : rest_of_handle_cse (void)
7560 : : {
7561 : 999232 : int tem;
7562 : :
7563 : 999232 : if (dump_file)
7564 : 32 : dump_flow_info (dump_file, dump_flags);
7565 : :
7566 : 999232 : tem = cse_main (get_insns (), max_reg_num ());
7567 : :
7568 : : /* If we are not running more CSE passes, then we are no longer
7569 : : expecting CSE to be run. But always rerun it in a cheap mode. */
7570 : 999232 : cse_not_expected = !flag_rerun_cse_after_loop && !flag_gcse;
7571 : :
7572 : 999232 : if (tem == 2)
7573 : : {
7574 : 5139 : timevar_push (TV_JUMP);
7575 : 5139 : rebuild_jump_labels (get_insns ());
7576 : 5139 : cse_cfg_altered |= cleanup_cfg (CLEANUP_CFG_CHANGED);
7577 : 5139 : timevar_pop (TV_JUMP);
7578 : : }
7579 : 994093 : else if (tem == 1 || optimize > 1)
7580 : 919951 : cse_cfg_altered |= cleanup_cfg (0);
7581 : :
7582 : 999232 : return 0;
7583 : : }
7584 : :
7585 : : namespace {
7586 : :
7587 : : const pass_data pass_data_cse =
7588 : : {
7589 : : RTL_PASS, /* type */
7590 : : "cse1", /* name */
7591 : : OPTGROUP_NONE, /* optinfo_flags */
7592 : : TV_CSE, /* tv_id */
7593 : : 0, /* properties_required */
7594 : : 0, /* properties_provided */
7595 : : 0, /* properties_destroyed */
7596 : : 0, /* todo_flags_start */
7597 : : TODO_df_finish, /* todo_flags_finish */
7598 : : };
7599 : :
7600 : : class pass_cse : public rtl_opt_pass
7601 : : {
7602 : : public:
7603 : 279404 : pass_cse (gcc::context *ctxt)
7604 : 558808 : : rtl_opt_pass (pass_data_cse, ctxt)
7605 : : {}
7606 : :
7607 : : /* opt_pass methods: */
7608 : 1427379 : bool gate (function *) final override { return optimize > 0; }
7609 : 999232 : unsigned int execute (function *) final override
7610 : : {
7611 : 999232 : return rest_of_handle_cse ();
7612 : : }
7613 : :
7614 : : }; // class pass_cse
7615 : :
7616 : : } // anon namespace
7617 : :
7618 : : rtl_opt_pass *
7619 : 279404 : make_pass_cse (gcc::context *ctxt)
7620 : : {
7621 : 279404 : return new pass_cse (ctxt);
7622 : : }
7623 : :
7624 : :
7625 : : /* Run second CSE pass after loop optimizations. */
7626 : : static unsigned int
7627 : 924761 : rest_of_handle_cse2 (void)
7628 : : {
7629 : 924761 : int tem;
7630 : :
7631 : 924761 : if (dump_file)
7632 : 22 : dump_flow_info (dump_file, dump_flags);
7633 : :
7634 : 924761 : tem = cse_main (get_insns (), max_reg_num ());
7635 : :
7636 : : /* Run a pass to eliminate duplicated assignments to condition code
7637 : : registers. We have to run this after bypass_jumps, because it
7638 : : makes it harder for that pass to determine whether a jump can be
7639 : : bypassed safely. */
7640 : 924761 : cse_condition_code_reg ();
7641 : :
7642 : 924761 : delete_trivially_dead_insns (get_insns (), max_reg_num ());
7643 : :
7644 : 924761 : if (tem == 2)
7645 : : {
7646 : 2215 : timevar_push (TV_JUMP);
7647 : 2215 : rebuild_jump_labels (get_insns ());
7648 : 2215 : cse_cfg_altered |= cleanup_cfg (CLEANUP_CFG_CHANGED);
7649 : 2215 : timevar_pop (TV_JUMP);
7650 : : }
7651 : 922546 : else if (tem == 1 || cse_cfg_altered)
7652 : 117 : cse_cfg_altered |= cleanup_cfg (0);
7653 : :
7654 : 924761 : cse_not_expected = 1;
7655 : 924761 : return 0;
7656 : : }
7657 : :
7658 : :
7659 : : namespace {
7660 : :
7661 : : const pass_data pass_data_cse2 =
7662 : : {
7663 : : RTL_PASS, /* type */
7664 : : "cse2", /* name */
7665 : : OPTGROUP_NONE, /* optinfo_flags */
7666 : : TV_CSE2, /* tv_id */
7667 : : 0, /* properties_required */
7668 : : 0, /* properties_provided */
7669 : : 0, /* properties_destroyed */
7670 : : 0, /* todo_flags_start */
7671 : : TODO_df_finish, /* todo_flags_finish */
7672 : : };
7673 : :
7674 : : class pass_cse2 : public rtl_opt_pass
7675 : : {
7676 : : public:
7677 : 279404 : pass_cse2 (gcc::context *ctxt)
7678 : 558808 : : rtl_opt_pass (pass_data_cse2, ctxt)
7679 : : {}
7680 : :
7681 : : /* opt_pass methods: */
7682 : 1427379 : bool gate (function *) final override
7683 : : {
7684 : 1427379 : return optimize > 0 && flag_rerun_cse_after_loop;
7685 : : }
7686 : :
7687 : 924761 : unsigned int execute (function *) final override
7688 : : {
7689 : 924761 : return rest_of_handle_cse2 ();
7690 : : }
7691 : :
7692 : : }; // class pass_cse2
7693 : :
7694 : : } // anon namespace
7695 : :
7696 : : rtl_opt_pass *
7697 : 279404 : make_pass_cse2 (gcc::context *ctxt)
7698 : : {
7699 : 279404 : return new pass_cse2 (ctxt);
7700 : : }
7701 : :
7702 : : /* Run second CSE pass after loop optimizations. */
7703 : : static unsigned int
7704 : 277048 : rest_of_handle_cse_after_global_opts (void)
7705 : : {
7706 : 277048 : int save_cfj;
7707 : 277048 : int tem;
7708 : :
7709 : : /* We only want to do local CSE, so don't follow jumps. */
7710 : 277048 : save_cfj = flag_cse_follow_jumps;
7711 : 277048 : flag_cse_follow_jumps = 0;
7712 : :
7713 : 277048 : rebuild_jump_labels (get_insns ());
7714 : 277048 : tem = cse_main (get_insns (), max_reg_num ());
7715 : 277048 : cse_cfg_altered |= purge_all_dead_edges ();
7716 : 277048 : delete_trivially_dead_insns (get_insns (), max_reg_num ());
7717 : :
7718 : 277048 : cse_not_expected = !flag_rerun_cse_after_loop;
7719 : :
7720 : : /* If cse altered any jumps, rerun jump opts to clean things up. */
7721 : 277048 : if (tem == 2)
7722 : : {
7723 : 239 : timevar_push (TV_JUMP);
7724 : 239 : rebuild_jump_labels (get_insns ());
7725 : 239 : cse_cfg_altered |= cleanup_cfg (CLEANUP_CFG_CHANGED);
7726 : 239 : timevar_pop (TV_JUMP);
7727 : : }
7728 : 276809 : else if (tem == 1 || cse_cfg_altered)
7729 : 4956 : cse_cfg_altered |= cleanup_cfg (0);
7730 : :
7731 : 277048 : flag_cse_follow_jumps = save_cfj;
7732 : 277048 : return 0;
7733 : : }
7734 : :
7735 : : namespace {
7736 : :
7737 : : const pass_data pass_data_cse_after_global_opts =
7738 : : {
7739 : : RTL_PASS, /* type */
7740 : : "cse_local", /* name */
7741 : : OPTGROUP_NONE, /* optinfo_flags */
7742 : : TV_CSE, /* tv_id */
7743 : : 0, /* properties_required */
7744 : : 0, /* properties_provided */
7745 : : 0, /* properties_destroyed */
7746 : : 0, /* todo_flags_start */
7747 : : TODO_df_finish, /* todo_flags_finish */
7748 : : };
7749 : :
7750 : : class pass_cse_after_global_opts : public rtl_opt_pass
7751 : : {
7752 : : public:
7753 : 279404 : pass_cse_after_global_opts (gcc::context *ctxt)
7754 : 558808 : : rtl_opt_pass (pass_data_cse_after_global_opts, ctxt)
7755 : : {}
7756 : :
7757 : : /* opt_pass methods: */
7758 : 1427379 : bool gate (function *) final override
7759 : : {
7760 : 1427379 : return optimize > 0 && flag_rerun_cse_after_global_opts;
7761 : : }
7762 : :
7763 : 277048 : unsigned int execute (function *) final override
7764 : : {
7765 : 277048 : return rest_of_handle_cse_after_global_opts ();
7766 : : }
7767 : :
7768 : : }; // class pass_cse_after_global_opts
7769 : :
7770 : : } // anon namespace
7771 : :
7772 : : rtl_opt_pass *
7773 : 279404 : make_pass_cse_after_global_opts (gcc::context *ctxt)
7774 : : {
7775 : 279404 : return new pass_cse_after_global_opts (ctxt);
7776 : : }
|
