---

liveness.h

Go to the documentation of this file.

#ifndef CBZ_LIVENESS_H
#define CBZ_LIVENESS_H

#include "pointers.h"

class livenessAnalyzer : public analysisProblem
{
private:

  typedef set< stmtNode * > stmt_liveness_set;
  typedef stmt_liveness_set::iterator stmt_liveness_set_p;

  typedef set< stmtLocation * > stmtlocation_liveness_set;
  typedef stmtlocation_liveness_set::iterator stmtlocation_liveness_set_p;

  typedef pair< basicblockLocation *, memoryBlock * > mergepoint_pair; 
  typedef set< mergepoint_pair > mergepoint_liveness_set;
  typedef mergepoint_liveness_set::iterator mergepoint_liveness_set_p;

  typedef list< bool > change_stack;

  stmt_liveness_set _live_stmts;

  stmtlocation_liveness_set _live_stmtlocations;

  mergepoint_liveness_set _live_mergepoints;

  memorydef_set _defs;

  bool _change;

  change_stack _change_stack;

  bool _debug;

public:

  livenessAnalyzer(bool debug);

  virtual string name() { return string("Liveness"); }

  void clear();

  bool isLive(stmtNode * stmt);

protected:

  void collectDefs(pointerValue & pointer);

  void addDef(memoryDef * def);

  bool determineLiveness();

  bool isLive(memoryUse * use, memoryBlock * owner);

  void setLive(stmtLocation * where);

  void setLive(basicblockLocation * where, memoryBlock * block);

public:

  virtual void at_index(stmtLocation * current,
                        binaryNode * binary,
                        pointerValue & left,
                        pointerValue & right,
                        pointerValue & result,
                        bool result_is_a_use);

  // -- Procedure calls

  virtual void at_call(stmtLocation * current, callNode * call,
                       pointerValue & call_target,
                       procNode * callee,
                       pointervalue_list & arguments,
                       pointerValue & return_val);

  virtual void at_heap(stmtLocation * current, callNode * call,
                       pointervalue_list & arguments,
                       pointerValue & return_val,
                       bool is_alloc);

  // -- Assignments

  virtual void at_assignment(stmtLocation * current,
                             binaryNode * binary,
                             pointerValue & left,
                             pointerValue & right,
                             pointerValue & result,
                             bool result_is_a_use,
                             memoryblock_set & changes);

  // -- Statement types

  virtual void at_return(stmtLocation * stmt,
                         returnNode * ret,
                         pointerValue & result,
                         pointerValue & return_val);

  virtual void at_exprstmt(stmtLocation * stmt,
                           exprstmtNode * es,
                           pointerValue & result);

  virtual void at_if(stmtLocation * stmt,
                     ifNode * ifnode,
                     pointerValue & result);

  // -- Process a merge point

  virtual void at_merge(basicblockLocation * where,
                        memoryBlock * block,
                        memoryuse_list & phi_uses,
                        pointerValue & result,
                        memoryblock_set & changes);

  // -- Control-flow options

  virtual void at_stmt_exit(stmtLocation * stmt,
                            pointerValue & result);

  virtual void at_basicblock_entry(basicblockLocation * block,
                                   procedureInfo * info,
                                   pointerValue & initial);

  // -- Procedure boundaries

  virtual void at_procedure_entry(procLocation * proc,
                                  procedureInfo * info,
                                  pointerValue & return_val);

  virtual void at_procedure_exit(procLocation * proc,
                                 procedureInfo * info,
                                 pointerValue & return_val);
};

class deadcodeChanger : public Changer
{
public:

  static void optimize(unitNode * u,
                       livenessAnalyzer * liveness)
  {
    deadcodeChanger ipcc(liveness);
    u->change(ipcc);
  }

private:

  livenessAnalyzer * _liveness;

  deadcodeChanger(livenessAnalyzer * liveness);

public:

  virtual Node * at_exprstmt(exprstmtNode * the_exprstmt, Order ord);
};


#endif // CBZ_LIVENESS_H

---