GCC Middle and Back End API Reference
rewrite_update_dom_walker Class Reference
Inheritance diagram for rewrite_update_dom_walker:
Collaboration diagram for rewrite_update_dom_walker:

Public Member Functions

 rewrite_update_dom_walker (cdi_direction direction)
virtual void before_dom_children (basic_block)
virtual void after_dom_children (basic_block)
void walk (basic_block)

Constructor & Destructor Documentation

rewrite_update_dom_walker::rewrite_update_dom_walker ( cdi_direction  direction)

Member Function Documentation

void rewrite_update_dom_walker::after_dom_children ( basic_block  bb)
   Called after visiting block BB.  Unwind BLOCK_DEFS_STACK to restore
   the current reaching definition of every name re-written in BB to
   the original reaching definition before visiting BB.  This
   unwinding must be done in the opposite order to what is done in
         NULL indicates the unwind stop point for this block (see

Reimplemented from dom_walker.

void rewrite_update_dom_walker::before_dom_children ( basic_block  bb)
   Initialization of block data structures for the incremental SSA
   update pass.  Create a block local stack of reaching definitions
   for new SSA names produced in this block (BLOCK_DEFS).  Register
   new definitions for every PHI node in the block.  
     Mark the unwind point for this block.  
     Mark the LHS if any of the arguments flows through an abnormal
     If any of the PHI nodes is a replacement for a name in
     OLD_SSA_NAMES or it's one of the names in NEW_SSA_NAMES, then
     register it as a new definition for its corresponding name.  Also
     register definitions for names whose underlying symbols are
     marked for renaming.  
             If LHS is a new name, register a new definition for all
             the names replaced by LHS.  
             If LHS is an OLD name, register it as a new definition
             for itself.  
     Step 2.  Rewrite every variable used in each statement in the block.  
     Step 3.  Update PHI nodes.  

Reimplemented from dom_walker.

void dom_walker::walk ( basic_block  bb)
     Walk the dominator tree.  
   Recursively walk the dominator tree.
   BB is the basic block we are currently visiting.  
         Don't worry about unreachable blocks.  
             Callback for subclasses to do custom things before we have walked
             the dominator children, but before we walk statements.  
             Mark the current BB to be popped out of the recursion stack
             once children are processed.  
         NULL is used to mark pop operations in the recursion stack.  
             Callback allowing subclasses to do custom things after we have
             walked dominator children, but before we walk statements.  

References bb_postorder, free(), inverted_post_order_compute(), and postorder_num.

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