141 lines
4.8 KiB
C++
141 lines
4.8 KiB
C++
// Definition of private classes for RTL SSA -*- C++ -*-
|
|
// Copyright (C) 2020-2022 Free Software Foundation, Inc.
|
|
//
|
|
// 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/>.
|
|
|
|
namespace rtl_ssa {
|
|
|
|
// Information about a basic block's phi nodes. This class is only used when
|
|
// constructing the SSA form, it isn't meant to be kept up-to-date.
|
|
class function_info::bb_phi_info
|
|
{
|
|
public:
|
|
// The set of registers that need phi nodes.
|
|
bitmap_head regs;
|
|
|
|
// The number of registers in REGS.
|
|
unsigned int num_phis;
|
|
|
|
// The number of inputs to each phi node. Caching the information here
|
|
// is at best a minor optimisation, but it fills a 32-bit hole that would
|
|
// otherwise exist on 64-bit hosts.
|
|
unsigned int num_preds;
|
|
|
|
// An array of all the phi inputs for this block. It lists all inputs
|
|
// from the first incoming edge followed by all inputs for the next
|
|
// incoming edge, and so on. The inputs for a given edge are sorted
|
|
// by increasing register number.
|
|
set_info **inputs;
|
|
};
|
|
|
|
// Information used while constructing the SSA form and discarded
|
|
// afterwards.
|
|
class function_info::build_info
|
|
{
|
|
public:
|
|
build_info (unsigned int, unsigned int);
|
|
~build_info ();
|
|
|
|
set_info *current_reg_value (unsigned int) const;
|
|
set_info *current_mem_value () const;
|
|
|
|
void record_reg_def (def_info *);
|
|
void record_mem_def (def_info *);
|
|
|
|
// The block that we're currently processing.
|
|
bb_info *current_bb;
|
|
|
|
// The EBB that contains CURRENT_BB.
|
|
ebb_info *current_ebb;
|
|
|
|
// Except for the local exception noted below:
|
|
//
|
|
// - If register R has been defined in the current EBB, LAST_ACCESS[R + 1]
|
|
// is the last definition of R in the EBB.
|
|
//
|
|
// - Otherwise, if the current EBB is dominated by a definition of R,
|
|
// LAST_ACCESS[R + 1] is the nearest dominating definition.
|
|
//
|
|
// - Otherwise, LAST_ACCESS[R + 1] is null.
|
|
//
|
|
// Similarly:
|
|
//
|
|
// - If the current EBB has defined memory, LAST_ACCESS[0] is the last
|
|
// definition of memory in the EBB.
|
|
//
|
|
// - Otherwise LAST_ACCESS[0] is the value of memory that is live on
|
|
// - entry to the EBB.
|
|
//
|
|
// The exception is that while building instructions, LAST_ACCESS[I]
|
|
// can temporarily be the use of regno I - 1 by that instruction.
|
|
auto_vec<access_info *> last_access;
|
|
|
|
// A bitmap used to hold EBB_LIVE_IN_FOR_DEBUG.
|
|
auto_bitmap tmp_ebb_live_in_for_debug;
|
|
|
|
// If nonnull, a bitmap of registers that are live on entry to this EBB,
|
|
// with a tree view for quick lookup. This bitmap is calculated lazily
|
|
// and is only used if MAY_HAVE_DEBUG_INSNS.
|
|
bitmap ebb_live_in_for_debug;
|
|
|
|
// The set of registers that might need to have phis associated with them.
|
|
// Registers outside this set are known to have a single definition that
|
|
// dominates all uses.
|
|
//
|
|
// Before RA, about 5% of registers are typically in the set.
|
|
auto_sbitmap potential_phi_regs;
|
|
|
|
// A sparse bitmap representation of POTENTIAL_PHI_REGS. Only used if
|
|
// MAY_HAVE_DEBUG_INSNS.
|
|
auto_bitmap potential_phi_regs_for_debug;
|
|
|
|
// The set of registers that have been defined so far in the current EBB.
|
|
auto_bitmap ebb_def_regs;
|
|
|
|
// BB_PHIS[B] describes the phis for basic block B.
|
|
auto_vec<bb_phi_info> bb_phis;
|
|
|
|
// BB_MEM_LIVE_OUT[B] is the memory value that is live on exit from
|
|
// basic block B.
|
|
auto_vec<set_info *> bb_mem_live_out;
|
|
|
|
// BB_TO_RPO[B] gives the position of block B in a reverse postorder
|
|
// of the CFG. The RPO is a tweaked version of the one normally
|
|
// returned by pre_and_rev_post_order_compute, with all blocks in
|
|
// an EBB having consecutive positions.
|
|
auto_vec<int> bb_to_rpo;
|
|
|
|
// This stack is divided into sections, with one section for the
|
|
// current basic block and one section for each dominating block.
|
|
// Each element is a register definition.
|
|
//
|
|
// If the section for block B contains a definition D of a register R,
|
|
// then one of two things is true:
|
|
//
|
|
// - D occurs in B and no definition of R dominates B.
|
|
// - D dominates B and is the nearest dominating definition of R.
|
|
//
|
|
// The two cases are distinguished by the value of D->bb ().
|
|
auto_vec<def_info *> def_stack;
|
|
|
|
// The top of this stack records the start of the current block's
|
|
// section in DEF_STACK.
|
|
auto_vec<unsigned int> old_def_stack_limit;
|
|
};
|
|
|
|
}
|