---

constants.h

Go to the documentation of this file.

#ifndef CBZ_CONSTANTS_H
#define CBZ_CONSTANTS_H

#include "pointers.h"

class constantFlowValue : public analysisVal
{
public:

  const constant * value;

  constantFlowValue()
    : value(0)
  {}

  constantFlowValue(const constant * val)
    : value(val)
  {}

  virtual ~constantFlowValue() { value = 0; }

  virtual analysisVal * clone() const {
    return new constantFlowValue(*this);
  }
};


class constantAnalyzer : public analysisProblem
{
private:

  typedef set< constant > constant_set;
  typedef constant_set::iterator constant_set_p;

  typedef map< memoryDef *, const constant *> memorydef_constant_map;
  typedef memorydef_constant_map::iterator memorydef_constant_map_p;

  typedef set< procLocation * > change_set;
  typedef change_set::iterator change_set_p;

  typedef map< exprNode *, const constant * > expr_value_map;
  typedef expr_value_map::iterator expr_value_map_p;

  TREE constant_set _constants;

  memorydef_constant_map _values;

  const constant * _top;

  const constant * _bottom;

  change_set _changes;

  expr_value_map _expr_values;

  bool _debug;

public:

  constantAnalyzer(bool debug = false);

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

  void clear();

  ~constantAnalyzer();

  inline const constant * top() const { return _top; }

  inline const constant * bottom() const { return _bottom; }

  inline void set_debug(bool new_val) { _debug = new_val; }

protected:

  const constant * lookup(const constant & value);

  const constant * lookup_flowvalue(memoryDef * def);

  bool update_flowvalue(const constant * val, memoryDef * def);

  const constant * meet(const constant * one, const constant * two);

  const constant * rebuild_flowvalue(pointerValue & pointer);

  const constant * get_flowvalue(pointerValue & pointer);

  void * set_flowvalue(const constant * val, pointerValue & pointer);

  void record_expression(exprNode * expr, const constant * val);

public:

  const constant * lookup_expression(exprNode * expr);

  // --- Transfer functions -----------------------

  // -- Non-pointer expressions

  virtual void at_id(stmtLocation * current, idNode * id,
                     pointerValue & value,
                     bool result_is_a_use);

  virtual void at_unary(stmtLocation * current,
                        unaryNode * unary,
                        pointerValue & operand,
                        pointerValue & result,
                        bool result_is_a_use);

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

  virtual void at_cast(stmtLocation * current, castNode * cast,
                       pointerValue & operand,
                       pointerValue & result,
                       bool result_is_a_use);

  virtual void at_const(stmtLocation * current, constNode * cons,
                        pointerValue & result,
                        bool result_is_a_use);

  // -- Pointer expressions

  virtual void at_field_access(stmtLocation * current,
                               binaryNode * binary,
                               pointerValue & operand,
                               idNode * field,
                               pointerValue & result,
                               bool result_is_a_use);

  virtual void at_dereference(stmtLocation * current,
                              unaryNode * unary,
                              pointerValue & operand,
                              pointerValue & result,
                              bool result_is_a_use);

  virtual void at_address(stmtLocation * current,
                          unaryNode * unary,
                          pointerValue & operand,
                          pointerValue & result,
                          bool result_is_a_use);

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

  // -- Assignments

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

  virtual void at_parameter_pass(Location * current,
                                 pointerValue & left,
                                 pointerValue & right,
                                 pointerValue & result,
                                 memoryblock_set & changes);

  // -- Statement types

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

  // -- 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_basicblock_entry(basicblockLocation * block,
                                   procedureInfo * info,
                                   pointerValue & initial);

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

  // -- Procedure boundaries

  virtual void at_conservative_procedure_call(stmtLocation * current,
                                              callNode * call,
                                              pointerValue & call_target,
                                              pointervalue_list & arguments,
                                              memoryblock_set & reachable_blocks,
                                              pointerValue & return_val,
                                              memoryblock_set & changes);

  // --- Output ---------------------

  void print(ostream & o, const constant * val) {
    if (val == _bottom)
      o << "(BOTTOM)";
    else
      if (val == _top)
        o << "(TOP)";
      else {
        constant temp = *val;
        o << temp.to_string();
      }
  }

private:

  void record_change(memoryDef * def);


};


class constantsChanger : public Changer
{
public:

  static void optimize(unitNode * u,
                       constantAnalyzer * constants,
                       bool simplify)
  {
    constantsChanger ipcc(constants, simplify);
    u->change(ipcc);
  }

private:

  constantAnalyzer * _constants;

  bool _simplify;

  constantsChanger(constantAnalyzer * constants, bool simplify);

public:

  virtual Node * at_expr(exprNode * the_expr, Order ord);
  virtual Node * at_if(ifNode * the_if, Order ord);
};

#endif // CBZ_CONSTANTS_H

---