src/ast/simplify-visitor.cc

   1 #include <sstream>
   2 #include <boost/foreach.hpp>
   3
   4 #include <core/assert.hh>
   5 #include "simplify-visitor.hh"
   6
   7 namespace ast
   8 {
   9   /// @defgroup Visitors
  10   /**
  11    * @class SimplifyVisitor
  12    * @ingroup Visitors
  13    *
  14    * <b>Algorithm</b><br>
  15    * - on Block
  16    *  - for every instruction
  17    *   - split the instruction in 3 address instruction
  18    */
  19
  20   SimplifyVisitor::SimplifyVisitor()
  21     : BrowseVisitor(),
  22       simplifications_(0),
  23       replacement_(0),
  24       nextId_(0)
  25   {
  26   }
  27
  28   SimplifyVisitor::~SimplifyVisitor()
  29   {
  30   }
  31
  32   std::string
  33   SimplifyVisitor::nextId()
  34   {
  35     std::stringstream ss;
  36     ss << "r" << ++nextId_;
  37     return ss.str();
  38   }
  39
  40   std::string
  41   SimplifyVisitor::currentId() const
  42   {
  43     std::stringstream ss;
  44     ss << "r" << nextId_;
  45     return ss.str();
  46   }
  47
  48   void
  49   SimplifyVisitor::visit(Block & block)
  50   {
  51     /// @todo use a garbage collector
  52     std::vector<Node *> * newList = new std::vector<Node *>();
  53
  54     BOOST_FOREACH(Node * node, (*block.instrs))
  55     {
  56       assert(node);
  57       simplifications_.clear();
  58       node->accept(*this);
  59       BOOST_FOREACH(Node * snode, simplifications_)
  60         newList->push_back(snode);
  61       //delete node;
  62     }
  63     //delete block.instrs;
  64     block.instrs = newList;
  65   }
  66
  67 #define SIMPLIFY_BINARY_EXP(Type)                                       \
  68   /**                                                                   \
  69    * @internal                                                          \
  70    * - Simplify childs                                                  \
  71    * - Create a new id.                                                 \
  72    * - Create a new assign exp to id.                                   \
  73    * - Create a IdExp and tell replace the parent's child with it.      \
  74    */                                                                   \
  75   void                                                                  \
  76   SimplifyVisitor::visit(Type & node)                                   \
  77   {                                                                     \
  78     assert(node.left);                                                  \
  79     node.left->accept(*this);                                           \
  80     node.left = replacement_;                                           \
  81     assert(node.right);                                                 \
  82     node.right->accept(*this);                                          \
  83     node.right = replacement_;                                          \
  84                                                                         \
  85     std::string name = nextId();                                        \
  86                                                                         \
  87     TmpResultExp * tmpRes = new TmpResultExp();                         \
  88     tmpRes->name = name;                                                \
  89     replacement_ = tmpRes;                                              \
  90                                                                         \
  91     AssignExp * assign = new AssignExp();                               \
  92     assign->name = name;                                                \
  93     assign->value = &node;                                              \
  94     simplifications_.push_back(assign);                                 \
  95   }
  96
  97   SIMPLIFY_BINARY_EXP(EqExp)
  98   SIMPLIFY_BINARY_EXP(NeqExp)
  99   SIMPLIFY_BINARY_EXP(LtExp)
 100   SIMPLIFY_BINARY_EXP(LtEqExp)
 101   SIMPLIFY_BINARY_EXP(GtExp)
 102   SIMPLIFY_BINARY_EXP(GtEqExp)
 103   SIMPLIFY_BINARY_EXP(AddExp)
 104   SIMPLIFY_BINARY_EXP(SubExp)
 105   SIMPLIFY_BINARY_EXP(MulExp)
 106   SIMPLIFY_BINARY_EXP(DivExp)
 107   SIMPLIFY_BINARY_EXP(ModExp)
 108
 109   void
 110   SimplifyVisitor::visit(AssignExp & node)
 111   {
 112     assert(node.value);
 113     node.value->accept(*this);
 114     node.value = replacement_;
 115
 116     StoreVar * sv = new StoreVar();
 117     sv->name = node.name;
 118     sv->value = replacement_;
 119     simplifications_.push_back(sv);
 120
 121     delete &node;
 122   }
 123
 124   void
 125   SimplifyVisitor::visit(NumberExp & node)
 126   {
 127     replacement_ = &node;
 128   }
 129
 130   void
 131   SimplifyVisitor::visit(IdExp & node)
 132   {
 133     LoadVar * lv = new LoadVar();
 134     lv->name = node.name;
 135     lv->to = nextId();
 136     simplifications_.push_back(lv);
 137
 138     TmpResultExp * tre = new TmpResultExp();
 139     tre->name = lv->to;
 140     replacement_ = tre;
 141     delete &node;
 142   }
 143 }