GCC Middle and Back End API Reference
rtx_reuse_manager Class Reference

#include <print-rtl.h>

Collaboration diagram for rtx_reuse_manager:

Public Member Functions

 rtx_reuse_manager ()
void preprocess (const_rtx x)
bool has_reuse_id (const_rtx x, int *out)
bool seen_def_p (int reuse_id)
void set_seen_def (int reuse_id)

Private Attributes

hash_map< const_rtx, int > m_rtx_occurrence_count
hash_map< const_rtx, int > m_rtx_reuse_ids
auto_bitmap m_defs_seen
int m_next_id

Detailed Description

For some rtx codes (such as SCRATCH), instances are defined to only be
equal for pointer equality: two distinct SCRATCH instances are non-equal.
copy_rtx preserves this equality by reusing the SCRATCH instance.

For example, in this x86 instruction:

   (cinsn (set (mem/v:BLK (scratch:DI) [0  A8])
                 (unspec:BLK [
                         (mem/v:BLK (scratch:DI) [0  A8])
                     ] UNSPEC_MEMORY_BLOCKAGE)) "test.c":2

the two instances of "(scratch:DI)" are actually the same underlying
rtx pointer (and thus "equal"), and the insn will only be recognized
(as "*memory_blockage") if this pointer-equality is preserved.

To be able to preserve this pointer-equality when round-tripping
through dumping/loading the rtl, we need some syntax.  The first
time a reused rtx is encountered in the dump, we prefix it with
a reuse ID:


Subsequent references to the rtx in the dump can be expressed using
"reuse_rtx" e.g.:

   (reuse_rtx 0)

This class is responsible for tracking a set of reuse IDs during a dump.

Dumping with reuse-support is done in two passes:

(a) a first pass in which "preprocess" is called on each top-level rtx
    to be seen in the dump.  This traverses the rtx and its descendents,
    identifying rtx that will be seen more than once in the actual dump,
    and assigning them reuse IDs.

(b) the actual dump, via print_rtx etc.  print_rtx detect the presence
    of a live rtx_reuse_manager and uses it if there is one.  Any rtx
    that were assigned reuse IDs will be printed with it the first time
    that they are seen, and then printed as "(reuse_rtx ID)" subsequently.

The first phase is needed since otherwise there would be no way to tell
if an rtx will be reused when first encountering it.   

Constructor & Destructor Documentation

◆ rtx_reuse_manager()

rtx_reuse_manager::rtx_reuse_manager ( )
rtx_reuse_manager's ctor.   

Member Function Documentation

◆ has_reuse_id()

bool rtx_reuse_manager::has_reuse_id ( const_rtx x,
int * out )
Return true iff X has been assigned a reuse ID.  If it has,
and OUT is non-NULL, then write the reuse ID to *OUT.   

References m_rtx_reuse_ids.

Referenced by rtx_writer::print_rtx().

◆ preprocess()

void rtx_reuse_manager::preprocess ( const_rtx x)
Traverse X and its descendents, determining if we see any rtx more than
once.  Any rtx suitable for "reuse_rtx" that is seen more than once is
assigned an ID.   

References count, FOR_EACH_SUBRTX, m_next_id, m_rtx_occurrence_count, m_rtx_reuse_ids, and uses_rtx_reuse_p().

◆ seen_def_p()

bool rtx_reuse_manager::seen_def_p ( int reuse_id)
Determine if set_seen_def has been called for the given reuse ID.   

References bitmap_bit_p, and m_defs_seen.

Referenced by rtx_writer::print_rtx().

◆ set_seen_def()

void rtx_reuse_manager::set_seen_def ( int reuse_id)
Record that the definition of the given reuse ID has been seen.   

References bitmap_set_bit, and m_defs_seen.

Referenced by rtx_writer::print_rtx().

Field Documentation

◆ m_defs_seen

auto_bitmap rtx_reuse_manager::m_defs_seen

Referenced by seen_def_p(), and set_seen_def().

◆ m_next_id

int rtx_reuse_manager::m_next_id

Referenced by preprocess().

◆ m_rtx_occurrence_count

hash_map<const_rtx, int> rtx_reuse_manager::m_rtx_occurrence_count

Referenced by preprocess().

◆ m_rtx_reuse_ids

hash_map<const_rtx, int> rtx_reuse_manager::m_rtx_reuse_ids

Referenced by has_reuse_id(), and preprocess().

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