#include "config.h"#include "system.h"#include "coretypes.h"#include "backend.h"#include "target.h"#include "rtl.h"#include "df.h"#include "insn-config.h"#include "regs.h"#include "memmodel.h"#include "ira.h"#include "recog.h"#include "output.h"#include "cfgrtl.h"#include "lra.h"#include "lra-int.h"
Data Structures | |
| struct | pseudo_slot |
| class | slot |
Functions | |
| static void | assign_mem_slot (int i) |
| static int | regno_freq_compare (const void *v1p, const void *v2p) |
| static int | pseudo_reg_slot_compare (const void *v1p, const void *v2p) |
| static int | assign_spill_hard_regs (int *pseudo_regnos, int n) |
| static void | add_pseudo_to_slot (int regno, int slot_num) |
| static void | assign_stack_slot_num_and_sort_pseudos (int *pseudo_regnos, int n) |
| static bool | remove_pseudos (rtx *loc, rtx_insn *insn) |
| static void | spill_pseudos (void) |
| bool | lra_need_for_scratch_reg_p (void) |
| bool | lra_need_for_spills_p (void) |
| void | lra_spill (void) |
| static bool | alter_subregs (rtx *loc, bool final_p) |
| void | lra_final_code_change (void) |
Variables | |
| static int | regs_num |
| static rtx * | spill_hard_reg |
| static struct pseudo_slot * | pseudo_slots |
| static class slot * | slots |
| static int | slots_num |
Function Documentation
◆ add_pseudo_to_slot()
Add pseudo REGNO to slot SLOT_NUM.
References slot::align, pseudo_slot::first, GET_MODE_SIZE(), slot::live_ranges, lra_copy_live_range_list(), lra_merge_live_ranges(), lra_reg_info, MAX, pseudo_slot::mem, pseudo_slot::next, NULL, NULL_RTX, PSEUDO_REGNO_MODE, pseudo_slots, slot::regno, slot::size, pseudo_slot::slot_num, slots, spill_slot_alignment(), and wider_subreg_mode().
Referenced by assign_stack_slot_num_and_sort_pseudos().
◆ alter_subregs()
Apply alter_subreg for subregs of regs in *LOC. Use FINAL_P for alter_subreg calls. Return true if any subreg of reg is processed.
References alter_subreg(), alter_subregs(), GET_CODE, GET_RTX_FORMAT, GET_RTX_LENGTH, ggc_alloc(), i, lra_assert, NULL_RTX, REG_P, REGNO, SUBREG_REG, XEXP, XVECEXP, and XVECLEN.
Referenced by alter_subregs(), and lra_final_code_change().
◆ assign_mem_slot()
Set up memory of the spilled pseudo I. The function can allocate the corresponding stack slot if it is not done yet.
References adjust_address_nv, slot::align, assign_stack_local(), GET_MODE, GET_MODE_SIZE(), ggc_alloc(), i, lra_assert, lra_reg_info, pseudo_slot::mem, slot::mem, NULL_RTX, PSEUDO_REGNO_BYTES, pseudo_slots, REG_P, reg_renumber, regno_reg_rtx, set_mem_attrs_for_spill(), slot::size, pseudo_slot::slot_num, slots, subreg_size_lowpart_offset(), and wider_subreg_mode().
Referenced by lra_spill().
◆ assign_spill_hard_regs()
|
static |
Assign spill hard registers to N pseudos in PSEUDO_REGNOS which is sorted in order of highest frequency first. Put the pseudos which did not get a spill hard register at the beginning of array PSEUDO_REGNOS. Return the number of such pseudos.
References add_to_hard_reg_set(), lra_reg::biggest_mode, bitmap_bit_p, bitmap_intersect_compl_p(), bitmap_set_bit, cfun, lra_reg::conflict_hard_regs, DEBUG_INSN_P, df_set_regs_ever_live(), eliminable_regset, FOR_BB_INSNS, FOR_EACH_BB_FN, free(), gen_raw_REG(), ggc_alloc(), slot::hard_regno, hard_regno_nregs(), hard_regs_spilled_into, i, INSN_UID(), ira_class_hard_regs, ira_class_hard_regs_num, slot::live_ranges, lra_assert, lra_dump_file, lra_get_allocno_class(), lra_get_regno_hard_regno(), lra_live_max_point, lra_no_alloc_regs, lra_reg_info, lra_reg_spill_p, lra_live_range::next, nr, NULL, NULL_RTX, overlaps_hard_reg_set_p(), PSEUDO_REGNO_MODE, r, reg_obstack, REG_P, slot::regno, regs_num, regstat_get_setjmp_crosses(), SET_DEST, SET_SRC, single_set(), spill_hard_reg, targetm, and TEST_HARD_REG_BIT.
Referenced by lra_spill().
◆ assign_stack_slot_num_and_sort_pseudos()
Assign stack slot numbers to pseudos in array PSEUDO_REGNOS of length N. Sort pseudos in PSEUDO_REGNOS for subsequent assigning memory stack slots.
References add_pseudo_to_slot(), slot::align, GET_MODE_SIZE(), ggc_alloc(), slot::hard_regno, i, slot::live_ranges, lra_intersected_live_ranges_p(), lra_reg_info, slot::mem, NULL, NULL_RTX, pseudo_reg_slot_compare(), PSEUDO_REGNO_MODE, qsort, slot::regno, slot::size, slots, slots_num, and wider_subreg_mode().
Referenced by lra_spill().
◆ lra_final_code_change()
Final change of pseudos got hard registers into the corresponding hard registers and removing temporary clobbers.
References alter_subregs(), cfun, const1_rtx, DEBUG_INSN_P, delete_insn(), FOR_BB_INSNS_SAFE, FOR_EACH_BB_FN, GET_CODE, ggc_alloc(), i, INSN_P, lra_assert, lra_get_insn_recog_data(), lra_get_regno_hard_regno(), lra_invalidate_insn_data(), lra_reg_info, LRA_TEMP_CLOBBER_P, lra_update_dup(), lra_update_operator_dups(), max_reg_num(), max_regno, lra_insn_reg::next, NONJUMP_INSN_P, lra_reg::nrefs, NULL, PATTERN(), REG_P, lra_insn_reg::regno, REGNO, regno_reg_rtx, SET, SET_DEST, SET_REGNO, SET_SRC, single_set(), and XEXP.
Referenced by lra().
◆ lra_need_for_scratch_reg_p()
Return true if we need scratch reg assignments.
References ggc_alloc(), i, ira_former_scratch_p(), lra_get_regno_hard_regno(), lra_reg_info, max_reg_num(), and max_regno.
Referenced by lra().
◆ lra_need_for_spills_p()
Return true if we need to change some pseudos into memory.
References ggc_alloc(), i, ira_former_scratch_p(), lra_get_regno_hard_regno(), lra_reg_info, max_reg_num(), and max_regno.
Referenced by lra().
◆ lra_spill()
Change spilled pseudos into memory or spill hard regs. Put changed insns on the constraint stack (these insns will be considered on the next constraint pass). The changed insns are all insns in which pseudos were changed.
References assign_mem_slot(), assign_spill_hard_regs(), assign_stack_local(), assign_stack_slot_num_and_sort_pseudos(), crtl, free(), GET_MODE, GET_MODE_SIZE(), ggc_alloc(), i, ira_former_scratch_p(), lra_assert, lra_dump_file, lra_get_regno_hard_regno(), lra_reg_info, lra_update_fp2sp_elimination(), max_reg_num(), pseudo_slot::mem, pseudo_slot::next, NULL, NULL_RTX, print_dec(), pseudo_slots, qsort, regno_freq_compare(), regs_num, SIGNED, slots, slots_num, spill_hard_reg, and spill_pseudos().
Referenced by lra().
◆ pseudo_reg_slot_compare()
Sort pseudos according to their slots, putting the slots in the order that they should be allocated. First prefer to group slots with variable sizes together and slots with constant sizes together, since that usually makes them easier to address from a common anchor point. E.g. loads of polynomial-sized registers tend to take polynomial offsets while loads of constant-sized registers tend to take constant (non-polynomial) offsets. Next, slots with lower numbers have the highest priority and should get the smallest displacement from the stack or frame pointer (whichever is being used). The first allocated slot is always closest to the frame pointer, so prefer lower slot numbers when frame_pointer_needed. If the stack and frame grow in the same direction, then the first allocated slot is always closest to the initial stack pointer and furthest away from the final stack pointer, so allocate higher numbers first when using the stack pointer in that case. The reverse is true if the stack and frame grow in opposite directions.
References FRAME_GROWS_DOWNWARD, frame_pointer_needed, GET_MODE_SIZE(), ggc_alloc(), poly_int< N, C >::is_constant(), lra_reg_info, pseudo_slots, slot::size, pseudo_slot::slot_num, slots, and STACK_GROWS_DOWNWARD.
Referenced by assign_stack_slot_num_and_sort_pseudos().
◆ regno_freq_compare()
Sort pseudos according their usage frequencies.
References ggc_alloc(), and lra_reg_info.
Referenced by lra_spill().
◆ remove_pseudos()
Recursively process LOC in INSN and change spilled pseudos to the corresponding memory or spilled hard reg. Ignore spilled pseudos created from the scratches. Return true if the pseudo nrefs equal to 0 (don't change the pseudo in this case). Otherwise return false.
References alter_subreg(), copy_rtx(), GET_CODE, GET_MODE, GET_RTX_FORMAT, GET_RTX_LENGTH, ggc_alloc(), i, INSN_UID(), ira_former_scratch_p(), lra_dump_file, lra_eliminate_regs_1(), lra_get_regno_hard_regno(), lra_reg_info, lra_update_insn_recog_data(), pseudo_slot::mem, NULL, NULL_RTX, pseudo_slots, REG_P, REGNO, remove_pseudos(), spill_hard_reg, SUBREG_REG, XEXP, XVECEXP, and XVECLEN.
Referenced by lra_undo_inheritance(), remove_inheritance_pseudos(), remove_pseudos(), and spill_pseudos().
◆ spill_pseudos()
Convert spilled pseudos into their stack slots or spill hard regs, put insns to process on the constraint stack (that is all insns in which pseudos were changed to memory or spill hard regs).
References bitmap_and_compl_into(), bitmap_bit_p, bitmap_ior_into(), bitmap_set_bit, CALL_INSN_FUNCTION_USAGE, CALL_P, cfun, DEBUG_INSN_P, df_get_live_in(), df_get_live_out(), FOR_BB_INSNS_SAFE, FOR_EACH_BB_FN, gen_rtx_UNKNOWN_VAR_LOC, ggc_alloc(), i, INSN_UID(), INSN_VAR_LOCATION_LOC, ira_former_scratch_p(), lra_assert, lra_dump_file, lra_get_regno_hard_regno(), lra_invalidate_insn_data(), lra_push_insn(), lra_reg_info, lra_reg_spill_p, lra_set_used_insn_alternative(), LRA_UNKNOWN_ALT, NULL, NULL_RTX, PATTERN(), REG_NOTE_KIND, REG_NOTES, reg_obstack, regs_num, remove_pseudos(), spilled_pseudos, targetm, and XEXP.
Referenced by lra_spill(), lra_update_fp2sp_elimination(), and update_reg_eliminate().
Variable Documentation
◆ pseudo_slots
|
static |
The stack slots for each spilled pseudo. Indexed by regnos.
Referenced by add_pseudo_to_slot(), assign_mem_slot(), lra_spill(), pseudo_reg_slot_compare(), and remove_pseudos().
◆ regs_num
|
static |
Change pseudos by memory. Copyright (C) 2010-2024 Free Software Foundation, Inc. Contributed by Vladimir Makarov <vmakarov@redhat.com>. This file is part of GCC. GCC is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 3, or (at your option) any later version. GCC is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with GCC; see the file COPYING3. If not see <http://www.gnu.org/licenses/>.
This file contains code for a pass to change spilled pseudos into
memory.
The pass creates necessary stack slots and assigns spilled pseudos
to the stack slots in following way:
for all spilled pseudos P most frequently used first do
for all stack slots S do
if P doesn't conflict with pseudos assigned to S then
assign S to P and goto to the next pseudo process
end
end
create new stack slot S and assign P to S
end
The actual algorithm is bit more complicated because of different
pseudo sizes.
After that the code changes spilled pseudos (except ones created
from scratches) by corresponding stack slot memory in RTL.
If at least one stack slot was created, we need to run more passes
because we have new addresses which should be checked and because
the old address displacements might change and address constraints
(or insn memory constraints) might not be satisfied any more.
For some targets, the pass can spill some pseudos into hard
registers of different class (usually into vector registers)
instead of spilling them into memory if it is possible and
profitable. Spilling GENERAL_REGS pseudo into SSE registers for
Intel Corei7 is an example of such optimization. And this is
actually recommended by Intel optimization guide.
The file also contains code for final change of pseudos on hard
regs correspondingly assigned to them. Max regno at the start of the pass.
Referenced by assign_spill_hard_regs(), lra_spill(), and spill_pseudos().
◆ slots
Array containing info about the stack slots. The array element is indexed by the stack slot number in the range [0..slots_num).
Referenced by add_pseudo_to_slot(), assign_mem_slot(), assign_stack_slot_num_and_sort_pseudos(), lra_spill(), make_return_insns(), and pseudo_reg_slot_compare().
◆ slots_num
|
static |
The number of the stack slots currently existing.
Referenced by assign_stack_slot_num_and_sort_pseudos(), and lra_spill().
◆ spill_hard_reg
|
static |
Map spilled regno -> hard regno used instead of memory for spilling.
Referenced by assign_spill_hard_regs(), lra_spill(), reload(), remove_pseudos(), and update_eliminables_and_spill().
