1 /* Perform simple optimizations to clean up the result of reload.
2 Copyright (C) 1987-2020 Free Software Foundation, Inc.
4 This file is part of GCC.
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
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
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/>. */
22 #include "coretypes.h"
38 #include "cfgcleanup.h"
41 #include "tree-pass.h"
43 #include "function-abi.h"
46 static int reload_cse_noop_set_p (rtx
);
47 static bool reload_cse_simplify (rtx_insn
*, rtx
);
48 static void reload_cse_regs_1 (void);
49 static int reload_cse_simplify_set (rtx
, rtx_insn
*);
50 static int reload_cse_simplify_operands (rtx_insn
*, rtx
);
52 static void reload_combine (void);
53 static void reload_combine_note_use (rtx
*, rtx_insn
*, int, rtx
);
54 static void reload_combine_note_store (rtx
, const_rtx
, void *);
56 static bool reload_cse_move2add (rtx_insn
*);
57 static void move2add_note_store (rtx
, const_rtx
, void *);
59 /* Call cse / combine like post-reload optimization phases.
60 FIRST is the first instruction. */
63 reload_cse_regs (rtx_insn
*first ATTRIBUTE_UNUSED
)
68 moves_converted
= reload_cse_move2add (first
);
69 if (flag_expensive_optimizations
)
77 /* See whether a single set SET is a noop. */
79 reload_cse_noop_set_p (rtx set
)
81 if (cselib_reg_set_mode (SET_DEST (set
)) != GET_MODE (SET_DEST (set
)))
84 return rtx_equal_for_cselib_p (SET_DEST (set
), SET_SRC (set
));
87 /* Try to simplify INSN. Return true if the CFG may have changed. */
89 reload_cse_simplify (rtx_insn
*insn
, rtx testreg
)
91 rtx body
= PATTERN (insn
);
92 basic_block insn_bb
= BLOCK_FOR_INSN (insn
);
93 unsigned insn_bb_succs
= EDGE_COUNT (insn_bb
->succs
);
95 /* If NO_FUNCTION_CSE has been set by the target, then we should not try
96 to cse function calls. */
97 if (NO_FUNCTION_CSE
&& CALL_P (insn
))
100 /* Remember if this insn has been sp += const_int. */
101 rtx sp_set
= set_for_reg_notes (insn
);
102 rtx sp_addend
= NULL_RTX
;
104 && SET_DEST (sp_set
) == stack_pointer_rtx
105 && GET_CODE (SET_SRC (sp_set
)) == PLUS
106 && XEXP (SET_SRC (sp_set
), 0) == stack_pointer_rtx
107 && CONST_INT_P (XEXP (SET_SRC (sp_set
), 1)))
108 sp_addend
= XEXP (SET_SRC (sp_set
), 1);
110 if (GET_CODE (body
) == SET
)
114 /* Simplify even if we may think it is a no-op.
115 We may think a memory load of a value smaller than WORD_SIZE
116 is redundant because we haven't taken into account possible
117 implicit extension. reload_cse_simplify_set() will bring
118 this out, so it's safer to simplify before we delete. */
119 count
+= reload_cse_simplify_set (body
, insn
);
121 if (!count
&& reload_cse_noop_set_p (body
))
123 if (check_for_inc_dec (insn
))
124 delete_insn_and_edges (insn
);
125 /* We're done with this insn. */
130 apply_change_group ();
132 reload_cse_simplify_operands (insn
, testreg
);
134 else if (GET_CODE (body
) == PARALLEL
)
138 rtx value
= NULL_RTX
;
140 /* Registers mentioned in the clobber list for an asm cannot be reused
141 within the body of the asm. Invalidate those registers now so that
142 we don't try to substitute values for them. */
143 if (asm_noperands (body
) >= 0)
145 for (i
= XVECLEN (body
, 0) - 1; i
>= 0; --i
)
147 rtx part
= XVECEXP (body
, 0, i
);
148 if (GET_CODE (part
) == CLOBBER
&& REG_P (XEXP (part
, 0)))
149 cselib_invalidate_rtx (XEXP (part
, 0));
153 /* If every action in a PARALLEL is a noop, we can delete
154 the entire PARALLEL. */
155 for (i
= XVECLEN (body
, 0) - 1; i
>= 0; --i
)
157 rtx part
= XVECEXP (body
, 0, i
);
158 if (GET_CODE (part
) == SET
)
160 if (! reload_cse_noop_set_p (part
))
162 if (REG_P (SET_DEST (part
))
163 && REG_FUNCTION_VALUE_P (SET_DEST (part
)))
167 value
= SET_DEST (part
);
170 else if (GET_CODE (part
) != CLOBBER
&& GET_CODE (part
) != USE
)
176 if (check_for_inc_dec (insn
))
177 delete_insn_and_edges (insn
);
178 /* We're done with this insn. */
182 /* It's not a no-op, but we can try to simplify it. */
183 for (i
= XVECLEN (body
, 0) - 1; i
>= 0; --i
)
184 if (GET_CODE (XVECEXP (body
, 0, i
)) == SET
)
185 count
+= reload_cse_simplify_set (XVECEXP (body
, 0, i
), insn
);
188 apply_change_group ();
190 reload_cse_simplify_operands (insn
, testreg
);
193 /* If sp += const_int insn is changed into sp = reg;, add REG_EQUAL
194 note so that the stack_adjustments pass can undo it if beneficial. */
196 && SET_DEST (sp_set
) == stack_pointer_rtx
197 && REG_P (SET_SRC (sp_set
)))
198 set_dst_reg_note (insn
, REG_EQUAL
,
199 gen_rtx_PLUS (Pmode
, stack_pointer_rtx
,
200 sp_addend
), stack_pointer_rtx
);
203 return (EDGE_COUNT (insn_bb
->succs
) != insn_bb_succs
);
206 /* Do a very simple CSE pass over the hard registers.
208 This function detects no-op moves where we happened to assign two
209 different pseudo-registers to the same hard register, and then
210 copied one to the other. Reload will generate a useless
211 instruction copying a register to itself.
213 This function also detects cases where we load a value from memory
214 into two different registers, and (if memory is more expensive than
215 registers) changes it to simply copy the first register into the
218 Another optimization is performed that scans the operands of each
219 instruction to see whether the value is already available in a
220 hard register. It then replaces the operand with the hard register
221 if possible, much like an optional reload would. */
224 reload_cse_regs_1 (void)
226 bool cfg_changed
= false;
229 rtx testreg
= gen_rtx_REG (word_mode
, LAST_VIRTUAL_REGISTER
+ 1);
231 cselib_init (CSELIB_RECORD_MEMORY
);
232 init_alias_analysis ();
234 FOR_EACH_BB_FN (bb
, cfun
)
235 FOR_BB_INSNS (bb
, insn
)
238 cfg_changed
|= reload_cse_simplify (insn
, testreg
);
240 cselib_process_insn (insn
);
244 end_alias_analysis ();
250 /* Try to simplify a single SET instruction. SET is the set pattern.
251 INSN is the instruction it came from.
252 This function only handles one case: if we set a register to a value
253 which is not a register, we try to find that value in some other register
254 and change the set into a register copy. */
257 reload_cse_simplify_set (rtx set
, rtx_insn
*insn
)
265 struct elt_loc_list
*l
;
266 enum rtx_code extend_op
= UNKNOWN
;
267 bool speed
= optimize_bb_for_speed_p (BLOCK_FOR_INSN (insn
));
269 dreg
= true_regnum (SET_DEST (set
));
274 if (side_effects_p (src
) || true_regnum (src
) >= 0)
277 dclass
= REGNO_REG_CLASS (dreg
);
279 /* When replacing a memory with a register, we need to honor assumptions
280 that combine made wrt the contents of sign bits. We'll do this by
281 generating an extend instruction instead of a reg->reg copy. Thus
282 the destination must be a register that we can widen. */
284 && (extend_op
= load_extend_op (GET_MODE (src
))) != UNKNOWN
285 && !REG_P (SET_DEST (set
)))
288 val
= cselib_lookup (src
, GET_MODE (SET_DEST (set
)), 0, VOIDmode
);
292 /* If memory loads are cheaper than register copies, don't change them. */
294 old_cost
= memory_move_cost (GET_MODE (src
), dclass
, true);
295 else if (REG_P (src
))
296 old_cost
= register_move_cost (GET_MODE (src
),
297 REGNO_REG_CLASS (REGNO (src
)), dclass
);
299 old_cost
= set_src_cost (src
, GET_MODE (SET_DEST (set
)), speed
);
301 for (l
= val
->locs
; l
; l
= l
->next
)
303 rtx this_rtx
= l
->loc
;
306 if (CONSTANT_P (this_rtx
) && ! references_value_p (this_rtx
, 0))
308 if (extend_op
!= UNKNOWN
)
312 if (!CONST_SCALAR_INT_P (this_rtx
))
318 result
= wide_int::from (rtx_mode_t (this_rtx
,
320 BITS_PER_WORD
, UNSIGNED
);
323 result
= wide_int::from (rtx_mode_t (this_rtx
,
325 BITS_PER_WORD
, SIGNED
);
330 this_rtx
= immed_wide_int_const (result
, word_mode
);
333 this_cost
= set_src_cost (this_rtx
, GET_MODE (SET_DEST (set
)), speed
);
335 else if (REG_P (this_rtx
))
337 if (extend_op
!= UNKNOWN
)
339 this_rtx
= gen_rtx_fmt_e (extend_op
, word_mode
, this_rtx
);
340 this_cost
= set_src_cost (this_rtx
, word_mode
, speed
);
343 this_cost
= register_move_cost (GET_MODE (this_rtx
),
344 REGNO_REG_CLASS (REGNO (this_rtx
)),
350 /* If equal costs, prefer registers over anything else. That
351 tends to lead to smaller instructions on some machines. */
352 if (this_cost
< old_cost
353 || (this_cost
== old_cost
355 && !REG_P (SET_SRC (set
))))
357 if (extend_op
!= UNKNOWN
358 && REG_CAN_CHANGE_MODE_P (REGNO (SET_DEST (set
)),
359 GET_MODE (SET_DEST (set
)), word_mode
))
361 rtx wide_dest
= gen_rtx_REG (word_mode
, REGNO (SET_DEST (set
)));
362 ORIGINAL_REGNO (wide_dest
) = ORIGINAL_REGNO (SET_DEST (set
));
363 validate_change (insn
, &SET_DEST (set
), wide_dest
, 1);
366 validate_unshare_change (insn
, &SET_SRC (set
), this_rtx
, 1);
367 old_cost
= this_cost
, did_change
= 1;
374 /* Try to replace operands in INSN with equivalent values that are already
375 in registers. This can be viewed as optional reloading.
377 For each non-register operand in the insn, see if any hard regs are
378 known to be equivalent to that operand. Record the alternatives which
379 can accept these hard registers. Among all alternatives, select the
380 ones which are better or equal to the one currently matching, where
381 "better" is in terms of '?' and '!' constraints. Among the remaining
382 alternatives, select the one which replaces most operands with
386 reload_cse_simplify_operands (rtx_insn
*insn
, rtx testreg
)
390 /* For each operand, all registers that are equivalent to it. */
391 HARD_REG_SET equiv_regs
[MAX_RECOG_OPERANDS
];
393 const char *constraints
[MAX_RECOG_OPERANDS
];
395 /* Vector recording how bad an alternative is. */
396 int *alternative_reject
;
397 /* Vector recording how many registers can be introduced by choosing
399 int *alternative_nregs
;
400 /* Array of vectors recording, for each operand and each alternative,
401 which hard register to substitute, or -1 if the operand should be
403 int *op_alt_regno
[MAX_RECOG_OPERANDS
];
404 /* Array of alternatives, sorted in order of decreasing desirability. */
405 int *alternative_order
;
407 extract_constrain_insn (insn
);
409 if (recog_data
.n_alternatives
== 0 || recog_data
.n_operands
== 0)
412 alternative_reject
= XALLOCAVEC (int, recog_data
.n_alternatives
);
413 alternative_nregs
= XALLOCAVEC (int, recog_data
.n_alternatives
);
414 alternative_order
= XALLOCAVEC (int, recog_data
.n_alternatives
);
415 memset (alternative_reject
, 0, recog_data
.n_alternatives
* sizeof (int));
416 memset (alternative_nregs
, 0, recog_data
.n_alternatives
* sizeof (int));
418 /* For each operand, find out which regs are equivalent. */
419 for (i
= 0; i
< recog_data
.n_operands
; i
++)
422 struct elt_loc_list
*l
;
425 CLEAR_HARD_REG_SET (equiv_regs
[i
]);
427 /* cselib blows up on CODE_LABELs. Trying to fix that doesn't seem
428 right, so avoid the problem here. Similarly NOTE_INSN_DELETED_LABEL.
429 Likewise if we have a constant and the insn pattern doesn't tell us
431 if (LABEL_P (recog_data
.operand
[i
])
432 || (NOTE_P (recog_data
.operand
[i
])
433 && NOTE_KIND (recog_data
.operand
[i
]) == NOTE_INSN_DELETED_LABEL
)
434 || (CONSTANT_P (recog_data
.operand
[i
])
435 && recog_data
.operand_mode
[i
] == VOIDmode
))
438 op
= recog_data
.operand
[i
];
439 if (MEM_P (op
) && load_extend_op (GET_MODE (op
)) != UNKNOWN
)
441 rtx set
= single_set (insn
);
443 /* We might have multiple sets, some of which do implicit
444 extension. Punt on this for now. */
447 /* If the destination is also a MEM or a STRICT_LOW_PART, no
449 Also, if there is an explicit extension, we don't have to
450 worry about an implicit one. */
451 else if (MEM_P (SET_DEST (set
))
452 || GET_CODE (SET_DEST (set
)) == STRICT_LOW_PART
453 || GET_CODE (SET_SRC (set
)) == ZERO_EXTEND
454 || GET_CODE (SET_SRC (set
)) == SIGN_EXTEND
)
455 ; /* Continue ordinary processing. */
456 /* If the register cannot change mode to word_mode, it follows that
457 it cannot have been used in word_mode. */
458 else if (REG_P (SET_DEST (set
))
459 && !REG_CAN_CHANGE_MODE_P (REGNO (SET_DEST (set
)),
460 GET_MODE (SET_DEST (set
)),
462 ; /* Continue ordinary processing. */
463 /* If this is a straight load, make the extension explicit. */
464 else if (REG_P (SET_DEST (set
))
465 && recog_data
.n_operands
== 2
466 && SET_SRC (set
) == op
467 && SET_DEST (set
) == recog_data
.operand
[1-i
])
469 validate_change (insn
, recog_data
.operand_loc
[i
],
470 gen_rtx_fmt_e (load_extend_op (GET_MODE (op
)),
473 validate_change (insn
, recog_data
.operand_loc
[1-i
],
474 gen_rtx_REG (word_mode
, REGNO (SET_DEST (set
))),
476 if (! apply_change_group ())
478 return reload_cse_simplify_operands (insn
, testreg
);
481 /* ??? There might be arithmetic operations with memory that are
482 safe to optimize, but is it worth the trouble? */
486 if (side_effects_p (op
))
488 v
= cselib_lookup (op
, recog_data
.operand_mode
[i
], 0, VOIDmode
);
492 for (l
= v
->locs
; l
; l
= l
->next
)
494 SET_HARD_REG_BIT (equiv_regs
[i
], REGNO (l
->loc
));
497 alternative_mask preferred
= get_preferred_alternatives (insn
);
498 for (i
= 0; i
< recog_data
.n_operands
; i
++)
504 op_alt_regno
[i
] = XALLOCAVEC (int, recog_data
.n_alternatives
);
505 for (j
= 0; j
< recog_data
.n_alternatives
; j
++)
506 op_alt_regno
[i
][j
] = -1;
508 p
= constraints
[i
] = recog_data
.constraints
[i
];
509 mode
= recog_data
.operand_mode
[i
];
511 /* Add the reject values for each alternative given by the constraints
520 alternative_reject
[j
] += 3;
522 alternative_reject
[j
] += 300;
525 /* We won't change operands which are already registers. We
526 also don't want to modify output operands. */
527 regno
= true_regnum (recog_data
.operand
[i
]);
529 || constraints
[i
][0] == '='
530 || constraints
[i
][0] == '+')
533 for (regno
= 0; regno
< FIRST_PSEUDO_REGISTER
; regno
++)
535 enum reg_class rclass
= NO_REGS
;
537 if (! TEST_HARD_REG_BIT (equiv_regs
[i
], regno
))
540 set_mode_and_regno (testreg
, mode
, regno
);
542 /* We found a register equal to this operand. Now look for all
543 alternatives that can accept this register and have not been
544 assigned a register they can use yet. */
554 rclass
= reg_class_subunion
[rclass
][GENERAL_REGS
];
559 = (reg_class_subunion
561 [reg_class_for_constraint (lookup_constraint (p
))]);
565 /* See if REGNO fits this alternative, and set it up as the
566 replacement register if we don't have one for this
567 alternative yet and the operand being replaced is not
568 a cheap CONST_INT. */
569 if (op_alt_regno
[i
][j
] == -1
570 && TEST_BIT (preferred
, j
)
571 && reg_fits_class_p (testreg
, rclass
, 0, mode
)
572 && (!CONST_INT_P (recog_data
.operand
[i
])
573 || (set_src_cost (recog_data
.operand
[i
], mode
,
574 optimize_bb_for_speed_p
575 (BLOCK_FOR_INSN (insn
)))
576 > set_src_cost (testreg
, mode
,
577 optimize_bb_for_speed_p
578 (BLOCK_FOR_INSN (insn
))))))
580 alternative_nregs
[j
]++;
581 op_alt_regno
[i
][j
] = regno
;
587 p
+= CONSTRAINT_LEN (c
, p
);
595 /* Record all alternatives which are better or equal to the currently
596 matching one in the alternative_order array. */
597 for (i
= j
= 0; i
< recog_data
.n_alternatives
; i
++)
598 if (alternative_reject
[i
] <= alternative_reject
[which_alternative
])
599 alternative_order
[j
++] = i
;
600 recog_data
.n_alternatives
= j
;
602 /* Sort it. Given a small number of alternatives, a dumb algorithm
603 won't hurt too much. */
604 for (i
= 0; i
< recog_data
.n_alternatives
- 1; i
++)
607 int best_reject
= alternative_reject
[alternative_order
[i
]];
608 int best_nregs
= alternative_nregs
[alternative_order
[i
]];
610 for (j
= i
+ 1; j
< recog_data
.n_alternatives
; j
++)
612 int this_reject
= alternative_reject
[alternative_order
[j
]];
613 int this_nregs
= alternative_nregs
[alternative_order
[j
]];
615 if (this_reject
< best_reject
616 || (this_reject
== best_reject
&& this_nregs
> best_nregs
))
619 best_reject
= this_reject
;
620 best_nregs
= this_nregs
;
624 std::swap (alternative_order
[best
], alternative_order
[i
]);
627 /* Substitute the operands as determined by op_alt_regno for the best
629 j
= alternative_order
[0];
631 for (i
= 0; i
< recog_data
.n_operands
; i
++)
633 machine_mode mode
= recog_data
.operand_mode
[i
];
634 if (op_alt_regno
[i
][j
] == -1)
637 validate_change (insn
, recog_data
.operand_loc
[i
],
638 gen_rtx_REG (mode
, op_alt_regno
[i
][j
]), 1);
641 for (i
= recog_data
.n_dups
- 1; i
>= 0; i
--)
643 int op
= recog_data
.dup_num
[i
];
644 machine_mode mode
= recog_data
.operand_mode
[op
];
646 if (op_alt_regno
[op
][j
] == -1)
649 validate_change (insn
, recog_data
.dup_loc
[i
],
650 gen_rtx_REG (mode
, op_alt_regno
[op
][j
]), 1);
653 return apply_change_group ();
656 /* If reload couldn't use reg+reg+offset addressing, try to use reg+reg
658 This code might also be useful when reload gave up on reg+reg addressing
659 because of clashes between the return register and INDEX_REG_CLASS. */
661 /* The maximum number of uses of a register we can keep track of to
662 replace them with reg+reg addressing. */
663 #define RELOAD_COMBINE_MAX_USES 16
665 /* Describes a recorded use of a register. */
668 /* The insn where a register has been used. */
670 /* Points to the memory reference enclosing the use, if any, NULL_RTX
673 /* Location of the register within INSN. */
675 /* The reverse uid of the insn. */
679 /* If the register is used in some unknown fashion, USE_INDEX is negative.
680 If it is dead, USE_INDEX is RELOAD_COMBINE_MAX_USES, and STORE_RUID
681 indicates where it is first set or clobbered.
682 Otherwise, USE_INDEX is the index of the last encountered use of the
683 register (which is first among these we have seen since we scan backwards).
684 USE_RUID indicates the first encountered, i.e. last, of these uses.
685 If ALL_OFFSETS_MATCH is true, all encountered uses were inside a PLUS
686 with a constant offset; OFFSET contains this constant in that case.
687 STORE_RUID is always meaningful if we only want to use a value in a
688 register in a different place: it denotes the next insn in the insn
689 stream (i.e. the last encountered) that sets or clobbers the register.
690 REAL_STORE_RUID is similar, but clobbers are ignored when updating it.
691 EXPR is the expression used when storing the register. */
694 struct reg_use reg_use
[RELOAD_COMBINE_MAX_USES
];
700 bool all_offsets_match
;
702 } reg_state
[FIRST_PSEUDO_REGISTER
];
704 /* Reverse linear uid. This is increased in reload_combine while scanning
705 the instructions from last to first. It is used to set last_label_ruid
706 and the store_ruid / use_ruid fields in reg_state. */
707 static int reload_combine_ruid
;
709 /* The RUID of the last label we encountered in reload_combine. */
710 static int last_label_ruid
;
712 /* The RUID of the last jump we encountered in reload_combine. */
713 static int last_jump_ruid
;
715 /* The register numbers of the first and last index register. A value of
716 -1 in LAST_INDEX_REG indicates that we've previously computed these
717 values and found no suitable index registers. */
718 static int first_index_reg
= -1;
719 static int last_index_reg
;
721 #define LABEL_LIVE(LABEL) \
722 (label_live[CODE_LABEL_NUMBER (LABEL) - min_labelno])
724 /* Subroutine of reload_combine_split_ruids, called to fix up a single
725 ruid pointed to by *PRUID if it is higher than SPLIT_RUID. */
728 reload_combine_split_one_ruid (int *pruid
, int split_ruid
)
730 if (*pruid
> split_ruid
)
734 /* Called when we insert a new insn in a position we've already passed in
735 the scan. Examine all our state, increasing all ruids that are higher
736 than SPLIT_RUID by one in order to make room for a new insn. */
739 reload_combine_split_ruids (int split_ruid
)
743 reload_combine_split_one_ruid (&reload_combine_ruid
, split_ruid
);
744 reload_combine_split_one_ruid (&last_label_ruid
, split_ruid
);
745 reload_combine_split_one_ruid (&last_jump_ruid
, split_ruid
);
747 for (i
= 0; i
< FIRST_PSEUDO_REGISTER
; i
++)
749 int j
, idx
= reg_state
[i
].use_index
;
750 reload_combine_split_one_ruid (®_state
[i
].use_ruid
, split_ruid
);
751 reload_combine_split_one_ruid (®_state
[i
].store_ruid
, split_ruid
);
752 reload_combine_split_one_ruid (®_state
[i
].real_store_ruid
,
756 for (j
= idx
; j
< RELOAD_COMBINE_MAX_USES
; j
++)
758 reload_combine_split_one_ruid (®_state
[i
].reg_use
[j
].ruid
,
764 /* Called when we are about to rescan a previously encountered insn with
765 reload_combine_note_use after modifying some part of it. This clears all
766 information about uses in that particular insn. */
769 reload_combine_purge_insn_uses (rtx_insn
*insn
)
773 for (i
= 0; i
< FIRST_PSEUDO_REGISTER
; i
++)
775 int j
, k
, idx
= reg_state
[i
].use_index
;
778 j
= k
= RELOAD_COMBINE_MAX_USES
;
781 if (reg_state
[i
].reg_use
[j
].insn
!= insn
)
785 reg_state
[i
].reg_use
[k
] = reg_state
[i
].reg_use
[j
];
788 reg_state
[i
].use_index
= k
;
792 /* Called when we need to forget about all uses of REGNO after an insn
793 which is identified by RUID. */
796 reload_combine_purge_reg_uses_after_ruid (unsigned regno
, int ruid
)
798 int j
, k
, idx
= reg_state
[regno
].use_index
;
801 j
= k
= RELOAD_COMBINE_MAX_USES
;
804 if (reg_state
[regno
].reg_use
[j
].ruid
>= ruid
)
808 reg_state
[regno
].reg_use
[k
] = reg_state
[regno
].reg_use
[j
];
811 reg_state
[regno
].use_index
= k
;
814 /* Find the use of REGNO with the ruid that is highest among those
815 lower than RUID_LIMIT, and return it if it is the only use of this
816 reg in the insn. Return NULL otherwise. */
818 static struct reg_use
*
819 reload_combine_closest_single_use (unsigned regno
, int ruid_limit
)
821 int i
, best_ruid
= 0;
822 int use_idx
= reg_state
[regno
].use_index
;
823 struct reg_use
*retval
;
828 for (i
= use_idx
; i
< RELOAD_COMBINE_MAX_USES
; i
++)
830 struct reg_use
*use
= reg_state
[regno
].reg_use
+ i
;
831 int this_ruid
= use
->ruid
;
832 if (this_ruid
>= ruid_limit
)
834 if (this_ruid
> best_ruid
)
836 best_ruid
= this_ruid
;
839 else if (this_ruid
== best_ruid
)
842 if (last_label_ruid
>= best_ruid
)
847 /* After we've moved an add insn, fix up any debug insns that occur
848 between the old location of the add and the new location. REG is
849 the destination register of the add insn; REPLACEMENT is the
850 SET_SRC of the add. FROM and TO specify the range in which we
851 should make this change on debug insns. */
854 fixup_debug_insns (rtx reg
, rtx replacement
, rtx_insn
*from
, rtx_insn
*to
)
857 for (insn
= from
; insn
!= to
; insn
= NEXT_INSN (insn
))
861 if (!DEBUG_BIND_INSN_P (insn
))
864 t
= INSN_VAR_LOCATION_LOC (insn
);
865 t
= simplify_replace_rtx (t
, reg
, replacement
);
866 validate_change (insn
, &INSN_VAR_LOCATION_LOC (insn
), t
, 0);
870 /* Subroutine of reload_combine_recognize_const_pattern. Try to replace REG
871 with SRC in the insn described by USE, taking costs into account. Return
872 true if we made the replacement. */
875 try_replace_in_use (struct reg_use
*use
, rtx reg
, rtx src
)
877 rtx_insn
*use_insn
= use
->insn
;
878 rtx mem
= use
->containing_mem
;
879 bool speed
= optimize_bb_for_speed_p (BLOCK_FOR_INSN (use_insn
));
883 addr_space_t as
= MEM_ADDR_SPACE (mem
);
884 rtx oldaddr
= XEXP (mem
, 0);
885 rtx newaddr
= NULL_RTX
;
886 int old_cost
= address_cost (oldaddr
, GET_MODE (mem
), as
, speed
);
889 newaddr
= simplify_replace_rtx (oldaddr
, reg
, src
);
890 if (memory_address_addr_space_p (GET_MODE (mem
), newaddr
, as
))
892 XEXP (mem
, 0) = newaddr
;
893 new_cost
= address_cost (newaddr
, GET_MODE (mem
), as
, speed
);
894 XEXP (mem
, 0) = oldaddr
;
895 if (new_cost
<= old_cost
896 && validate_change (use_insn
,
897 &XEXP (mem
, 0), newaddr
, 0))
903 rtx new_set
= single_set (use_insn
);
905 && REG_P (SET_DEST (new_set
))
906 && GET_CODE (SET_SRC (new_set
)) == PLUS
907 && REG_P (XEXP (SET_SRC (new_set
), 0))
908 && CONSTANT_P (XEXP (SET_SRC (new_set
), 1)))
911 machine_mode mode
= GET_MODE (SET_DEST (new_set
));
912 int old_cost
= set_src_cost (SET_SRC (new_set
), mode
, speed
);
914 gcc_assert (rtx_equal_p (XEXP (SET_SRC (new_set
), 0), reg
));
915 new_src
= simplify_replace_rtx (SET_SRC (new_set
), reg
, src
);
917 if (set_src_cost (new_src
, mode
, speed
) <= old_cost
918 && validate_change (use_insn
, &SET_SRC (new_set
),
926 /* Called by reload_combine when scanning INSN. This function tries to detect
927 patterns where a constant is added to a register, and the result is used
929 Return true if no further processing is needed on INSN; false if it wasn't
930 recognized and should be handled normally. */
933 reload_combine_recognize_const_pattern (rtx_insn
*insn
)
935 int from_ruid
= reload_combine_ruid
;
936 rtx set
, pat
, reg
, src
, addreg
;
940 rtx_insn
*add_moved_after_insn
= NULL
;
941 int add_moved_after_ruid
= 0;
942 int clobbered_regno
= -1;
944 set
= single_set (insn
);
948 reg
= SET_DEST (set
);
951 || REG_NREGS (reg
) != 1
952 || GET_MODE (reg
) != Pmode
953 || reg
== stack_pointer_rtx
)
958 /* We look for a REG1 = REG2 + CONSTANT insn, followed by either
959 uses of REG1 inside an address, or inside another add insn. If
960 possible and profitable, merge the addition into subsequent
962 if (GET_CODE (src
) != PLUS
963 || !REG_P (XEXP (src
, 0))
964 || !CONSTANT_P (XEXP (src
, 1)))
967 addreg
= XEXP (src
, 0);
968 must_move_add
= rtx_equal_p (reg
, addreg
);
970 pat
= PATTERN (insn
);
971 if (must_move_add
&& set
!= pat
)
973 /* We have to be careful when moving the add; apart from the
974 single_set there may also be clobbers. Recognize one special
975 case, that of one clobber alongside the set (likely a clobber
976 of the CC register). */
977 gcc_assert (GET_CODE (PATTERN (insn
)) == PARALLEL
);
978 if (XVECLEN (pat
, 0) != 2 || XVECEXP (pat
, 0, 0) != set
979 || GET_CODE (XVECEXP (pat
, 0, 1)) != CLOBBER
980 || !REG_P (XEXP (XVECEXP (pat
, 0, 1), 0)))
982 clobbered_regno
= REGNO (XEXP (XVECEXP (pat
, 0, 1), 0));
987 use
= reload_combine_closest_single_use (regno
, from_ruid
);
990 /* Start the search for the next use from here. */
991 from_ruid
= use
->ruid
;
993 if (use
&& GET_MODE (*use
->usep
) == Pmode
)
995 bool delete_add
= false;
996 rtx_insn
*use_insn
= use
->insn
;
997 int use_ruid
= use
->ruid
;
999 /* Avoid moving the add insn past a jump. */
1000 if (must_move_add
&& use_ruid
<= last_jump_ruid
)
1003 /* If the add clobbers another hard reg in parallel, don't move
1004 it past a real set of this hard reg. */
1005 if (must_move_add
&& clobbered_regno
>= 0
1006 && reg_state
[clobbered_regno
].real_store_ruid
>= use_ruid
)
1009 /* Do not separate cc0 setter and cc0 user on HAVE_cc0 targets. */
1010 if (HAVE_cc0
&& must_move_add
&& sets_cc0_p (PATTERN (use_insn
)))
1013 gcc_assert (reg_state
[regno
].store_ruid
<= use_ruid
);
1014 /* Avoid moving a use of ADDREG past a point where it is stored. */
1015 if (reg_state
[REGNO (addreg
)].store_ruid
> use_ruid
)
1018 /* We also must not move the addition past an insn that sets
1019 the same register, unless we can combine two add insns. */
1020 if (must_move_add
&& reg_state
[regno
].store_ruid
== use_ruid
)
1022 if (use
->containing_mem
== NULL_RTX
)
1028 if (try_replace_in_use (use
, reg
, src
))
1030 reload_combine_purge_insn_uses (use_insn
);
1031 reload_combine_note_use (&PATTERN (use_insn
), use_insn
,
1032 use_ruid
, NULL_RTX
);
1036 fixup_debug_insns (reg
, src
, insn
, use_insn
);
1042 add_moved_after_insn
= use_insn
;
1043 add_moved_after_ruid
= use_ruid
;
1048 /* If we get here, we couldn't handle this use. */
1054 if (!must_move_add
|| add_moved_after_insn
== NULL_RTX
)
1055 /* Process the add normally. */
1058 fixup_debug_insns (reg
, src
, insn
, add_moved_after_insn
);
1060 reorder_insns (insn
, insn
, add_moved_after_insn
);
1061 reload_combine_purge_reg_uses_after_ruid (regno
, add_moved_after_ruid
);
1062 reload_combine_split_ruids (add_moved_after_ruid
- 1);
1063 reload_combine_note_use (&PATTERN (insn
), insn
,
1064 add_moved_after_ruid
, NULL_RTX
);
1065 reg_state
[regno
].store_ruid
= add_moved_after_ruid
;
1070 /* Called by reload_combine when scanning INSN. Try to detect a pattern we
1071 can handle and improve. Return true if no further processing is needed on
1072 INSN; false if it wasn't recognized and should be handled normally. */
1075 reload_combine_recognize_pattern (rtx_insn
*insn
)
1079 set
= single_set (insn
);
1080 if (set
== NULL_RTX
)
1083 reg
= SET_DEST (set
);
1084 src
= SET_SRC (set
);
1085 if (!REG_P (reg
) || REG_NREGS (reg
) != 1)
1088 unsigned int regno
= REGNO (reg
);
1089 machine_mode mode
= GET_MODE (reg
);
1091 if (reg_state
[regno
].use_index
< 0
1092 || reg_state
[regno
].use_index
>= RELOAD_COMBINE_MAX_USES
)
1095 for (int i
= reg_state
[regno
].use_index
;
1096 i
< RELOAD_COMBINE_MAX_USES
; i
++)
1098 struct reg_use
*use
= reg_state
[regno
].reg_use
+ i
;
1099 if (GET_MODE (*use
->usep
) != mode
)
1101 /* Don't try to adjust (use (REGX)). */
1102 if (GET_CODE (PATTERN (use
->insn
)) == USE
1103 && &XEXP (PATTERN (use
->insn
), 0) == use
->usep
)
1107 /* Look for (set (REGX) (CONST_INT))
1108 (set (REGX) (PLUS (REGX) (REGY)))
1110 ... (MEM (REGX)) ...
1112 (set (REGZ) (CONST_INT))
1114 ... (MEM (PLUS (REGZ) (REGY)))... .
1116 First, check that we have (set (REGX) (PLUS (REGX) (REGY)))
1117 and that we know all uses of REGX before it dies.
1118 Also, explicitly check that REGX != REGY; our life information
1119 does not yet show whether REGY changes in this insn. */
1121 if (GET_CODE (src
) == PLUS
1122 && reg_state
[regno
].all_offsets_match
1123 && last_index_reg
!= -1
1124 && REG_P (XEXP (src
, 1))
1125 && rtx_equal_p (XEXP (src
, 0), reg
)
1126 && !rtx_equal_p (XEXP (src
, 1), reg
)
1127 && last_label_ruid
< reg_state
[regno
].use_ruid
)
1129 rtx base
= XEXP (src
, 1);
1130 rtx_insn
*prev
= prev_nonnote_nondebug_insn (insn
);
1131 rtx prev_set
= prev
? single_set (prev
) : NULL_RTX
;
1132 rtx index_reg
= NULL_RTX
;
1133 rtx reg_sum
= NULL_RTX
;
1136 /* Now we need to set INDEX_REG to an index register (denoted as
1137 REGZ in the illustration above) and REG_SUM to the expression
1138 register+register that we want to use to substitute uses of REG
1139 (typically in MEMs) with. First check REG and BASE for being
1140 index registers; we can use them even if they are not dead. */
1141 if (TEST_HARD_REG_BIT (reg_class_contents
[INDEX_REG_CLASS
], regno
)
1142 || TEST_HARD_REG_BIT (reg_class_contents
[INDEX_REG_CLASS
],
1150 /* Otherwise, look for a free index register. Since we have
1151 checked above that neither REG nor BASE are index registers,
1152 if we find anything at all, it will be different from these
1154 for (i
= first_index_reg
; i
<= last_index_reg
; i
++)
1156 if (TEST_HARD_REG_BIT (reg_class_contents
[INDEX_REG_CLASS
], i
)
1157 && reg_state
[i
].use_index
== RELOAD_COMBINE_MAX_USES
1158 && reg_state
[i
].store_ruid
<= reg_state
[regno
].use_ruid
1159 && (crtl
->abi
->clobbers_full_reg_p (i
)
1160 || df_regs_ever_live_p (i
))
1161 && (!frame_pointer_needed
|| i
!= HARD_FRAME_POINTER_REGNUM
)
1162 && !fixed_regs
[i
] && !global_regs
[i
]
1163 && hard_regno_nregs (i
, GET_MODE (reg
)) == 1
1164 && targetm
.hard_regno_scratch_ok (i
))
1166 index_reg
= gen_rtx_REG (GET_MODE (reg
), i
);
1167 reg_sum
= gen_rtx_PLUS (GET_MODE (reg
), index_reg
, base
);
1173 /* Check that PREV_SET is indeed (set (REGX) (CONST_INT)) and that
1174 (REGY), i.e. BASE, is not clobbered before the last use we'll
1178 && CONST_INT_P (SET_SRC (prev_set
))
1179 && rtx_equal_p (SET_DEST (prev_set
), reg
)
1180 && (reg_state
[REGNO (base
)].store_ruid
1181 <= reg_state
[regno
].use_ruid
))
1183 /* Change destination register and, if necessary, the constant
1184 value in PREV, the constant loading instruction. */
1185 validate_change (prev
, &SET_DEST (prev_set
), index_reg
, 1);
1186 if (reg_state
[regno
].offset
!= const0_rtx
)
1189 = trunc_int_for_mode (UINTVAL (SET_SRC (prev_set
))
1190 + UINTVAL (reg_state
[regno
].offset
),
1191 GET_MODE (index_reg
));
1192 validate_change (prev
, &SET_SRC (prev_set
), GEN_INT (c
), 1);
1195 /* Now for every use of REG that we have recorded, replace REG
1197 for (i
= reg_state
[regno
].use_index
;
1198 i
< RELOAD_COMBINE_MAX_USES
; i
++)
1199 validate_unshare_change (reg_state
[regno
].reg_use
[i
].insn
,
1200 reg_state
[regno
].reg_use
[i
].usep
,
1201 /* Each change must have its own
1205 if (apply_change_group ())
1207 struct reg_use
*lowest_ruid
= NULL
;
1209 /* For every new use of REG_SUM, we have to record the use
1210 of BASE therein, i.e. operand 1. */
1211 for (i
= reg_state
[regno
].use_index
;
1212 i
< RELOAD_COMBINE_MAX_USES
; i
++)
1214 struct reg_use
*use
= reg_state
[regno
].reg_use
+ i
;
1215 reload_combine_note_use (&XEXP (*use
->usep
, 1), use
->insn
,
1216 use
->ruid
, use
->containing_mem
);
1217 if (lowest_ruid
== NULL
|| use
->ruid
< lowest_ruid
->ruid
)
1221 fixup_debug_insns (reg
, reg_sum
, insn
, lowest_ruid
->insn
);
1223 /* Delete the reg-reg addition. */
1226 if (reg_state
[regno
].offset
!= const0_rtx
1227 /* Previous REG_EQUIV / REG_EQUAL notes for PREV
1229 && remove_reg_equal_equiv_notes (prev
))
1230 df_notes_rescan (prev
);
1232 reg_state
[regno
].use_index
= RELOAD_COMBINE_MAX_USES
;
1241 reload_combine (void)
1243 rtx_insn
*insn
, *prev
;
1246 int min_labelno
, n_labels
;
1247 HARD_REG_SET ever_live_at_start
, *label_live
;
1249 /* To avoid wasting too much time later searching for an index register,
1250 determine the minimum and maximum index register numbers. */
1251 if (INDEX_REG_CLASS
== NO_REGS
)
1252 last_index_reg
= -1;
1253 else if (first_index_reg
== -1 && last_index_reg
== 0)
1255 for (r
= 0; r
< FIRST_PSEUDO_REGISTER
; r
++)
1256 if (TEST_HARD_REG_BIT (reg_class_contents
[INDEX_REG_CLASS
], r
))
1258 if (first_index_reg
== -1)
1259 first_index_reg
= r
;
1264 /* If no index register is available, we can quit now. Set LAST_INDEX_REG
1265 to -1 so we'll know to quit early the next time we get here. */
1266 if (first_index_reg
== -1)
1268 last_index_reg
= -1;
1273 /* Set up LABEL_LIVE and EVER_LIVE_AT_START. The register lifetime
1274 information is a bit fuzzy immediately after reload, but it's
1275 still good enough to determine which registers are live at a jump
1277 min_labelno
= get_first_label_num ();
1278 n_labels
= max_label_num () - min_labelno
;
1279 label_live
= XNEWVEC (HARD_REG_SET
, n_labels
);
1280 CLEAR_HARD_REG_SET (ever_live_at_start
);
1282 FOR_EACH_BB_REVERSE_FN (bb
, cfun
)
1284 insn
= BB_HEAD (bb
);
1288 bitmap live_in
= df_get_live_in (bb
);
1290 REG_SET_TO_HARD_REG_SET (live
, live_in
);
1291 compute_use_by_pseudos (&live
, live_in
);
1292 LABEL_LIVE (insn
) = live
;
1293 ever_live_at_start
|= live
;
1297 /* Initialize last_label_ruid, reload_combine_ruid and reg_state. */
1298 last_label_ruid
= last_jump_ruid
= reload_combine_ruid
= 0;
1299 for (r
= 0; r
< FIRST_PSEUDO_REGISTER
; r
++)
1301 reg_state
[r
].store_ruid
= 0;
1302 reg_state
[r
].real_store_ruid
= 0;
1304 reg_state
[r
].use_index
= -1;
1306 reg_state
[r
].use_index
= RELOAD_COMBINE_MAX_USES
;
1309 for (insn
= get_last_insn (); insn
; insn
= prev
)
1311 bool control_flow_insn
;
1314 prev
= PREV_INSN (insn
);
1316 /* We cannot do our optimization across labels. Invalidating all the use
1317 information we have would be costly, so we just note where the label
1318 is and then later disable any optimization that would cross it. */
1320 last_label_ruid
= reload_combine_ruid
;
1321 else if (BARRIER_P (insn
))
1323 /* Crossing a barrier resets all the use information. */
1324 for (r
= 0; r
< FIRST_PSEUDO_REGISTER
; r
++)
1325 if (! fixed_regs
[r
])
1326 reg_state
[r
].use_index
= RELOAD_COMBINE_MAX_USES
;
1328 else if (INSN_P (insn
) && volatile_insn_p (PATTERN (insn
)))
1329 /* Optimizations across insns being marked as volatile must be
1330 prevented. All the usage information is invalidated
1332 for (r
= 0; r
< FIRST_PSEUDO_REGISTER
; r
++)
1334 && reg_state
[r
].use_index
!= RELOAD_COMBINE_MAX_USES
)
1335 reg_state
[r
].use_index
= -1;
1337 if (! NONDEBUG_INSN_P (insn
))
1340 reload_combine_ruid
++;
1342 control_flow_insn
= control_flow_insn_p (insn
);
1343 if (control_flow_insn
)
1344 last_jump_ruid
= reload_combine_ruid
;
1346 if (reload_combine_recognize_const_pattern (insn
)
1347 || reload_combine_recognize_pattern (insn
))
1350 note_stores (insn
, reload_combine_note_store
, NULL
);
1355 HARD_REG_SET used_regs
= insn_callee_abi (insn
).full_reg_clobbers ();
1357 for (r
= 0; r
< FIRST_PSEUDO_REGISTER
; r
++)
1358 if (TEST_HARD_REG_BIT (used_regs
, r
))
1360 reg_state
[r
].use_index
= RELOAD_COMBINE_MAX_USES
;
1361 reg_state
[r
].store_ruid
= reload_combine_ruid
;
1364 for (link
= CALL_INSN_FUNCTION_USAGE (insn
); link
;
1365 link
= XEXP (link
, 1))
1367 rtx setuse
= XEXP (link
, 0);
1368 rtx usage_rtx
= XEXP (setuse
, 0);
1370 if (GET_CODE (setuse
) == USE
&& REG_P (usage_rtx
))
1372 unsigned int end_regno
= END_REGNO (usage_rtx
);
1373 for (unsigned int i
= REGNO (usage_rtx
); i
< end_regno
; ++i
)
1374 reg_state
[i
].use_index
= -1;
1379 if (control_flow_insn
&& !ANY_RETURN_P (PATTERN (insn
)))
1381 /* Non-spill registers might be used at the call destination in
1382 some unknown fashion, so we have to mark the unknown use. */
1385 if ((condjump_p (insn
) || condjump_in_parallel_p (insn
))
1386 && JUMP_LABEL (insn
))
1388 if (ANY_RETURN_P (JUMP_LABEL (insn
)))
1391 live
= &LABEL_LIVE (JUMP_LABEL (insn
));
1394 live
= &ever_live_at_start
;
1397 for (r
= 0; r
< FIRST_PSEUDO_REGISTER
; r
++)
1398 if (TEST_HARD_REG_BIT (*live
, r
))
1399 reg_state
[r
].use_index
= -1;
1402 reload_combine_note_use (&PATTERN (insn
), insn
, reload_combine_ruid
,
1405 for (note
= REG_NOTES (insn
); note
; note
= XEXP (note
, 1))
1407 if (REG_NOTE_KIND (note
) == REG_INC
&& REG_P (XEXP (note
, 0)))
1409 int regno
= REGNO (XEXP (note
, 0));
1410 reg_state
[regno
].store_ruid
= reload_combine_ruid
;
1411 reg_state
[regno
].real_store_ruid
= reload_combine_ruid
;
1412 reg_state
[regno
].use_index
= -1;
1420 /* Check if DST is a register or a subreg of a register; if it is,
1421 update store_ruid, real_store_ruid and use_index in the reg_state
1422 structure accordingly. Called via note_stores from reload_combine. */
1425 reload_combine_note_store (rtx dst
, const_rtx set
, void *data ATTRIBUTE_UNUSED
)
1429 machine_mode mode
= GET_MODE (dst
);
1431 if (GET_CODE (dst
) == SUBREG
)
1433 regno
= subreg_regno_offset (REGNO (SUBREG_REG (dst
)),
1434 GET_MODE (SUBREG_REG (dst
)),
1437 dst
= SUBREG_REG (dst
);
1440 /* Some targets do argument pushes without adding REG_INC notes. */
1444 dst
= XEXP (dst
, 0);
1445 if (GET_CODE (dst
) == PRE_INC
|| GET_CODE (dst
) == POST_INC
1446 || GET_CODE (dst
) == PRE_DEC
|| GET_CODE (dst
) == POST_DEC
1447 || GET_CODE (dst
) == PRE_MODIFY
|| GET_CODE (dst
) == POST_MODIFY
)
1449 unsigned int end_regno
= END_REGNO (XEXP (dst
, 0));
1450 for (unsigned int i
= REGNO (XEXP (dst
, 0)); i
< end_regno
; ++i
)
1452 /* We could probably do better, but for now mark the register
1453 as used in an unknown fashion and set/clobbered at this
1455 reg_state
[i
].use_index
= -1;
1456 reg_state
[i
].store_ruid
= reload_combine_ruid
;
1457 reg_state
[i
].real_store_ruid
= reload_combine_ruid
;
1466 regno
+= REGNO (dst
);
1468 /* note_stores might have stripped a STRICT_LOW_PART, so we have to be
1469 careful with registers / register parts that are not full words.
1470 Similarly for ZERO_EXTRACT. */
1471 if (GET_CODE (SET_DEST (set
)) == ZERO_EXTRACT
1472 || GET_CODE (SET_DEST (set
)) == STRICT_LOW_PART
)
1474 for (i
= end_hard_regno (mode
, regno
) - 1; i
>= regno
; i
--)
1476 reg_state
[i
].use_index
= -1;
1477 reg_state
[i
].store_ruid
= reload_combine_ruid
;
1478 reg_state
[i
].real_store_ruid
= reload_combine_ruid
;
1483 for (i
= end_hard_regno (mode
, regno
) - 1; i
>= regno
; i
--)
1485 reg_state
[i
].store_ruid
= reload_combine_ruid
;
1486 if (GET_CODE (set
) == SET
)
1487 reg_state
[i
].real_store_ruid
= reload_combine_ruid
;
1488 reg_state
[i
].use_index
= RELOAD_COMBINE_MAX_USES
;
1493 /* XP points to a piece of rtl that has to be checked for any uses of
1495 *XP is the pattern of INSN, or a part of it.
1496 Called from reload_combine, and recursively by itself. */
1498 reload_combine_note_use (rtx
*xp
, rtx_insn
*insn
, int ruid
, rtx containing_mem
)
1501 enum rtx_code code
= x
->code
;
1504 rtx offset
= const0_rtx
; /* For the REG case below. */
1509 if (REG_P (SET_DEST (x
)))
1511 reload_combine_note_use (&SET_SRC (x
), insn
, ruid
, NULL_RTX
);
1517 /* If this is the USE of a return value, we can't change it. */
1518 if (REG_P (XEXP (x
, 0)) && REG_FUNCTION_VALUE_P (XEXP (x
, 0)))
1520 /* Mark the return register as used in an unknown fashion. */
1521 rtx reg
= XEXP (x
, 0);
1522 unsigned int end_regno
= END_REGNO (reg
);
1523 for (unsigned int regno
= REGNO (reg
); regno
< end_regno
; ++regno
)
1524 reg_state
[regno
].use_index
= -1;
1530 if (REG_P (SET_DEST (x
)))
1532 /* No spurious CLOBBERs of pseudo registers may remain. */
1533 gcc_assert (REGNO (SET_DEST (x
)) < FIRST_PSEUDO_REGISTER
);
1539 /* We are interested in (plus (reg) (const_int)) . */
1540 if (!REG_P (XEXP (x
, 0))
1541 || !CONST_INT_P (XEXP (x
, 1)))
1543 offset
= XEXP (x
, 1);
1548 int regno
= REGNO (x
);
1552 /* No spurious USEs of pseudo registers may remain. */
1553 gcc_assert (regno
< FIRST_PSEUDO_REGISTER
);
1555 nregs
= REG_NREGS (x
);
1557 /* We can't substitute into multi-hard-reg uses. */
1560 while (--nregs
>= 0)
1561 reg_state
[regno
+ nregs
].use_index
= -1;
1565 /* We may be called to update uses in previously seen insns.
1566 Don't add uses beyond the last store we saw. */
1567 if (ruid
< reg_state
[regno
].store_ruid
)
1570 /* If this register is already used in some unknown fashion, we
1572 If we decrement the index from zero to -1, we can't store more
1573 uses, so this register becomes used in an unknown fashion. */
1574 use_index
= --reg_state
[regno
].use_index
;
1578 if (use_index
== RELOAD_COMBINE_MAX_USES
- 1)
1580 /* This is the first use of this register we have seen since we
1581 marked it as dead. */
1582 reg_state
[regno
].offset
= offset
;
1583 reg_state
[regno
].all_offsets_match
= true;
1584 reg_state
[regno
].use_ruid
= ruid
;
1588 if (reg_state
[regno
].use_ruid
> ruid
)
1589 reg_state
[regno
].use_ruid
= ruid
;
1591 if (! rtx_equal_p (offset
, reg_state
[regno
].offset
))
1592 reg_state
[regno
].all_offsets_match
= false;
1595 reg_state
[regno
].reg_use
[use_index
].insn
= insn
;
1596 reg_state
[regno
].reg_use
[use_index
].ruid
= ruid
;
1597 reg_state
[regno
].reg_use
[use_index
].containing_mem
= containing_mem
;
1598 reg_state
[regno
].reg_use
[use_index
].usep
= xp
;
1610 /* Recursively process the components of X. */
1611 fmt
= GET_RTX_FORMAT (code
);
1612 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
1615 reload_combine_note_use (&XEXP (x
, i
), insn
, ruid
, containing_mem
);
1616 else if (fmt
[i
] == 'E')
1618 for (j
= XVECLEN (x
, i
) - 1; j
>= 0; j
--)
1619 reload_combine_note_use (&XVECEXP (x
, i
, j
), insn
, ruid
,
1625 /* See if we can reduce the cost of a constant by replacing a move
1626 with an add. We track situations in which a register is set to a
1627 constant or to a register plus a constant. */
1628 /* We cannot do our optimization across labels. Invalidating all the
1629 information about register contents we have would be costly, so we
1630 use move2add_last_label_luid to note where the label is and then
1631 later disable any optimization that would cross it.
1632 reg_offset[n] / reg_base_reg[n] / reg_symbol_ref[n] / reg_mode[n]
1633 are only valid if reg_set_luid[n] is greater than
1634 move2add_last_label_luid.
1635 For a set that established a new (potential) base register with
1636 non-constant value, we use move2add_luid from the place where the
1637 setting insn is encountered; registers based off that base then
1638 get the same reg_set_luid. Constants all get
1639 move2add_last_label_luid + 1 as their reg_set_luid. */
1640 static int reg_set_luid
[FIRST_PSEUDO_REGISTER
];
1642 /* If reg_base_reg[n] is negative, register n has been set to
1643 reg_offset[n] or reg_symbol_ref[n] + reg_offset[n] in mode reg_mode[n].
1644 If reg_base_reg[n] is non-negative, register n has been set to the
1645 sum of reg_offset[n] and the value of register reg_base_reg[n]
1646 before reg_set_luid[n], calculated in mode reg_mode[n] .
1647 For multi-hard-register registers, all but the first one are
1648 recorded as BLKmode in reg_mode. Setting reg_mode to VOIDmode
1649 marks it as invalid. */
1650 static HOST_WIDE_INT reg_offset
[FIRST_PSEUDO_REGISTER
];
1651 static int reg_base_reg
[FIRST_PSEUDO_REGISTER
];
1652 static rtx reg_symbol_ref
[FIRST_PSEUDO_REGISTER
];
1653 static machine_mode reg_mode
[FIRST_PSEUDO_REGISTER
];
1655 /* move2add_luid is linearly increased while scanning the instructions
1656 from first to last. It is used to set reg_set_luid in
1657 reload_cse_move2add and move2add_note_store. */
1658 static int move2add_luid
;
1660 /* move2add_last_label_luid is set whenever a label is found. Labels
1661 invalidate all previously collected reg_offset data. */
1662 static int move2add_last_label_luid
;
1664 /* ??? We don't know how zero / sign extension is handled, hence we
1665 can't go from a narrower to a wider mode. */
1666 #define MODES_OK_FOR_MOVE2ADD(OUTMODE, INMODE) \
1667 (GET_MODE_SIZE (OUTMODE) == GET_MODE_SIZE (INMODE) \
1668 || (GET_MODE_SIZE (OUTMODE) <= GET_MODE_SIZE (INMODE) \
1669 && TRULY_NOOP_TRUNCATION_MODES_P (OUTMODE, INMODE)))
1671 /* Record that REG is being set to a value with the mode of REG. */
1674 move2add_record_mode (rtx reg
)
1677 machine_mode mode
= GET_MODE (reg
);
1679 if (GET_CODE (reg
) == SUBREG
)
1681 regno
= subreg_regno (reg
);
1682 nregs
= subreg_nregs (reg
);
1684 else if (REG_P (reg
))
1686 regno
= REGNO (reg
);
1687 nregs
= REG_NREGS (reg
);
1691 for (int i
= nregs
- 1; i
> 0; i
--)
1692 reg_mode
[regno
+ i
] = BLKmode
;
1693 reg_mode
[regno
] = mode
;
1696 /* Record that REG is being set to the sum of SYM and OFF. */
1699 move2add_record_sym_value (rtx reg
, rtx sym
, rtx off
)
1701 int regno
= REGNO (reg
);
1703 move2add_record_mode (reg
);
1704 reg_set_luid
[regno
] = move2add_luid
;
1705 reg_base_reg
[regno
] = -1;
1706 reg_symbol_ref
[regno
] = sym
;
1707 reg_offset
[regno
] = INTVAL (off
);
1710 /* Check if REGNO contains a valid value in MODE. */
1713 move2add_valid_value_p (int regno
, scalar_int_mode mode
)
1715 if (reg_set_luid
[regno
] <= move2add_last_label_luid
)
1718 if (mode
!= reg_mode
[regno
])
1720 scalar_int_mode old_mode
;
1721 if (!is_a
<scalar_int_mode
> (reg_mode
[regno
], &old_mode
)
1722 || !MODES_OK_FOR_MOVE2ADD (mode
, old_mode
))
1724 /* The value loaded into regno in reg_mode[regno] is also valid in
1725 mode after truncation only if (REG:mode regno) is the lowpart of
1726 (REG:reg_mode[regno] regno). Now, for big endian, the starting
1727 regno of the lowpart might be different. */
1728 poly_int64 s_off
= subreg_lowpart_offset (mode
, old_mode
);
1729 s_off
= subreg_regno_offset (regno
, old_mode
, s_off
, mode
);
1730 if (maybe_ne (s_off
, 0))
1731 /* We could in principle adjust regno, check reg_mode[regno] to be
1732 BLKmode, and return s_off to the caller (vs. -1 for failure),
1733 but we currently have no callers that could make use of this
1738 for (int i
= end_hard_regno (mode
, regno
) - 1; i
> regno
; i
--)
1739 if (reg_mode
[i
] != BLKmode
)
1744 /* This function is called with INSN that sets REG (of mode MODE)
1745 to (SYM + OFF), while REG is known to already have value (SYM + offset).
1746 This function tries to change INSN into an add instruction
1747 (set (REG) (plus (REG) (OFF - offset))) using the known value.
1748 It also updates the information about REG's known value.
1749 Return true if we made a change. */
1752 move2add_use_add2_insn (scalar_int_mode mode
, rtx reg
, rtx sym
, rtx off
,
1755 rtx pat
= PATTERN (insn
);
1756 rtx src
= SET_SRC (pat
);
1757 int regno
= REGNO (reg
);
1758 rtx new_src
= gen_int_mode (UINTVAL (off
) - reg_offset
[regno
], mode
);
1759 bool speed
= optimize_bb_for_speed_p (BLOCK_FOR_INSN (insn
));
1760 bool changed
= false;
1762 /* (set (reg) (plus (reg) (const_int 0))) is not canonical;
1763 use (set (reg) (reg)) instead.
1764 We don't delete this insn, nor do we convert it into a
1765 note, to avoid losing register notes or the return
1766 value flag. jump2 already knows how to get rid of
1768 if (new_src
== const0_rtx
)
1770 /* If the constants are different, this is a
1771 truncation, that, if turned into (set (reg)
1772 (reg)), would be discarded. Maybe we should
1773 try a truncMN pattern? */
1774 if (INTVAL (off
) == reg_offset
[regno
])
1775 changed
= validate_change (insn
, &SET_SRC (pat
), reg
, 0);
1779 struct full_rtx_costs oldcst
, newcst
;
1780 rtx tem
= gen_rtx_PLUS (mode
, reg
, new_src
);
1782 get_full_set_rtx_cost (pat
, &oldcst
);
1783 SET_SRC (pat
) = tem
;
1784 get_full_set_rtx_cost (pat
, &newcst
);
1785 SET_SRC (pat
) = src
;
1787 if (costs_lt_p (&newcst
, &oldcst
, speed
)
1788 && have_add2_insn (reg
, new_src
))
1789 changed
= validate_change (insn
, &SET_SRC (pat
), tem
, 0);
1790 else if (sym
== NULL_RTX
&& mode
!= BImode
)
1792 scalar_int_mode narrow_mode
;
1793 FOR_EACH_MODE_UNTIL (narrow_mode
, mode
)
1795 if (have_insn_for (STRICT_LOW_PART
, narrow_mode
)
1796 && ((reg_offset
[regno
] & ~GET_MODE_MASK (narrow_mode
))
1797 == (INTVAL (off
) & ~GET_MODE_MASK (narrow_mode
))))
1799 rtx narrow_reg
= gen_lowpart_common (narrow_mode
, reg
);
1800 rtx narrow_src
= gen_int_mode (INTVAL (off
),
1803 = gen_rtx_SET (gen_rtx_STRICT_LOW_PART (VOIDmode
,
1806 get_full_set_rtx_cost (new_set
, &newcst
);
1807 if (costs_lt_p (&newcst
, &oldcst
, speed
))
1809 changed
= validate_change (insn
, &PATTERN (insn
),
1818 move2add_record_sym_value (reg
, sym
, off
);
1823 /* This function is called with INSN that sets REG (of mode MODE) to
1824 (SYM + OFF), but REG doesn't have known value (SYM + offset). This
1825 function tries to find another register which is known to already have
1826 value (SYM + offset) and change INSN into an add instruction
1827 (set (REG) (plus (the found register) (OFF - offset))) if such
1828 a register is found. It also updates the information about
1830 Return true iff we made a change. */
1833 move2add_use_add3_insn (scalar_int_mode mode
, rtx reg
, rtx sym
, rtx off
,
1836 rtx pat
= PATTERN (insn
);
1837 rtx src
= SET_SRC (pat
);
1838 int regno
= REGNO (reg
);
1840 bool speed
= optimize_bb_for_speed_p (BLOCK_FOR_INSN (insn
));
1842 bool changed
= false;
1843 struct full_rtx_costs oldcst
, newcst
, mincst
;
1846 init_costs_to_max (&mincst
);
1847 get_full_set_rtx_cost (pat
, &oldcst
);
1849 plus_expr
= gen_rtx_PLUS (GET_MODE (reg
), reg
, const0_rtx
);
1850 SET_SRC (pat
) = plus_expr
;
1852 for (i
= 0; i
< FIRST_PSEUDO_REGISTER
; i
++)
1853 if (move2add_valid_value_p (i
, mode
)
1854 && reg_base_reg
[i
] < 0
1855 && reg_symbol_ref
[i
] != NULL_RTX
1856 && rtx_equal_p (sym
, reg_symbol_ref
[i
]))
1858 rtx new_src
= gen_int_mode (UINTVAL (off
) - reg_offset
[i
],
1860 /* (set (reg) (plus (reg) (const_int 0))) is not canonical;
1861 use (set (reg) (reg)) instead.
1862 We don't delete this insn, nor do we convert it into a
1863 note, to avoid losing register notes or the return
1864 value flag. jump2 already knows how to get rid of
1866 if (new_src
== const0_rtx
)
1868 init_costs_to_zero (&mincst
);
1874 XEXP (plus_expr
, 1) = new_src
;
1875 get_full_set_rtx_cost (pat
, &newcst
);
1877 if (costs_lt_p (&newcst
, &mincst
, speed
))
1884 SET_SRC (pat
) = src
;
1886 if (costs_lt_p (&mincst
, &oldcst
, speed
))
1890 tem
= gen_rtx_REG (GET_MODE (reg
), min_regno
);
1893 rtx new_src
= gen_int_mode (UINTVAL (off
) - reg_offset
[min_regno
],
1895 tem
= gen_rtx_PLUS (GET_MODE (reg
), tem
, new_src
);
1897 if (validate_change (insn
, &SET_SRC (pat
), tem
, 0))
1900 reg_set_luid
[regno
] = move2add_luid
;
1901 move2add_record_sym_value (reg
, sym
, off
);
1905 /* Convert move insns with constant inputs to additions if they are cheaper.
1906 Return true if any changes were made. */
1908 reload_cse_move2add (rtx_insn
*first
)
1912 bool changed
= false;
1914 for (i
= FIRST_PSEUDO_REGISTER
- 1; i
>= 0; i
--)
1916 reg_set_luid
[i
] = 0;
1918 reg_base_reg
[i
] = 0;
1919 reg_symbol_ref
[i
] = NULL_RTX
;
1920 reg_mode
[i
] = VOIDmode
;
1923 move2add_last_label_luid
= 0;
1925 for (insn
= first
; insn
; insn
= NEXT_INSN (insn
), move2add_luid
++)
1931 move2add_last_label_luid
= move2add_luid
;
1932 /* We're going to increment move2add_luid twice after a
1933 label, so that we can use move2add_last_label_luid + 1 as
1934 the luid for constants. */
1938 if (! INSN_P (insn
))
1940 pat
= PATTERN (insn
);
1941 /* For simplicity, we only perform this optimization on
1942 straightforward SETs. */
1943 scalar_int_mode mode
;
1944 if (GET_CODE (pat
) == SET
1945 && REG_P (SET_DEST (pat
))
1946 && is_a
<scalar_int_mode
> (GET_MODE (SET_DEST (pat
)), &mode
))
1948 rtx reg
= SET_DEST (pat
);
1949 int regno
= REGNO (reg
);
1950 rtx src
= SET_SRC (pat
);
1952 /* Check if we have valid information on the contents of this
1953 register in the mode of REG. */
1954 if (move2add_valid_value_p (regno
, mode
)
1955 && dbg_cnt (cse2_move2add
))
1957 /* Try to transform (set (REGX) (CONST_INT A))
1959 (set (REGX) (CONST_INT B))
1961 (set (REGX) (CONST_INT A))
1963 (set (REGX) (plus (REGX) (CONST_INT B-A)))
1965 (set (REGX) (CONST_INT A))
1967 (set (STRICT_LOW_PART (REGX)) (CONST_INT B))
1970 if (CONST_INT_P (src
)
1971 && reg_base_reg
[regno
] < 0
1972 && reg_symbol_ref
[regno
] == NULL_RTX
)
1974 changed
|= move2add_use_add2_insn (mode
, reg
, NULL_RTX
,
1979 /* Try to transform (set (REGX) (REGY))
1980 (set (REGX) (PLUS (REGX) (CONST_INT A)))
1983 (set (REGX) (PLUS (REGX) (CONST_INT B)))
1986 (set (REGX) (PLUS (REGX) (CONST_INT A)))
1988 (set (REGX) (plus (REGX) (CONST_INT B-A))) */
1989 else if (REG_P (src
)
1990 && reg_set_luid
[regno
] == reg_set_luid
[REGNO (src
)]
1991 && reg_base_reg
[regno
] == reg_base_reg
[REGNO (src
)]
1992 && move2add_valid_value_p (REGNO (src
), mode
))
1994 rtx_insn
*next
= next_nonnote_nondebug_insn (insn
);
1997 set
= single_set (next
);
1999 && SET_DEST (set
) == reg
2000 && GET_CODE (SET_SRC (set
)) == PLUS
2001 && XEXP (SET_SRC (set
), 0) == reg
2002 && CONST_INT_P (XEXP (SET_SRC (set
), 1)))
2004 rtx src3
= XEXP (SET_SRC (set
), 1);
2005 unsigned HOST_WIDE_INT added_offset
= UINTVAL (src3
);
2006 HOST_WIDE_INT base_offset
= reg_offset
[REGNO (src
)];
2007 HOST_WIDE_INT regno_offset
= reg_offset
[regno
];
2009 gen_int_mode (added_offset
2013 bool success
= false;
2014 bool speed
= optimize_bb_for_speed_p (BLOCK_FOR_INSN (insn
));
2016 if (new_src
== const0_rtx
)
2017 /* See above why we create (set (reg) (reg)) here. */
2019 = validate_change (next
, &SET_SRC (set
), reg
, 0);
2022 rtx old_src
= SET_SRC (set
);
2023 struct full_rtx_costs oldcst
, newcst
;
2024 rtx tem
= gen_rtx_PLUS (mode
, reg
, new_src
);
2026 get_full_set_rtx_cost (set
, &oldcst
);
2027 SET_SRC (set
) = tem
;
2028 get_full_set_src_cost (tem
, mode
, &newcst
);
2029 SET_SRC (set
) = old_src
;
2030 costs_add_n_insns (&oldcst
, 1);
2032 if (costs_lt_p (&newcst
, &oldcst
, speed
)
2033 && have_add2_insn (reg
, new_src
))
2035 rtx newpat
= gen_rtx_SET (reg
, tem
);
2037 = validate_change (next
, &PATTERN (next
),
2045 move2add_record_mode (reg
);
2047 = trunc_int_for_mode (added_offset
+ base_offset
,
2055 (set (REGX) (CONST (PLUS (SYMBOL_REF) (CONST_INT A))))
2057 (set (REGY) (CONST (PLUS (SYMBOL_REF) (CONST_INT B))))
2059 (set (REGX) (CONST (PLUS (SYMBOL_REF) (CONST_INT A))))
2061 (set (REGY) (CONST (PLUS (REGX) (CONST_INT B-A)))) */
2062 if ((GET_CODE (src
) == SYMBOL_REF
2063 || (GET_CODE (src
) == CONST
2064 && GET_CODE (XEXP (src
, 0)) == PLUS
2065 && GET_CODE (XEXP (XEXP (src
, 0), 0)) == SYMBOL_REF
2066 && CONST_INT_P (XEXP (XEXP (src
, 0), 1))))
2067 && dbg_cnt (cse2_move2add
))
2071 if (GET_CODE (src
) == SYMBOL_REF
)
2078 sym
= XEXP (XEXP (src
, 0), 0);
2079 off
= XEXP (XEXP (src
, 0), 1);
2082 /* If the reg already contains the value which is sum of
2083 sym and some constant value, we can use an add2 insn. */
2084 if (move2add_valid_value_p (regno
, mode
)
2085 && reg_base_reg
[regno
] < 0
2086 && reg_symbol_ref
[regno
] != NULL_RTX
2087 && rtx_equal_p (sym
, reg_symbol_ref
[regno
]))
2088 changed
|= move2add_use_add2_insn (mode
, reg
, sym
, off
, insn
);
2090 /* Otherwise, we have to find a register whose value is sum
2091 of sym and some constant value. */
2093 changed
|= move2add_use_add3_insn (mode
, reg
, sym
, off
, insn
);
2099 for (note
= REG_NOTES (insn
); note
; note
= XEXP (note
, 1))
2101 if (REG_NOTE_KIND (note
) == REG_INC
2102 && REG_P (XEXP (note
, 0)))
2104 /* Reset the information about this register. */
2105 int regno
= REGNO (XEXP (note
, 0));
2106 if (regno
< FIRST_PSEUDO_REGISTER
)
2108 move2add_record_mode (XEXP (note
, 0));
2109 reg_mode
[regno
] = VOIDmode
;
2114 /* There are no REG_INC notes for SP autoinc. */
2115 subrtx_var_iterator::array_type array
;
2116 FOR_EACH_SUBRTX_VAR (iter
, array
, PATTERN (insn
), NONCONST
)
2121 && GET_RTX_CLASS (GET_CODE (XEXP (mem
, 0))) == RTX_AUTOINC
)
2123 if (XEXP (XEXP (mem
, 0), 0) == stack_pointer_rtx
)
2124 reg_mode
[STACK_POINTER_REGNUM
] = VOIDmode
;
2128 note_stores (insn
, move2add_note_store
, insn
);
2130 /* If INSN is a conditional branch, we try to extract an
2131 implicit set out of it. */
2132 if (any_condjump_p (insn
))
2134 rtx cnd
= fis_get_condition (insn
);
2137 && GET_CODE (cnd
) == NE
2138 && REG_P (XEXP (cnd
, 0))
2139 && !reg_set_p (XEXP (cnd
, 0), insn
)
2140 /* The following two checks, which are also in
2141 move2add_note_store, are intended to reduce the
2142 number of calls to gen_rtx_SET to avoid memory
2143 allocation if possible. */
2144 && SCALAR_INT_MODE_P (GET_MODE (XEXP (cnd
, 0)))
2145 && REG_NREGS (XEXP (cnd
, 0)) == 1
2146 && CONST_INT_P (XEXP (cnd
, 1)))
2149 gen_rtx_SET (XEXP (cnd
, 0), XEXP (cnd
, 1));
2150 move2add_note_store (SET_DEST (implicit_set
), implicit_set
, insn
);
2154 /* If this is a CALL_INSN, all call used registers are stored with
2158 function_abi callee_abi
= insn_callee_abi (insn
);
2159 for (i
= FIRST_PSEUDO_REGISTER
- 1; i
>= 0; i
--)
2160 if (reg_mode
[i
] != VOIDmode
2161 && reg_mode
[i
] != BLKmode
2162 && callee_abi
.clobbers_reg_p (reg_mode
[i
], i
))
2163 /* Reset the information about this register. */
2164 reg_mode
[i
] = VOIDmode
;
2170 /* SET is a SET or CLOBBER that sets DST. DATA is the insn which
2172 Update reg_set_luid, reg_offset and reg_base_reg accordingly.
2173 Called from reload_cse_move2add via note_stores. */
2176 move2add_note_store (rtx dst
, const_rtx set
, void *data
)
2178 rtx_insn
*insn
= (rtx_insn
*) data
;
2179 unsigned int regno
= 0;
2180 scalar_int_mode mode
;
2182 if (GET_CODE (dst
) == SUBREG
)
2183 regno
= subreg_regno (dst
);
2184 else if (REG_P (dst
))
2185 regno
= REGNO (dst
);
2189 if (!is_a
<scalar_int_mode
> (GET_MODE (dst
), &mode
))
2192 if (GET_CODE (set
) == SET
)
2194 rtx note
, sym
= NULL_RTX
;
2197 note
= find_reg_equal_equiv_note (insn
);
2198 if (note
&& GET_CODE (XEXP (note
, 0)) == SYMBOL_REF
)
2200 sym
= XEXP (note
, 0);
2203 else if (note
&& GET_CODE (XEXP (note
, 0)) == CONST
2204 && GET_CODE (XEXP (XEXP (note
, 0), 0)) == PLUS
2205 && GET_CODE (XEXP (XEXP (XEXP (note
, 0), 0), 0)) == SYMBOL_REF
2206 && CONST_INT_P (XEXP (XEXP (XEXP (note
, 0), 0), 1)))
2208 sym
= XEXP (XEXP (XEXP (note
, 0), 0), 0);
2209 off
= XEXP (XEXP (XEXP (note
, 0), 0), 1);
2212 if (sym
!= NULL_RTX
)
2214 move2add_record_sym_value (dst
, sym
, off
);
2219 if (GET_CODE (set
) == SET
2220 && GET_CODE (SET_DEST (set
)) != ZERO_EXTRACT
2221 && GET_CODE (SET_DEST (set
)) != STRICT_LOW_PART
)
2223 rtx src
= SET_SRC (set
);
2225 unsigned HOST_WIDE_INT offset
;
2228 switch (GET_CODE (src
))
2231 if (REG_P (XEXP (src
, 0)))
2233 base_reg
= XEXP (src
, 0);
2235 if (CONST_INT_P (XEXP (src
, 1)))
2236 offset
= UINTVAL (XEXP (src
, 1));
2237 else if (REG_P (XEXP (src
, 1))
2238 && move2add_valid_value_p (REGNO (XEXP (src
, 1)), mode
))
2240 if (reg_base_reg
[REGNO (XEXP (src
, 1))] < 0
2241 && reg_symbol_ref
[REGNO (XEXP (src
, 1))] == NULL_RTX
)
2242 offset
= reg_offset
[REGNO (XEXP (src
, 1))];
2243 /* Maybe the first register is known to be a
2245 else if (move2add_valid_value_p (REGNO (base_reg
), mode
)
2246 && reg_base_reg
[REGNO (base_reg
)] < 0
2247 && reg_symbol_ref
[REGNO (base_reg
)] == NULL_RTX
)
2249 offset
= reg_offset
[REGNO (base_reg
)];
2250 base_reg
= XEXP (src
, 1);
2269 /* Start tracking the register as a constant. */
2270 reg_base_reg
[regno
] = -1;
2271 reg_symbol_ref
[regno
] = NULL_RTX
;
2272 reg_offset
[regno
] = INTVAL (SET_SRC (set
));
2273 /* We assign the same luid to all registers set to constants. */
2274 reg_set_luid
[regno
] = move2add_last_label_luid
+ 1;
2275 move2add_record_mode (dst
);
2282 base_regno
= REGNO (base_reg
);
2283 /* If information about the base register is not valid, set it
2284 up as a new base register, pretending its value is known
2285 starting from the current insn. */
2286 if (!move2add_valid_value_p (base_regno
, mode
))
2288 reg_base_reg
[base_regno
] = base_regno
;
2289 reg_symbol_ref
[base_regno
] = NULL_RTX
;
2290 reg_offset
[base_regno
] = 0;
2291 reg_set_luid
[base_regno
] = move2add_luid
;
2292 gcc_assert (GET_MODE (base_reg
) == mode
);
2293 move2add_record_mode (base_reg
);
2296 /* Copy base information from our base register. */
2297 reg_set_luid
[regno
] = reg_set_luid
[base_regno
];
2298 reg_base_reg
[regno
] = reg_base_reg
[base_regno
];
2299 reg_symbol_ref
[regno
] = reg_symbol_ref
[base_regno
];
2301 /* Compute the sum of the offsets or constants. */
2303 = trunc_int_for_mode (offset
+ reg_offset
[base_regno
], mode
);
2305 move2add_record_mode (dst
);
2310 /* Invalidate the contents of the register. */
2311 move2add_record_mode (dst
);
2312 reg_mode
[regno
] = VOIDmode
;
2318 const pass_data pass_data_postreload_cse
=
2320 RTL_PASS
, /* type */
2321 "postreload", /* name */
2322 OPTGROUP_NONE
, /* optinfo_flags */
2323 TV_RELOAD_CSE_REGS
, /* tv_id */
2324 0, /* properties_required */
2325 0, /* properties_provided */
2326 0, /* properties_destroyed */
2327 0, /* todo_flags_start */
2328 TODO_df_finish
, /* todo_flags_finish */
2331 class pass_postreload_cse
: public rtl_opt_pass
2334 pass_postreload_cse (gcc::context
*ctxt
)
2335 : rtl_opt_pass (pass_data_postreload_cse
, ctxt
)
2338 /* opt_pass methods: */
2339 virtual bool gate (function
*) { return (optimize
> 0 && reload_completed
); }
2341 virtual unsigned int execute (function
*);
2343 }; // class pass_postreload_cse
2346 pass_postreload_cse::execute (function
*fun
)
2348 if (!dbg_cnt (postreload_cse
))
2351 /* Do a very simple CSE pass over just the hard registers. */
2352 reload_cse_regs (get_insns ());
2353 /* Reload_cse_regs can eliminate potentially-trapping MEMs.
2354 Remove any EH edges associated with them. */
2355 if (fun
->can_throw_non_call_exceptions
2356 && purge_all_dead_edges ())
2365 make_pass_postreload_cse (gcc::context
*ctxt
)
2367 return new pass_postreload_cse (ctxt
);