lra_elim_table Class Reference

Collaboration diagram for lra_elim_table:

Data Fields
int	from
int	to
poly_int64	previous_offset
poly_int64	offset
bool	can_eliminate
bool	prev_can_eliminate
rtx	from_rtx
rtx	to_rtx

Detailed Description

Code for RTL register eliminations.
   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/>.   

Eliminable registers (like a soft argument or frame pointer) are
  widely used in RTL.  These eliminable registers should be replaced
  by real hard registers (like the stack pointer or hard frame
  pointer) plus some offset.  The offsets usually change whenever the
  stack is expanded.  We know the final offsets only at the very end
  of LRA.

  Within LRA, we usually keep the RTL in such a state that the
  eliminable registers can be replaced by just the corresponding hard
  register (without any offset).  To achieve this we should add the
  initial elimination offset at the beginning of LRA and update the
  offsets whenever the stack is expanded.  We need to do this before
  every constraint pass because the choice of offset often affects
  whether a particular address or memory constraint is satisfied.

  We keep RTL code at most time in such state that the virtual
  registers can be changed by just the corresponding hard registers
  (with zero offsets) and we have the right RTL code.   To achieve this
  we should add initial offset at the beginning of LRA work and update
  offsets after each stack expanding.   But actually we update virtual
  registers to the same virtual registers + corresponding offsets
  before every constraint pass because it affects constraint
  satisfaction (e.g. an address displacement became too big for some
  target).

  The final change of eliminable registers to the corresponding hard
  registers are done at the very end of LRA when there were no change
  in offsets anymore:

             fp + 42     =>     sp + 42

This structure is used to record information about hard register
eliminations.   

Field Documentation

can_eliminate

bool lra_elim_table::can_eliminate

Referenced by init_elim_table().

from

int lra_elim_table::from

Referenced by get_elimination().

from_rtx

rtx lra_elim_table::from_rtx

Referenced by get_elimination().

offset

poly_int64 lra_elim_table::offset

Referenced by get_elimination().

prev_can_eliminate

bool lra_elim_table::prev_can_eliminate

Referenced by init_elim_table().

previous_offset

poly_int64 lra_elim_table::previous_offset

Referenced by init_elim_table().

to

int lra_elim_table::to

Referenced by get_elimination(), and lra_eliminate_regs_1().

to_rtx

rtx lra_elim_table::to_rtx

Referenced by get_elimination().

---

The documentation for this class was generated from the following file:

• lra-eliminations.cc