#include "config.h"#include "system.h"#include "coretypes.h"#include "tm.h"#include "hard-reg-set.h"#include "rtl.h"#include "tm_p.h"#include "regs.h"#include "insn-config.h"#include "insn-codes.h"#include "recog.h"#include "output.h"#include "addresses.h"#include "target.h"#include "function.h"#include "expr.h"#include "basic-block.h"#include "except.h"#include "optabs.h"#include "df.h"#include "ira.h"#include "rtl-error.h"#include "lra-int.h"
Data Structures | |
| struct | elim_table |
| struct | elim_table_1 |
Macros | |
| #define | NUM_ELIMINABLE_REGS ARRAY_SIZE (reg_eliminate_1) |
Functions | |
| static void | print_elim_table () |
| void | lra_debug_elim_table () |
| static void | setup_can_eliminate () |
| static void | setup_elimination_map () |
| static rtx | form_sum () |
| int | lra_get_elimination_hard_regno () |
| static struct elim_table * | get_elimination () |
| rtx | lra_eliminate_regs_1 (rtx x, enum machine_mode mem_mode, bool subst_p, bool update_p, bool full_p) |
| rtx | lra_eliminate_regs (rtx x, enum machine_mode mem_mode, rtx insn) |
| static void | mark_not_eliminable () |
| static rtx | remove_reg_equal_offset_note () |
| static void | eliminate_regs_in_insn () |
| static void | spill_pseudos () |
| static bool | update_reg_eliminate () |
| static void | init_elim_table () |
| void | lra_init_elimination () |
| void | lra_eliminate_reg_if_possible () |
| static void | process_insn_for_elimination () |
| void | lra_eliminate () |
Variables | |
| static struct elim_table * | reg_eliminate = 0 |
| static struct elim_table_1 | reg_eliminate_1 [] |
| static struct elim_table * | elimination_map [FIRST_PSEUDO_REGISTER] |
| static struct elim_table | self_elim_table |
| static HOST_WIDE_INT | self_elim_offsets [FIRST_PSEUDO_REGISTER] |
| static rtx | eliminable_reg_rtx [FIRST_PSEUDO_REGISTER] |
Macro Definition Documentation
| #define NUM_ELIMINABLE_REGS ARRAY_SIZE (reg_eliminate_1) |
Referenced by remove_reg_equal_offset_note(), and spill_pseudos().
Function Documentation
|
static |
Scan INSN and eliminate all eliminable hard registers in it.
If REPLACE_P is true, do the replacement destructively. Also delete the insn as dead it if it is setting an eliminable register.
If REPLACE_P is false, just update the offsets while keeping the base register the same. Attach the note about used elimination for insns setting frame pointer to update elimination easy (without parsing already generated elimination insns to find offset previously used) in future.
Check for setting an eliminable register.
If this is setting the frame pointer register to the
hardware frame pointer register and this is an
elimination that will be done (tested above), this
insn is really adjusting the frame pointer downward
to compensate for the adjustment done before a
nonlocal goto. First see if this insn remains valid when we
make the change. If not, keep the INSN_CODE
the same and let the constraint pass fit it
up. Add offset note for future updates.
This insn isn't serving a useful purpose. We delete it
when REPLACE is set. We allow one special case which happens to work on all machines we currently support: a single set with the source or a REG_EQUAL note being a PLUS of an eliminable register and a constant.
First see if the source is of the form (plus (...) CST).
Check that the first operand of the PLUS is a hard reg or
the lowpart subreg of one. If we have a nonzero offset, and the source is already a
simple REG, the following transformation would increase
the cost of the insn by replacing a simple REG with (plus
(reg sp) CST). So try only when we already had a PLUS
before. First see if this insn remains valid when we make the
change. If not, try to replace the whole pattern
with a simple set (this may help if the original insn
was a PARALLEL that was only recognized as single_set
due to REG_UNUSED notes). If this isn't valid
either, keep the INSN_CODE the same and let the
constraint pass fix it up. This can't have an effect on elimination offsets, so skip
right to the end. Eliminate all eliminable registers occurring in operands that can be handled by the constraint pass.
For an asm statement, every operand is eliminable.
Check for setting a hard register that we know about.
If we are assigning to a hard register that can be
eliminated, it must be as part of a PARALLEL, since
the code above handles single SETs. This reg can not
be longer eliminated – it is forced by
mark_not_eliminable. Companion to the above plus substitution, we can allow
invariants as the source of a plain move. Substitute the operands; the new values are in the substed_operand array.
If we had a move insn but now we don't, re-recognize it. This will cause spurious re-recognition if the old move had a PARALLEL since the new one still will, but we can't call single_set without having put new body into the insn and the re-recognition won't hurt in this rare case.
Referenced by init_elim_table(), maybe_fix_stack_asms(), and spill_hard_reg().
|
static |
Compute the sum of X and Y, making canonicalizations assumed in an address, namely: sum constant integers, surround the sum of two constants with a CONST, put the constant as the second operand, and group the constant on the outermost sum.
This routine assumes both inputs are already in canonical form.
Note that if the operands of Y are specified in the opposite order in the recursive calls below, infinite recursion will occur.
If both constant, encapsulate sum. Otherwise, just form sum. A constant will have been placed second.
Referenced by set_label_offsets(), and setup_elimination_map().
|
staticread |
Return elimination which will be used for hard reg REG, NULL otherwise.
This is an iteration to restore offsets just after HARD_REGNO stopped to be eliminable.
References CASE_CONST_ANY, and GET_CODE.
|
static |
Initialize the table of hard registers to eliminate. Pre-condition: global flag frame_pointer_needed has been set before calling this function.
Initiate member values which will be never changed.
Count the number of eliminable registers and build the FROM and TO REG rtx's. Note that code in gen_rtx_REG will cause, e.g., gen_rtx_REG (Pmode, STACK_POINTER_REGNUM) to equal stack_pointer_rtx. We depend on this.
References eliminate_regs_in_insn(), INSN_CODE, lra_push_insn(), lra_set_used_insn_alternative(), lra_update_insn_recog_data(), lra_update_insn_regno_info(), PATTERN, and recog().
| void lra_debug_elim_table | ( | void | ) |
Print info about elimination table to stderr.
| void lra_eliminate | ( | ) |
Entry function to do final elimination if FINAL_P or to update elimination register offsets.
We change eliminable hard registers in insns so we should do this for all insns containing any eliminable hard register.
A dead insn can be deleted in process_insn_for_elimination.
| void lra_eliminate_reg_if_possible | ( | ) |
Eliminate hard reg given by its location LOC.
This function is used externally in subsequent passes of GCC. It always does a full elimination of X.
| rtx lra_eliminate_regs_1 | ( | rtx | x, |
| enum machine_mode | mem_mode, | ||
| bool | subst_p, | ||
| bool | update_p, | ||
| bool | full_p | ||
| ) |
Scan X and replace any eliminable registers (such as fp) with a replacement (such as sp) if SUBST_P, plus an offset. The offset is a change in the offset between the eliminable register and its substitution if UPDATE_P, or the full offset if FULL_P, or otherwise zero.
MEM_MODE is the mode of an enclosing MEM. We need this to know how much to adjust a register for, e.g., PRE_DEC. Also, if we are inside a MEM, we are allowed to replace a sum of a hard register and the constant zero with the hard register, which we cannot do outside a MEM. In addition, we need to record the fact that a hard register is referenced outside a MEM.
Alternatively, INSN may be a note (an EXPR_LIST or INSN_LIST). That's used when we eliminate in expressions stored in notes.
First handle the case where we encounter a bare hard register
that is eliminable. Replace it with a PLUS.
If this is the sum of an eliminable register and a constant, rework
the sum. If the hard register is not eliminable, we are done since
the other operand is a constant. If this is part of an address, we want to bring any constant
to the outermost PLUS. We will do this by doing hard
register replacement in our operands and seeing if a constant
shows up in one of them.
Note that there is no risk of modifying the structure of the
insn, since we only get called for its operands, thus we are
either modifying the address inside a MEM, or something like
an address operand of a load-address insn. If this is the product of an eliminable hard register and a
constant, apply the distribute law and move the constant out
so that we have (plus (mult ..) ..). This is needed in order
to keep load-address insns valid. This case is pathological.
We ignore the possibility of overflow here. ... fall through ...
See comments before PLUS about handling MINUS.
If we have something in XEXP (x, 0), the usual case,
eliminate it. If this is a REG_DEAD note, it is not valid anymore.
Using the eliminated version could result in creating a
REG_DEAD note for the stack or frame pointer. ... fall through ...
Now do eliminations in the rest of the chain. If this was
an EXPR_LIST, this might result in allocating more memory than is
strictly needed, but it simplifies the code. We do not support elimination of a register that is modified.
elimination_effects has already make sure that this does not
happen. We do not support elimination of a hard register that is
modified. LRA has already make sure that this does not
happen. The only remaining case we need to consider here is
that the increment value may be an eliminable register. Our only special processing is to pass the mode of the MEM to our
recursive call and copy the flags. While we are here, handle this
case more efficiently. Handle insn_list USE that a call to a pure function may generate.
Process each of our operands recursively. If any have changed, make a copy of the rtx.
References elim_table::from_rtx, elim_table::offset, plus_constant(), elim_table::previous_offset, elim_table::to, and elim_table::to_rtx.
Referenced by assign_mem_slot().
| int lra_get_elimination_hard_regno | ( | ) |
Return the current substitution hard register of the elimination of HARD_REGNO. If HARD_REGNO is not eliminable, return itself.
| void lra_init_elimination | ( | void | ) |
Entry function for initialization of elimination once per function.
References lra_dump_file, and print_elim_table().
|
static |
Scan rtx X for references to elimination source or target registers in contexts that would prevent the elimination from happening. Update the table of eliminables to reflect the changed state. MEM_MODE is the mode of an enclosing MEM rtx, or VOIDmode if not within a MEM.
If we modify the source of an elimination rule, disable
it. Do the same if it is the source and not the hard frame
register.
If using a hard register that is the source of an eliminate
we still think can be performed, note it cannot be
performed since we don't know how this hard register is
used. If clobbering a hard register that is the replacement
register for an elimination we still think can be
performed, note that it cannot be performed. Otherwise, we
need not be concerned about it. Check for setting a hard register that we know about.
See if this is setting the replacement hard register for
an elimination.
If DEST is the hard frame pointer, we do nothing because
we assume that all assignments to the frame pointer are
for non-local gotos and are being done at a time when
they are valid and do not disturb anything else. Some
machines want to eliminate a fake argument pointer (or
even a fake frame pointer) with either the real frame
pointer or the stack pointer. Assignments to the hard
frame pointer must not prevent this elimination.
|
static |
Print info about elimination table to file F.
Referenced by lra_init_elimination().
|
static |
Do (final if FINAL_P) elimination in INSN. Add the insn for subsequent processing in the constraint pass, update the insn info.
Check that insn changed its code. This is a case when a move insn becomes an add insn and we do not want to process the insn as a move anymore.
|
static |
Find offset equivalence note for reg WHAT in INSN and return the found elmination offset. If the note is not found, return NULL. Remove the found note.
References elim_table::can_eliminate, CONST_INT_P, elim_table::from, elim_table::from_rtx, GET_CODE, HARD_FRAME_POINTER_REGNUM, HOST_WIDE_INT, NUM_ELIMINABLE_REGS, offset, SET_DEST, SET_SRC, elim_table::to, elim_table::to_rtx, and XEXP.
|
static |
Setup possibility of elimination in elimination table element EP to VALUE. Setup FRAME_POINTER_NEEDED if elimination from frame pointer to stack pointer is not possible anymore.
|
static |
Set up ELIMINATION_MAP of the currently used eliminations.
References CONST_INT_P, CONSTANT_P, form_sum(), GET_CODE, GET_MODE, INTVAL, plus_constant(), and XEXP.
|
static |
Spill pseudos which are assigned to hard registers in SET. Add affected insns for processing in the subsequent constraint pass.
References bitmap_ior_into(), elim_table::can_eliminate, elim_table::from, lra_reg::insn_bitmap, lra_assert, lra_dump_file, lra_reg_info, NULL, NUM_ELIMINABLE_REGS, elim_table::offset, elim_table::previous_offset, SET_HARD_REG_BIT, and elim_table::to.
|
static |
Update all offsets and possibility for elimination on eliminable registers. Spill pseudos assigned to registers which became uneliminable, update LRA_NO_ALLOC_REGS and ELIMINABLE_REG_SET. Add insns to INSNS_WITH_CHANGED_OFFSETS containing eliminable hard registers whose offsets should be changed. Return true if any elimination offset changed.
Clear self elimination offsets.
If it is a currently used elimination: update the previous
offset. It is possible that not eliminable register becomes
eliminable because we took other reasons into account to
set up eliminable regs in the initial set up. Just
ignore new eliminable registers. We cannot use this elimination anymore – find another
one. Mark that is not eliminable anymore.
Prevent the hard register into which we eliminate now
from the usage for pseudos. There is no elimination anymore just use the hard
register `from' itself. Setup self elimination
offset to restore the original offset values. Update offset when the eliminate offset have been
changed.
Variable Documentation
|
static |
Map: hard regno -> RTL presentation. RTL presentations of all potentially eliminable hard registers are stored in the map.
|
static |
Map: eliminable "from" register -> its current elimination, or NULL if none. The elimination table may contain more than one elimination for the same hard register, but this map specifies the one that we are currently using.
|
static |
The elimination table. Each array entry describes one possible way of eliminating a register in favor of another. If there is more than one way of eliminating a particular register, the most preferred should be specified first.
|
static |
|
static |
Offsets should be used to restore original offsets for eliminable hard register which just became not eliminable. Zero, otherwise.
|
static |
When an eliminable hard register becomes not eliminable, we use the following special structure to restore original offsets for the register.
