1 /* Code for RTL register eliminations.
2 Copyright (C) 2010-2021 Free Software Foundation, Inc.
3 Contributed by Vladimir Makarov <vmakarov@redhat.com>.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 3, or (at your option) any later
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
21 /* Eliminable registers (like a soft argument or frame pointer) are
22 widely used in RTL. These eliminable registers should be replaced
23 by real hard registers (like the stack pointer or hard frame
24 pointer) plus some offset. The offsets usually change whenever the
25 stack is expanded. We know the final offsets only at the very end
28 Within LRA, we usually keep the RTL in such a state that the
29 eliminable registers can be replaced by just the corresponding hard
30 register (without any offset). To achieve this we should add the
31 initial elimination offset at the beginning of LRA and update the
32 offsets whenever the stack is expanded. We need to do this before
33 every constraint pass because the choice of offset often affects
34 whether a particular address or memory constraint is satisfied.
36 We keep RTL code at most time in such state that the virtual
37 registers can be changed by just the corresponding hard registers
38 (with zero offsets) and we have the right RTL code. To achieve this
39 we should add initial offset at the beginning of LRA work and update
40 offsets after each stack expanding. But actually we update virtual
41 registers to the same virtual registers + corresponding offsets
42 before every constraint pass because it affects constraint
43 satisfaction (e.g. an address displacement became too big for some
46 The final change of eliminable registers to the corresponding hard
47 registers are done at the very end of LRA when there were no change
56 #include "coretypes.h"
69 #include "rtl-error.h"
72 /* This structure is used to record information about hard register
77 /* Hard register number to be eliminated. */
79 /* Hard register number used as replacement. */
81 /* Difference between values of the two hard registers above on
82 previous iteration. */
83 poly_int64 previous_offset
;
84 /* Difference between the values on the current iteration. */
86 /* Nonzero if this elimination can be done. */
88 /* CAN_ELIMINATE since the last check. */
89 bool prev_can_eliminate
;
90 /* REG rtx for the register to be eliminated. We cannot simply
91 compare the number since we might then spuriously replace a hard
92 register corresponding to a pseudo assigned to the reg to be
95 /* REG rtx for the replacement. */
99 /* The elimination table. Each array entry describes one possible way
100 of eliminating a register in favor of another. If there is more
101 than one way of eliminating a particular register, the most
102 preferred should be specified first. */
103 static class lra_elim_table
*reg_eliminate
= 0;
105 /* This is an intermediate structure to initialize the table. It has
106 exactly the members provided by ELIMINABLE_REGS. */
107 static const struct elim_table_1
111 } reg_eliminate_1
[] =
115 #define NUM_ELIMINABLE_REGS ARRAY_SIZE (reg_eliminate_1)
117 /* Print info about elimination table to file F. */
119 print_elim_table (FILE *f
)
121 class lra_elim_table
*ep
;
123 for (ep
= reg_eliminate
; ep
< ®_eliminate
[NUM_ELIMINABLE_REGS
]; ep
++)
125 fprintf (f
, "%s eliminate %d to %d (offset=",
126 ep
->can_eliminate
? "Can" : "Can't", ep
->from
, ep
->to
);
127 print_dec (ep
->offset
, f
);
128 fprintf (f
, ", prev_offset=");
129 print_dec (ep
->previous_offset
, f
);
134 /* Print info about elimination table to stderr. */
136 lra_debug_elim_table (void)
138 print_elim_table (stderr
);
141 /* Setup possibility of elimination in elimination table element EP to
142 VALUE. Setup FRAME_POINTER_NEEDED if elimination from frame
143 pointer to stack pointer is not possible anymore. */
145 setup_can_eliminate (class lra_elim_table
*ep
, bool value
)
147 ep
->can_eliminate
= ep
->prev_can_eliminate
= value
;
149 && ep
->from
== FRAME_POINTER_REGNUM
&& ep
->to
== STACK_POINTER_REGNUM
)
150 frame_pointer_needed
= 1;
151 if (!frame_pointer_needed
)
152 REGNO_POINTER_ALIGN (HARD_FRAME_POINTER_REGNUM
) = 0;
155 /* Map: eliminable "from" register -> its current elimination,
156 or NULL if none. The elimination table may contain more than
157 one elimination for the same hard register, but this map specifies
158 the one that we are currently using. */
159 static class lra_elim_table
*elimination_map
[FIRST_PSEUDO_REGISTER
];
161 /* When an eliminable hard register becomes not eliminable, we use the
162 following special structure to restore original offsets for the
164 static class lra_elim_table self_elim_table
;
166 /* Offsets should be used to restore original offsets for eliminable
167 hard register which just became not eliminable. Zero,
169 static poly_int64_pod self_elim_offsets
[FIRST_PSEUDO_REGISTER
];
171 /* Map: hard regno -> RTL presentation. RTL presentations of all
172 potentially eliminable hard registers are stored in the map. */
173 static rtx eliminable_reg_rtx
[FIRST_PSEUDO_REGISTER
];
175 /* Set up ELIMINATION_MAP of the currently used eliminations. */
177 setup_elimination_map (void)
180 class lra_elim_table
*ep
;
182 for (i
= 0; i
< FIRST_PSEUDO_REGISTER
; i
++)
183 elimination_map
[i
] = NULL
;
184 for (ep
= reg_eliminate
; ep
< ®_eliminate
[NUM_ELIMINABLE_REGS
]; ep
++)
185 if (ep
->can_eliminate
&& elimination_map
[ep
->from
] == NULL
)
186 elimination_map
[ep
->from
] = ep
;
191 /* Compute the sum of X and Y, making canonicalizations assumed in an
192 address, namely: sum constant integers, surround the sum of two
193 constants with a CONST, put the constant as the second operand, and
194 group the constant on the outermost sum.
196 This routine assumes both inputs are already in canonical form. */
198 form_sum (rtx x
, rtx y
)
200 machine_mode mode
= GET_MODE (x
);
203 if (mode
== VOIDmode
)
206 if (mode
== VOIDmode
)
209 if (poly_int_rtx_p (x
, &offset
))
210 return plus_constant (mode
, y
, offset
);
211 else if (poly_int_rtx_p (y
, &offset
))
212 return plus_constant (mode
, x
, offset
);
213 else if (CONSTANT_P (x
))
216 if (GET_CODE (x
) == PLUS
&& CONSTANT_P (XEXP (x
, 1)))
217 return form_sum (XEXP (x
, 0), form_sum (XEXP (x
, 1), y
));
219 /* Note that if the operands of Y are specified in the opposite
220 order in the recursive calls below, infinite recursion will
222 if (GET_CODE (y
) == PLUS
&& CONSTANT_P (XEXP (y
, 1)))
223 return form_sum (form_sum (x
, XEXP (y
, 0)), XEXP (y
, 1));
225 /* If both constant, encapsulate sum. Otherwise, just form sum. A
226 constant will have been placed second. */
227 if (CONSTANT_P (x
) && CONSTANT_P (y
))
229 if (GET_CODE (x
) == CONST
)
231 if (GET_CODE (y
) == CONST
)
234 return gen_rtx_CONST (VOIDmode
, gen_rtx_PLUS (mode
, x
, y
));
237 return gen_rtx_PLUS (mode
, x
, y
);
240 /* Return the current substitution hard register of the elimination of
241 HARD_REGNO. If HARD_REGNO is not eliminable, return itself. */
243 lra_get_elimination_hard_regno (int hard_regno
)
245 class lra_elim_table
*ep
;
247 if (hard_regno
< 0 || hard_regno
>= FIRST_PSEUDO_REGISTER
)
249 if ((ep
= elimination_map
[hard_regno
]) == NULL
)
254 /* Return elimination which will be used for hard reg REG, NULL
256 static class lra_elim_table
*
257 get_elimination (rtx reg
)
260 class lra_elim_table
*ep
;
262 lra_assert (REG_P (reg
));
263 if ((hard_regno
= REGNO (reg
)) < 0 || hard_regno
>= FIRST_PSEUDO_REGISTER
)
265 if ((ep
= elimination_map
[hard_regno
]) != NULL
)
266 return ep
->from_rtx
!= reg
? NULL
: ep
;
267 poly_int64 offset
= self_elim_offsets
[hard_regno
];
268 if (known_eq (offset
, 0))
270 /* This is an iteration to restore offsets just after HARD_REGNO
271 stopped to be eliminable. */
272 self_elim_table
.from
= self_elim_table
.to
= hard_regno
;
273 self_elim_table
.from_rtx
274 = self_elim_table
.to_rtx
275 = eliminable_reg_rtx
[hard_regno
];
276 lra_assert (self_elim_table
.from_rtx
!= NULL
);
277 self_elim_table
.offset
= offset
;
278 return &self_elim_table
;
281 /* Transform (subreg (plus reg const)) to (plus (subreg reg) const)
282 when it is possible. Return X or the transformation result if the
283 transformation is done. */
288 machine_mode x_mode
, subreg_reg_mode
;
290 if (GET_CODE (x
) != SUBREG
|| !subreg_lowpart_p (x
))
292 subreg_reg
= SUBREG_REG (x
);
293 x_mode
= GET_MODE (x
);
294 subreg_reg_mode
= GET_MODE (subreg_reg
);
295 if (!paradoxical_subreg_p (x
)
296 && GET_CODE (subreg_reg
) == PLUS
297 && CONSTANT_P (XEXP (subreg_reg
, 1))
298 && GET_MODE_CLASS (x_mode
) == MODE_INT
299 && GET_MODE_CLASS (subreg_reg_mode
) == MODE_INT
)
301 rtx cst
= simplify_subreg (x_mode
, XEXP (subreg_reg
, 1), subreg_reg_mode
,
302 subreg_lowpart_offset (x_mode
,
304 if (cst
&& CONSTANT_P (cst
))
305 return gen_rtx_PLUS (x_mode
, lowpart_subreg (x_mode
,
306 XEXP (subreg_reg
, 0),
307 subreg_reg_mode
), cst
);
312 /* Scan X and replace any eliminable registers (such as fp) with a
313 replacement (such as sp) if SUBST_P, plus an offset. The offset is
314 a change in the offset between the eliminable register and its
315 substitution if UPDATE_P, or the full offset if FULL_P, or
316 otherwise zero. If FULL_P, we also use the SP offsets for
317 elimination to SP. If UPDATE_P, use UPDATE_SP_OFFSET for updating
318 offsets of register elimnable to SP. If UPDATE_SP_OFFSET is
319 non-zero, don't use difference of the offset and the previous
322 MEM_MODE is the mode of an enclosing MEM. We need this to know how
323 much to adjust a register for, e.g., PRE_DEC. Also, if we are
324 inside a MEM, we are allowed to replace a sum of a hard register
325 and the constant zero with the hard register, which we cannot do
326 outside a MEM. In addition, we need to record the fact that a
327 hard register is referenced outside a MEM.
329 If we make full substitution to SP for non-null INSN, add the insn
332 lra_eliminate_regs_1 (rtx_insn
*insn
, rtx x
, machine_mode mem_mode
,
333 bool subst_p
, bool update_p
,
334 poly_int64 update_sp_offset
, bool full_p
)
336 enum rtx_code code
= GET_CODE (x
);
337 class lra_elim_table
*ep
;
343 lra_assert (!update_p
|| !full_p
);
344 lra_assert (known_eq (update_sp_offset
, 0)
345 || (!subst_p
&& update_p
&& !full_p
));
346 if (! current_function_decl
)
364 /* First handle the case where we encounter a bare hard register
365 that is eliminable. Replace it with a PLUS. */
366 if ((ep
= get_elimination (x
)) != NULL
)
368 rtx to
= subst_p
? ep
->to_rtx
: ep
->from_rtx
;
370 if (maybe_ne (update_sp_offset
, 0))
372 if (ep
->to_rtx
== stack_pointer_rtx
)
373 return plus_constant (Pmode
, to
, update_sp_offset
);
377 return plus_constant (Pmode
, to
, ep
->offset
- ep
->previous_offset
);
379 return plus_constant (Pmode
, to
,
382 && ep
->to_rtx
== stack_pointer_rtx
383 ? lra_get_insn_recog_data (insn
)->sp_offset
391 /* If this is the sum of an eliminable register and a constant, rework
393 if (REG_P (XEXP (x
, 0)) && CONSTANT_P (XEXP (x
, 1)))
395 if ((ep
= get_elimination (XEXP (x
, 0))) != NULL
)
397 poly_int64 offset
, curr_offset
;
398 rtx to
= subst_p
? ep
->to_rtx
: ep
->from_rtx
;
400 if (! update_p
&& ! full_p
)
401 return gen_rtx_PLUS (Pmode
, to
, XEXP (x
, 1));
403 if (maybe_ne (update_sp_offset
, 0))
404 offset
= ep
->to_rtx
== stack_pointer_rtx
? update_sp_offset
: 0;
407 ? ep
->offset
- ep
->previous_offset
: ep
->offset
);
408 if (full_p
&& insn
!= NULL_RTX
&& ep
->to_rtx
== stack_pointer_rtx
)
409 offset
-= lra_get_insn_recog_data (insn
)->sp_offset
;
410 if (poly_int_rtx_p (XEXP (x
, 1), &curr_offset
)
411 && known_eq (curr_offset
, -offset
))
414 return gen_rtx_PLUS (Pmode
, to
,
415 plus_constant (Pmode
,
416 XEXP (x
, 1), offset
));
419 /* If the hard register is not eliminable, we are done since
420 the other operand is a constant. */
424 /* If this is part of an address, we want to bring any constant
425 to the outermost PLUS. We will do this by doing hard
426 register replacement in our operands and seeing if a constant
427 shows up in one of them.
429 Note that there is no risk of modifying the structure of the
430 insn, since we only get called for its operands, thus we are
431 either modifying the address inside a MEM, or something like
432 an address operand of a load-address insn. */
435 rtx new0
= lra_eliminate_regs_1 (insn
, XEXP (x
, 0), mem_mode
,
437 update_sp_offset
, full_p
);
438 rtx new1
= lra_eliminate_regs_1 (insn
, XEXP (x
, 1), mem_mode
,
440 update_sp_offset
, full_p
);
442 new0
= move_plus_up (new0
);
443 new1
= move_plus_up (new1
);
444 if (new0
!= XEXP (x
, 0) || new1
!= XEXP (x
, 1))
445 return form_sum (new0
, new1
);
450 /* If this is the product of an eliminable hard register and a
451 constant, apply the distribute law and move the constant out
452 so that we have (plus (mult ..) ..). This is needed in order
453 to keep load-address insns valid. This case is pathological.
454 We ignore the possibility of overflow here. */
455 if (REG_P (XEXP (x
, 0)) && CONST_INT_P (XEXP (x
, 1))
456 && (ep
= get_elimination (XEXP (x
, 0))) != NULL
)
458 rtx to
= subst_p
? ep
->to_rtx
: ep
->from_rtx
;
460 if (maybe_ne (update_sp_offset
, 0))
462 if (ep
->to_rtx
== stack_pointer_rtx
)
463 return plus_constant (Pmode
,
464 gen_rtx_MULT (Pmode
, to
, XEXP (x
, 1)),
465 update_sp_offset
* INTVAL (XEXP (x
, 1)));
466 return gen_rtx_MULT (Pmode
, to
, XEXP (x
, 1));
469 return plus_constant (Pmode
,
470 gen_rtx_MULT (Pmode
, to
, XEXP (x
, 1)),
471 (ep
->offset
- ep
->previous_offset
)
472 * INTVAL (XEXP (x
, 1)));
475 poly_int64 offset
= ep
->offset
;
477 if (insn
!= NULL_RTX
&& ep
->to_rtx
== stack_pointer_rtx
)
478 offset
-= lra_get_insn_recog_data (insn
)->sp_offset
;
480 plus_constant (Pmode
,
481 gen_rtx_MULT (Pmode
, to
, XEXP (x
, 1)),
482 offset
* INTVAL (XEXP (x
, 1)));
485 return gen_rtx_MULT (Pmode
, to
, XEXP (x
, 1));
492 /* See comments before PLUS about handling MINUS. */
496 case AND
: case IOR
: case XOR
:
497 case ROTATERT
: case ROTATE
:
498 case ASHIFTRT
: case LSHIFTRT
: case ASHIFT
:
500 case GE
: case GT
: case GEU
: case GTU
:
501 case LE
: case LT
: case LEU
: case LTU
:
503 rtx new0
= lra_eliminate_regs_1 (insn
, XEXP (x
, 0), mem_mode
,
505 update_sp_offset
, full_p
);
506 rtx new1
= XEXP (x
, 1)
507 ? lra_eliminate_regs_1 (insn
, XEXP (x
, 1), mem_mode
,
509 update_sp_offset
, full_p
) : 0;
511 if (new0
!= XEXP (x
, 0) || new1
!= XEXP (x
, 1))
512 return gen_rtx_fmt_ee (code
, GET_MODE (x
), new0
, new1
);
517 /* If we have something in XEXP (x, 0), the usual case,
521 new_rtx
= lra_eliminate_regs_1 (insn
, XEXP (x
, 0), mem_mode
,
523 update_sp_offset
, full_p
);
524 if (new_rtx
!= XEXP (x
, 0))
526 /* If this is a REG_DEAD note, it is not valid anymore.
527 Using the eliminated version could result in creating a
528 REG_DEAD note for the stack or frame pointer. */
529 if (REG_NOTE_KIND (x
) == REG_DEAD
)
531 ? lra_eliminate_regs_1 (insn
, XEXP (x
, 1), mem_mode
,
533 update_sp_offset
, full_p
)
536 x
= alloc_reg_note (REG_NOTE_KIND (x
), new_rtx
, XEXP (x
, 1));
544 /* Now do eliminations in the rest of the chain. If this was
545 an EXPR_LIST, this might result in allocating more memory than is
546 strictly needed, but it simplifies the code. */
549 new_rtx
= lra_eliminate_regs_1 (insn
, XEXP (x
, 1), mem_mode
,
551 update_sp_offset
, full_p
);
552 if (new_rtx
!= XEXP (x
, 1))
554 gen_rtx_fmt_ee (GET_CODE (x
), GET_MODE (x
),
555 XEXP (x
, 0), new_rtx
);
563 /* We do not support elimination of a register that is modified.
564 elimination_effects has already make sure that this does not
570 /* We do not support elimination of a hard register that is
571 modified. LRA has already make sure that this does not
572 happen. The only remaining case we need to consider here is
573 that the increment value may be an eliminable register. */
574 if (GET_CODE (XEXP (x
, 1)) == PLUS
575 && XEXP (XEXP (x
, 1), 0) == XEXP (x
, 0))
577 rtx new_rtx
= lra_eliminate_regs_1 (insn
, XEXP (XEXP (x
, 1), 1),
578 mem_mode
, subst_p
, update_p
,
579 update_sp_offset
, full_p
);
581 if (new_rtx
!= XEXP (XEXP (x
, 1), 1))
582 return gen_rtx_fmt_ee (code
, GET_MODE (x
), XEXP (x
, 0),
583 gen_rtx_PLUS (GET_MODE (x
),
584 XEXP (x
, 0), new_rtx
));
588 case STRICT_LOW_PART
:
590 case SIGN_EXTEND
: case ZERO_EXTEND
:
591 case TRUNCATE
: case FLOAT_EXTEND
: case FLOAT_TRUNCATE
:
592 case FLOAT
: case FIX
:
593 case UNSIGNED_FIX
: case UNSIGNED_FLOAT
:
602 new_rtx
= lra_eliminate_regs_1 (insn
, XEXP (x
, 0), mem_mode
,
604 update_sp_offset
, full_p
);
605 if (new_rtx
!= XEXP (x
, 0))
606 return gen_rtx_fmt_e (code
, GET_MODE (x
), new_rtx
);
610 new_rtx
= lra_eliminate_regs_1 (insn
, SUBREG_REG (x
), mem_mode
,
612 update_sp_offset
, full_p
);
614 if (new_rtx
!= SUBREG_REG (x
))
616 if (MEM_P (new_rtx
) && !paradoxical_subreg_p (x
))
618 SUBREG_REG (x
) = new_rtx
;
619 alter_subreg (&x
, false);
624 /* LRA can transform subregs itself. So don't call
625 simplify_gen_subreg until LRA transformations are
626 finished. Function simplify_gen_subreg can do
627 non-trivial transformations (like truncation) which
628 might make LRA work to fail. */
629 SUBREG_REG (x
) = new_rtx
;
633 return simplify_gen_subreg (GET_MODE (x
), new_rtx
,
634 GET_MODE (new_rtx
), SUBREG_BYTE (x
));
640 /* Our only special processing is to pass the mode of the MEM to our
641 recursive call and copy the flags. While we are here, handle this
642 case more efficiently. */
644 replace_equiv_address_nv
646 lra_eliminate_regs_1 (insn
, XEXP (x
, 0), GET_MODE (x
),
647 subst_p
, update_p
, update_sp_offset
, full_p
));
650 /* Handle insn_list USE that a call to a pure function may generate. */
651 new_rtx
= lra_eliminate_regs_1 (insn
, XEXP (x
, 0), VOIDmode
,
652 subst_p
, update_p
, update_sp_offset
, full_p
);
653 if (new_rtx
!= XEXP (x
, 0))
654 return gen_rtx_USE (GET_MODE (x
), new_rtx
);
665 /* Process each of our operands recursively. If any have changed, make a
667 fmt
= GET_RTX_FORMAT (code
);
668 for (i
= 0; i
< GET_RTX_LENGTH (code
); i
++, fmt
++)
672 new_rtx
= lra_eliminate_regs_1 (insn
, XEXP (x
, i
), mem_mode
,
674 update_sp_offset
, full_p
);
675 if (new_rtx
!= XEXP (x
, i
) && ! copied
)
677 x
= shallow_copy_rtx (x
);
680 XEXP (x
, i
) = new_rtx
;
682 else if (*fmt
== 'E')
685 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
687 new_rtx
= lra_eliminate_regs_1 (insn
, XVECEXP (x
, i
, j
), mem_mode
,
689 update_sp_offset
, full_p
);
690 if (new_rtx
!= XVECEXP (x
, i
, j
) && ! copied_vec
)
692 rtvec new_v
= gen_rtvec_v (XVECLEN (x
, i
),
696 x
= shallow_copy_rtx (x
);
702 XVECEXP (x
, i
, j
) = new_rtx
;
710 /* This function is used externally in subsequent passes of GCC. It
711 always does a full elimination of X. */
713 lra_eliminate_regs (rtx x
, machine_mode mem_mode
,
714 rtx insn ATTRIBUTE_UNUSED
)
716 return lra_eliminate_regs_1 (NULL
, x
, mem_mode
, true, false, 0, true);
719 /* Stack pointer offset before the current insn relative to one at the
720 func start. RTL insns can change SP explicitly. We keep the
721 changes from one insn to another through this variable. */
722 static poly_int64 curr_sp_change
;
724 /* Scan rtx X for references to elimination source or target registers
725 in contexts that would prevent the elimination from happening.
726 Update the table of eliminables to reflect the changed state.
727 MEM_MODE is the mode of an enclosing MEM rtx, or VOIDmode if not
730 mark_not_eliminable (rtx x
, machine_mode mem_mode
)
732 enum rtx_code code
= GET_CODE (x
);
733 class lra_elim_table
*ep
;
736 poly_int64 offset
= 0;
746 if (XEXP (x
, 0) == stack_pointer_rtx
747 && ((code
!= PRE_MODIFY
&& code
!= POST_MODIFY
)
748 || (GET_CODE (XEXP (x
, 1)) == PLUS
749 && XEXP (x
, 0) == XEXP (XEXP (x
, 1), 0)
750 && poly_int_rtx_p (XEXP (XEXP (x
, 1), 1), &offset
))))
752 poly_int64 size
= GET_MODE_SIZE (mem_mode
);
755 /* If more bytes than MEM_MODE are pushed, account for
757 size
= PUSH_ROUNDING (size
);
759 if (code
== PRE_DEC
|| code
== POST_DEC
)
760 curr_sp_change
-= size
;
761 else if (code
== PRE_INC
|| code
== POST_INC
)
762 curr_sp_change
+= size
;
763 else if (code
== PRE_MODIFY
|| code
== POST_MODIFY
)
764 curr_sp_change
+= offset
;
766 else if (REG_P (XEXP (x
, 0))
767 && REGNO (XEXP (x
, 0)) >= FIRST_PSEUDO_REGISTER
)
769 /* If we modify the source of an elimination rule, disable
770 it. Do the same if it is the destination and not the
771 hard frame register. */
772 for (ep
= reg_eliminate
;
773 ep
< ®_eliminate
[NUM_ELIMINABLE_REGS
];
775 if (ep
->from_rtx
== XEXP (x
, 0)
776 || (ep
->to_rtx
== XEXP (x
, 0)
777 && ep
->to_rtx
!= hard_frame_pointer_rtx
))
778 setup_can_eliminate (ep
, false);
783 if (REG_P (XEXP (x
, 0)) && REGNO (XEXP (x
, 0)) < FIRST_PSEUDO_REGISTER
)
784 /* If using a hard register that is the source of an eliminate
785 we still think can be performed, note it cannot be
786 performed since we don't know how this hard register is
788 for (ep
= reg_eliminate
;
789 ep
< ®_eliminate
[NUM_ELIMINABLE_REGS
];
791 if (ep
->from_rtx
== XEXP (x
, 0)
792 && ep
->to_rtx
!= hard_frame_pointer_rtx
)
793 setup_can_eliminate (ep
, false);
797 if (REG_P (XEXP (x
, 0)) && REGNO (XEXP (x
, 0)) < FIRST_PSEUDO_REGISTER
)
798 /* If clobbering a hard register that is the replacement
799 register for an elimination we still think can be
800 performed, note that it cannot be performed. Otherwise, we
801 need not be concerned about it. */
802 for (ep
= reg_eliminate
;
803 ep
< ®_eliminate
[NUM_ELIMINABLE_REGS
];
805 if (ep
->to_rtx
== XEXP (x
, 0)
806 && ep
->to_rtx
!= hard_frame_pointer_rtx
)
807 setup_can_eliminate (ep
, false);
811 if (SET_DEST (x
) == stack_pointer_rtx
812 && GET_CODE (SET_SRC (x
)) == PLUS
813 && XEXP (SET_SRC (x
), 0) == SET_DEST (x
)
814 && poly_int_rtx_p (XEXP (SET_SRC (x
), 1), &offset
))
816 curr_sp_change
+= offset
;
819 if (! REG_P (SET_DEST (x
))
820 || REGNO (SET_DEST (x
)) >= FIRST_PSEUDO_REGISTER
)
821 mark_not_eliminable (SET_DEST (x
), mem_mode
);
824 /* See if this is setting the replacement hard register for
827 If DEST is the hard frame pointer, we do nothing because
828 we assume that all assignments to the frame pointer are
829 for non-local gotos and are being done at a time when
830 they are valid and do not disturb anything else. Some
831 machines want to eliminate a fake argument pointer (or
832 even a fake frame pointer) with either the real frame
833 pointer or the stack pointer. Assignments to the hard
834 frame pointer must not prevent this elimination. */
835 for (ep
= reg_eliminate
;
836 ep
< ®_eliminate
[NUM_ELIMINABLE_REGS
];
838 if (ep
->to_rtx
== SET_DEST (x
)
839 && SET_DEST (x
) != hard_frame_pointer_rtx
)
840 setup_can_eliminate (ep
, false);
843 mark_not_eliminable (SET_SRC (x
), mem_mode
);
847 /* Our only special processing is to pass the mode of the MEM to
848 our recursive call. */
849 mark_not_eliminable (XEXP (x
, 0), GET_MODE (x
));
856 fmt
= GET_RTX_FORMAT (code
);
857 for (i
= 0; i
< GET_RTX_LENGTH (code
); i
++, fmt
++)
860 mark_not_eliminable (XEXP (x
, i
), mem_mode
);
861 else if (*fmt
== 'E')
862 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
863 mark_not_eliminable (XVECEXP (x
, i
, j
), mem_mode
);
869 /* Scan INSN and eliminate all eliminable hard registers in it.
871 If REPLACE_P is true, do the replacement destructively. Also
872 delete the insn as dead it if it is setting an eliminable register.
874 If REPLACE_P is false, just update the offsets while keeping the
875 base register the same. If FIRST_P, use the sp offset for
876 elimination to sp. Otherwise, use UPDATE_SP_OFFSET for this. If
877 UPDATE_SP_OFFSET is non-zero, don't use difference of the offset
878 and the previous offset. Attach the note about used elimination
879 for insns setting frame pointer to update elimination easy (without
880 parsing already generated elimination insns to find offset
881 previously used) in future. */
884 eliminate_regs_in_insn (rtx_insn
*insn
, bool replace_p
, bool first_p
,
885 poly_int64 update_sp_offset
)
887 int icode
= recog_memoized (insn
);
888 rtx set
, old_set
= single_set (insn
);
891 rtx substed_operand
[MAX_RECOG_OPERANDS
];
892 rtx orig_operand
[MAX_RECOG_OPERANDS
];
893 class lra_elim_table
*ep
;
894 rtx plus_src
, plus_cst_src
;
895 lra_insn_recog_data_t id
;
896 struct lra_static_insn_data
*static_id
;
898 if (icode
< 0 && asm_noperands (PATTERN (insn
)) < 0 && ! DEBUG_INSN_P (insn
))
900 lra_assert (GET_CODE (PATTERN (insn
)) == USE
901 || GET_CODE (PATTERN (insn
)) == CLOBBER
902 || GET_CODE (PATTERN (insn
)) == ASM_INPUT
);
906 /* We allow one special case which happens to work on all machines we
907 currently support: a single set with the source or a REG_EQUAL
908 note being a PLUS of an eliminable register and a constant. */
909 plus_src
= plus_cst_src
= 0;
910 poly_int64 offset
= 0;
911 if (old_set
&& REG_P (SET_DEST (old_set
)))
913 if (GET_CODE (SET_SRC (old_set
)) == PLUS
)
914 plus_src
= SET_SRC (old_set
);
915 /* First see if the source is of the form (plus (...) CST). */
916 if (plus_src
&& poly_int_rtx_p (XEXP (plus_src
, 1), &offset
))
917 plus_cst_src
= plus_src
;
918 /* Check that the first operand of the PLUS is a hard reg or
919 the lowpart subreg of one. */
922 rtx reg
= XEXP (plus_cst_src
, 0);
924 if (GET_CODE (reg
) == SUBREG
&& subreg_lowpart_p (reg
))
925 reg
= SUBREG_REG (reg
);
927 if (!REG_P (reg
) || REGNO (reg
) >= FIRST_PSEUDO_REGISTER
)
933 rtx reg
= XEXP (plus_cst_src
, 0);
935 if (GET_CODE (reg
) == SUBREG
)
936 reg
= SUBREG_REG (reg
);
938 if (REG_P (reg
) && (ep
= get_elimination (reg
)) != NULL
)
940 rtx to_rtx
= replace_p
? ep
->to_rtx
: ep
->from_rtx
;
944 if (known_eq (update_sp_offset
, 0))
945 offset
+= (ep
->offset
- ep
->previous_offset
);
946 if (ep
->to_rtx
== stack_pointer_rtx
)
949 offset
-= lra_get_insn_recog_data (insn
)->sp_offset
;
951 offset
+= update_sp_offset
;
953 offset
= trunc_int_for_mode (offset
, GET_MODE (plus_cst_src
));
956 if (GET_CODE (XEXP (plus_cst_src
, 0)) == SUBREG
)
957 to_rtx
= gen_lowpart (GET_MODE (XEXP (plus_cst_src
, 0)), to_rtx
);
958 /* If we have a nonzero offset, and the source is already a
959 simple REG, the following transformation would increase
960 the cost of the insn by replacing a simple REG with (plus
961 (reg sp) CST). So try only when we already had a PLUS
963 if (known_eq (offset
, 0) || plus_src
)
965 rtx new_src
= plus_constant (GET_MODE (to_rtx
), to_rtx
, offset
);
967 old_set
= single_set (insn
);
969 /* First see if this insn remains valid when we make the
970 change. If not, try to replace the whole pattern
971 with a simple set (this may help if the original insn
972 was a PARALLEL that was only recognized as single_set
973 due to REG_UNUSED notes). If this isn't valid
974 either, keep the INSN_CODE the same and let the
975 constraint pass fix it up. */
976 if (! validate_change (insn
, &SET_SRC (old_set
), new_src
, 0))
978 rtx new_pat
= gen_rtx_SET (SET_DEST (old_set
), new_src
);
980 if (! validate_change (insn
, &PATTERN (insn
), new_pat
, 0))
981 SET_SRC (old_set
) = new_src
;
983 lra_update_insn_recog_data (insn
);
984 /* This can't have an effect on elimination offsets, so skip
991 /* Eliminate all eliminable registers occurring in operands that
992 can be handled by the constraint pass. */
993 id
= lra_get_insn_recog_data (insn
);
994 static_id
= id
->insn_static_data
;
996 for (i
= 0; i
< static_id
->n_operands
; i
++)
998 orig_operand
[i
] = *id
->operand_loc
[i
];
999 substed_operand
[i
] = *id
->operand_loc
[i
];
1001 /* For an asm statement, every operand is eliminable. */
1002 if (icode
< 0 || insn_data
[icode
].operand
[i
].eliminable
)
1004 /* Check for setting a hard register that we know about. */
1005 if (static_id
->operand
[i
].type
!= OP_IN
1006 && REG_P (orig_operand
[i
]))
1008 /* If we are assigning to a hard register that can be
1009 eliminated, it must be as part of a PARALLEL, since
1010 the code above handles single SETs. This reg cannot
1011 be longer eliminated -- it is forced by
1012 mark_not_eliminable. */
1013 for (ep
= reg_eliminate
;
1014 ep
< ®_eliminate
[NUM_ELIMINABLE_REGS
];
1016 lra_assert (ep
->from_rtx
!= orig_operand
[i
]
1017 || ! ep
->can_eliminate
);
1020 /* Companion to the above plus substitution, we can allow
1021 invariants as the source of a plain move. */
1023 = lra_eliminate_regs_1 (insn
, *id
->operand_loc
[i
], VOIDmode
,
1024 replace_p
, ! replace_p
&& ! first_p
,
1025 update_sp_offset
, first_p
);
1026 if (substed_operand
[i
] != orig_operand
[i
])
1034 /* Substitute the operands; the new values are in the substed_operand
1036 for (i
= 0; i
< static_id
->n_operands
; i
++)
1037 *id
->operand_loc
[i
] = substed_operand
[i
];
1038 for (i
= 0; i
< static_id
->n_dups
; i
++)
1039 *id
->dup_loc
[i
] = substed_operand
[(int) static_id
->dup_num
[i
]];
1041 /* Transform plus (plus (hard reg, const), pseudo) to plus (plus (pseudo,
1042 const), hard reg) in order to keep insn containing eliminated register
1043 after all reloads calculating its offset. This permits to keep register
1044 pressure under control and helps to avoid LRA cycling in patalogical
1046 if (! replace_p
&& (set
= single_set (insn
)) != NULL
1047 && GET_CODE (SET_SRC (set
)) == PLUS
1048 && GET_CODE (XEXP (SET_SRC (set
), 0)) == PLUS
)
1050 rtx reg1
, reg2
, op1
, op2
;
1052 reg1
= op1
= XEXP (XEXP (SET_SRC (set
), 0), 0);
1053 reg2
= op2
= XEXP (SET_SRC (set
), 1);
1054 if (GET_CODE (reg1
) == SUBREG
)
1055 reg1
= SUBREG_REG (reg1
);
1056 if (GET_CODE (reg2
) == SUBREG
)
1057 reg2
= SUBREG_REG (reg2
);
1058 if (REG_P (reg1
) && REG_P (reg2
)
1059 && REGNO (reg1
) < FIRST_PSEUDO_REGISTER
1060 && REGNO (reg2
) >= FIRST_PSEUDO_REGISTER
)
1062 XEXP (XEXP (SET_SRC (set
), 0), 0) = op2
;
1063 XEXP (SET_SRC (set
), 1) = op1
;
1067 /* If we had a move insn but now we don't, re-recognize it.
1068 This will cause spurious re-recognition if the old move had a
1069 PARALLEL since the new one still will, but we can't call
1070 single_set without having put new body into the insn and the
1071 re-recognition won't hurt in this rare case. */
1072 lra_update_insn_recog_data (insn
);
1075 /* Spill pseudos which are assigned to hard registers in SET. Add
1076 affected insns for processing in the subsequent constraint
1079 spill_pseudos (HARD_REG_SET set
)
1082 bitmap_head to_process
;
1085 if (hard_reg_set_empty_p (set
))
1087 if (lra_dump_file
!= NULL
)
1089 fprintf (lra_dump_file
, " Spilling non-eliminable hard regs:");
1090 for (i
= 0; i
< FIRST_PSEUDO_REGISTER
; i
++)
1091 if (TEST_HARD_REG_BIT (set
, i
))
1092 fprintf (lra_dump_file
, " %d", i
);
1093 fprintf (lra_dump_file
, "\n");
1095 bitmap_initialize (&to_process
, ®_obstack
);
1096 for (i
= FIRST_PSEUDO_REGISTER
; i
< max_reg_num (); i
++)
1097 if (lra_reg_info
[i
].nrefs
!= 0 && reg_renumber
[i
] >= 0
1098 && overlaps_hard_reg_set_p (set
,
1099 PSEUDO_REGNO_MODE (i
), reg_renumber
[i
]))
1101 if (lra_dump_file
!= NULL
)
1102 fprintf (lra_dump_file
, " Spilling r%d(%d)\n",
1103 i
, reg_renumber
[i
]);
1104 reg_renumber
[i
] = -1;
1105 bitmap_ior_into (&to_process
, &lra_reg_info
[i
].insn_bitmap
);
1107 lra_no_alloc_regs
|= set
;
1108 for (insn
= get_insns (); insn
!= NULL_RTX
; insn
= NEXT_INSN (insn
))
1109 if (bitmap_bit_p (&to_process
, INSN_UID (insn
)))
1111 lra_push_insn (insn
);
1112 lra_set_used_insn_alternative (insn
, LRA_UNKNOWN_ALT
);
1114 bitmap_clear (&to_process
);
1117 /* Update all offsets and possibility for elimination on eliminable
1118 registers. Spill pseudos assigned to registers which are
1119 uneliminable, update LRA_NO_ALLOC_REGS and ELIMINABLE_REG_SET. Add
1120 insns to INSNS_WITH_CHANGED_OFFSETS containing eliminable hard
1121 registers whose offsets should be changed. Return true if any
1122 elimination offset changed. */
1124 update_reg_eliminate (bitmap insns_with_changed_offsets
)
1127 class lra_elim_table
*ep
, *ep1
;
1128 HARD_REG_SET temp_hard_reg_set
;
1130 targetm
.compute_frame_layout ();
1132 /* Clear self elimination offsets. */
1133 for (ep
= reg_eliminate
; ep
< ®_eliminate
[NUM_ELIMINABLE_REGS
]; ep
++)
1134 self_elim_offsets
[ep
->from
] = 0;
1135 for (ep
= reg_eliminate
; ep
< ®_eliminate
[NUM_ELIMINABLE_REGS
]; ep
++)
1137 /* If it is a currently used elimination: update the previous
1139 if (elimination_map
[ep
->from
] == ep
)
1140 ep
->previous_offset
= ep
->offset
;
1142 prev
= ep
->prev_can_eliminate
;
1143 setup_can_eliminate (ep
, targetm
.can_eliminate (ep
->from
, ep
->to
));
1144 if (ep
->can_eliminate
&& ! prev
)
1146 /* It is possible that not eliminable register becomes
1147 eliminable because we took other reasons into account to
1148 set up eliminable regs in the initial set up. Just
1149 ignore new eliminable registers. */
1150 setup_can_eliminate (ep
, false);
1153 if (ep
->can_eliminate
!= prev
&& elimination_map
[ep
->from
] == ep
)
1155 /* We cannot use this elimination anymore -- find another
1157 if (lra_dump_file
!= NULL
)
1158 fprintf (lra_dump_file
,
1159 " Elimination %d to %d is not possible anymore\n",
1161 /* If after processing RTL we decides that SP can be used as
1162 a result of elimination, it cannot be changed. */
1163 gcc_assert ((ep
->to_rtx
!= stack_pointer_rtx
)
1164 || (ep
->from
< FIRST_PSEUDO_REGISTER
1165 && fixed_regs
[ep
->from
]));
1166 /* Mark that is not eliminable anymore. */
1167 elimination_map
[ep
->from
] = NULL
;
1168 for (ep1
= ep
+ 1; ep1
< ®_eliminate
[NUM_ELIMINABLE_REGS
]; ep1
++)
1169 if (ep1
->can_eliminate
&& ep1
->from
== ep
->from
)
1171 if (ep1
< ®_eliminate
[NUM_ELIMINABLE_REGS
])
1173 if (lra_dump_file
!= NULL
)
1174 fprintf (lra_dump_file
, " Using elimination %d to %d now\n",
1175 ep1
->from
, ep1
->to
);
1176 lra_assert (known_eq (ep1
->previous_offset
, 0));
1177 ep1
->previous_offset
= ep
->offset
;
1181 /* There is no elimination anymore just use the hard
1182 register `from' itself. Setup self elimination
1183 offset to restore the original offset values. */
1184 if (lra_dump_file
!= NULL
)
1185 fprintf (lra_dump_file
, " %d is not eliminable at all\n",
1187 self_elim_offsets
[ep
->from
] = -ep
->offset
;
1188 if (maybe_ne (ep
->offset
, 0))
1189 bitmap_ior_into (insns_with_changed_offsets
,
1190 &lra_reg_info
[ep
->from
].insn_bitmap
);
1194 INITIAL_ELIMINATION_OFFSET (ep
->from
, ep
->to
, ep
->offset
);
1196 setup_elimination_map ();
1198 CLEAR_HARD_REG_SET (temp_hard_reg_set
);
1199 for (ep
= reg_eliminate
; ep
< ®_eliminate
[NUM_ELIMINABLE_REGS
]; ep
++)
1200 if (elimination_map
[ep
->from
] == NULL
)
1201 add_to_hard_reg_set (&temp_hard_reg_set
, Pmode
, ep
->from
);
1202 else if (elimination_map
[ep
->from
] == ep
)
1204 /* Prevent the hard register into which we eliminate from
1205 the usage for pseudos. */
1206 if (ep
->from
!= ep
->to
)
1207 add_to_hard_reg_set (&temp_hard_reg_set
, Pmode
, ep
->to
);
1208 if (maybe_ne (ep
->previous_offset
, ep
->offset
))
1210 bitmap_ior_into (insns_with_changed_offsets
,
1211 &lra_reg_info
[ep
->from
].insn_bitmap
);
1213 /* Update offset when the eliminate offset have been
1215 lra_update_reg_val_offset (lra_reg_info
[ep
->from
].val
,
1216 ep
->offset
- ep
->previous_offset
);
1220 lra_no_alloc_regs
|= temp_hard_reg_set
;
1221 eliminable_regset
&= ~temp_hard_reg_set
;
1222 spill_pseudos (temp_hard_reg_set
);
1226 /* Initialize the table of hard registers to eliminate.
1227 Pre-condition: global flag frame_pointer_needed has been set before
1228 calling this function. */
1230 init_elim_table (void)
1232 class lra_elim_table
*ep
;
1234 const struct elim_table_1
*ep1
;
1237 reg_eliminate
= XCNEWVEC (class lra_elim_table
, NUM_ELIMINABLE_REGS
);
1239 memset (self_elim_offsets
, 0, sizeof (self_elim_offsets
));
1240 /* Initiate member values which will be never changed. */
1241 self_elim_table
.can_eliminate
= self_elim_table
.prev_can_eliminate
= true;
1242 self_elim_table
.previous_offset
= 0;
1244 for (ep
= reg_eliminate
, ep1
= reg_eliminate_1
;
1245 ep
< ®_eliminate
[NUM_ELIMINABLE_REGS
]; ep
++, ep1
++)
1247 ep
->offset
= ep
->previous_offset
= 0;
1248 ep
->from
= ep1
->from
;
1250 value_p
= (targetm
.can_eliminate (ep
->from
, ep
->to
)
1251 && ! (ep
->to
== STACK_POINTER_REGNUM
1252 && frame_pointer_needed
1253 && (! SUPPORTS_STACK_ALIGNMENT
1254 || ! stack_realign_fp
)));
1255 setup_can_eliminate (ep
, value_p
);
1258 /* Build the FROM and TO REG rtx's. Note that code in gen_rtx_REG
1259 will cause, e.g., gen_rtx_REG (Pmode, STACK_POINTER_REGNUM) to
1260 equal stack_pointer_rtx. We depend on this. Threfore we switch
1261 off that we are in LRA temporarily. */
1262 lra_in_progress
= 0;
1263 for (ep
= reg_eliminate
; ep
< ®_eliminate
[NUM_ELIMINABLE_REGS
]; ep
++)
1265 ep
->from_rtx
= gen_rtx_REG (Pmode
, ep
->from
);
1266 ep
->to_rtx
= gen_rtx_REG (Pmode
, ep
->to
);
1267 eliminable_reg_rtx
[ep
->from
] = ep
->from_rtx
;
1269 lra_in_progress
= 1;
1272 /* Function for initialization of elimination once per function. It
1273 sets up sp offset for each insn. */
1275 init_elimination (void)
1277 bool stop_to_sp_elimination_p
;
1280 class lra_elim_table
*ep
;
1283 FOR_EACH_BB_FN (bb
, cfun
)
1286 stop_to_sp_elimination_p
= false;
1287 FOR_BB_INSNS (bb
, insn
)
1290 lra_get_insn_recog_data (insn
)->sp_offset
= curr_sp_change
;
1291 if (NONDEBUG_INSN_P (insn
))
1293 mark_not_eliminable (PATTERN (insn
), VOIDmode
);
1294 if (maybe_ne (curr_sp_change
, 0)
1295 && find_reg_note (insn
, REG_LABEL_OPERAND
, NULL_RTX
))
1296 stop_to_sp_elimination_p
= true;
1299 if (! frame_pointer_needed
1300 && (maybe_ne (curr_sp_change
, 0) || stop_to_sp_elimination_p
)
1301 && bb
->succs
&& bb
->succs
->length () != 0)
1302 for (ep
= reg_eliminate
; ep
< ®_eliminate
[NUM_ELIMINABLE_REGS
]; ep
++)
1303 if (ep
->to
== STACK_POINTER_REGNUM
)
1304 setup_can_eliminate (ep
, false);
1306 setup_elimination_map ();
1309 /* Eliminate hard reg given by its location LOC. */
1311 lra_eliminate_reg_if_possible (rtx
*loc
)
1314 class lra_elim_table
*ep
;
1316 lra_assert (REG_P (*loc
));
1317 if ((regno
= REGNO (*loc
)) >= FIRST_PSEUDO_REGISTER
1318 || ! TEST_HARD_REG_BIT (lra_no_alloc_regs
, regno
))
1320 if ((ep
= get_elimination (*loc
)) != NULL
)
1324 /* Do (final if FINAL_P or first if FIRST_P) elimination in INSN. Add
1325 the insn for subsequent processing in the constraint pass, update
1328 process_insn_for_elimination (rtx_insn
*insn
, bool final_p
, bool first_p
)
1330 eliminate_regs_in_insn (insn
, final_p
, first_p
, 0);
1333 /* Check that insn changed its code. This is a case when a move
1334 insn becomes an add insn and we do not want to process the
1335 insn as a move anymore. */
1336 int icode
= recog (PATTERN (insn
), insn
, 0);
1338 if (icode
>= 0 && icode
!= INSN_CODE (insn
))
1340 if (INSN_CODE (insn
) >= 0)
1341 /* Insn code is changed. It may change its operand type
1342 from IN to INOUT. Inform the subsequent assignment
1343 subpass about this situation. */
1344 check_and_force_assignment_correctness_p
= true;
1345 INSN_CODE (insn
) = icode
;
1346 lra_update_insn_recog_data (insn
);
1348 lra_update_insn_regno_info (insn
);
1349 lra_push_insn (insn
);
1350 lra_set_used_insn_alternative (insn
, LRA_UNKNOWN_ALT
);
1354 /* Entry function to do final elimination if FINAL_P or to update
1355 elimination register offsets (FIRST_P if we are doing it the first
1358 lra_eliminate (bool final_p
, bool first_p
)
1361 bitmap_head insns_with_changed_offsets
;
1363 class lra_elim_table
*ep
;
1365 gcc_assert (! final_p
|| ! first_p
);
1367 timevar_push (TV_LRA_ELIMINATE
);
1370 init_elimination ();
1372 bitmap_initialize (&insns_with_changed_offsets
, ®_obstack
);
1377 update_reg_eliminate (&insns_with_changed_offsets
);
1378 gcc_assert (bitmap_empty_p (&insns_with_changed_offsets
));
1380 /* We change eliminable hard registers in insns so we should do
1381 this for all insns containing any eliminable hard
1383 for (ep
= reg_eliminate
; ep
< ®_eliminate
[NUM_ELIMINABLE_REGS
]; ep
++)
1384 if (elimination_map
[ep
->from
] != NULL
)
1385 bitmap_ior_into (&insns_with_changed_offsets
,
1386 &lra_reg_info
[ep
->from
].insn_bitmap
);
1388 else if (! update_reg_eliminate (&insns_with_changed_offsets
))
1389 goto lra_eliminate_done
;
1390 if (lra_dump_file
!= NULL
)
1392 fprintf (lra_dump_file
, "New elimination table:\n");
1393 print_elim_table (lra_dump_file
);
1395 EXECUTE_IF_SET_IN_BITMAP (&insns_with_changed_offsets
, 0, uid
, bi
)
1396 /* A dead insn can be deleted in process_insn_for_elimination. */
1397 if (lra_insn_recog_data
[uid
] != NULL
)
1398 process_insn_for_elimination (lra_insn_recog_data
[uid
]->insn
,
1400 bitmap_clear (&insns_with_changed_offsets
);
1403 timevar_pop (TV_LRA_ELIMINATE
);