src/ASTAnalyses/Encoding/encodinggraph.cc

   1 #include "encodinggraph.h"
   2 #include "iterator.h"
   3 #include "element.h"
   4 #include "function.h"
   5
   6 EncodingGraph::EncodingGraph(CSolver * _solver) :
   7         solver(_solver) {
   8
   9
  10 }
  11
  12 void EncodingGraph::buildGraph() {
  13         ElementIterator it(solver);
  14         while(it.hasNext()) {
  15                 Element * e = it.next();
  16                 switch(e->type) {
  17                 case ELEMSET:
  18                 case ELEMFUNCRETURN:
  19                         processElement(e);
  20                         break;
  21                 case ELEMCONST:
  22                         break;
  23                 default:
  24                         ASSERT(0);
  25                 }
  26         }
  27 }
  28
  29 void EncodingGraph::processElement(Element *e) {
  30         uint size=e->parents.getSize();
  31         for(uint i=0;i<size;i++) {
  32                 ASTNode * n = e->parents.get(i);
  33                 switch(n->type) {
  34                 case PREDICATEOP:
  35                         processPredicate((BooleanPredicate *)n);
  36                         break;
  37                 case ELEMFUNCRETURN:
  38                         processFunction((ElementFunction *)n);
  39                         break;
  40                 default:
  41                         ASSERT(0);
  42                 }
  43         }
  44 }
  45
  46 void EncodingGraph::processFunction(ElementFunction *ef) {
  47         Function *f=ef->getFunction();
  48         if (f->type==OPERATORFUNC) {
  49                 FunctionOperator *fo=(FunctionOperator*)f;
  50                 ASSERT(ef->inputs.getSize() == 2);
  51                 EncodingNode *left=createNode(ef->inputs.get(0));
  52                 EncodingNode *right=createNode(ef->inputs.get(1));
  53                 if (left == NULL && right == NULL)
  54                         return;
  55                 EncodingNode *dst=createNode(ef);
  56                 EncodingEdge *edge=getEdge(left, right, dst);
  57         }
  58 }
  59
  60 EncodingEdge * EncodingGraph::getEdge(EncodingNode *left, EncodingNode *right, EncodingNode *dst) {
  61         EncodingEdge e(left, right, dst);
  62         EncodingEdge *result = edgeMap.get(&e);
  63         if (result == NULL) {
  64                 result=new EncodingEdge(left, right, dst);
  65                 edgeMap.put(result, result);
  66         }
  67         return result;
  68 }
  69
  70 void EncodingGraph::processPredicate(BooleanPredicate *b) {
  71
  72 }
  73
  74 EncodingNode::EncodingNode(Set *_s) :
  75         s(_s),
  76         numElements(0) {
  77 }
  78
  79 EncodingNode * EncodingGraph::createNode(Element *e) {
  80         if (e->type == ELEMCONST)
  81                 return NULL;
  82         Set *s = e->getRange();
  83         EncodingNode *n = encodingMap.get(s);
  84         if (n == NULL) {
  85                 n = new EncodingNode(s);
  86                 encodingMap.put(s, n);
  87         }
  88         n->addElement(e);
  89         if (discovered.add(e))
  90                 n->numElements++;
  91         return n;
  92 }
  93
  94 void EncodingNode::addElement(Element *e) {
  95         elements.add(e);
  96 }
  97
  98 EncodingEdge::EncodingEdge(EncodingNode *_l, EncodingNode *_r) :
  99         left(_l),
 100         right(_r),
 101         dst(NULL),
 102         numArithOps(0),
 103         numEquals(0),
 104         numComparisons(0)
 105 {
 106 }
 107
 108 EncodingEdge::EncodingEdge(EncodingNode *_left, EncodingNode *_right, EncodingNode *_dst) :
 109         left(_left),
 110         right(_right),
 111         dst(_dst),
 112         numArithOps(0),
 113         numEquals(0),
 114         numComparisons(0)
 115 {
 116 }
 117
 118 uint hashEncodingEdge(EncodingEdge *edge) {
 119         uintptr_t hash=(((uintptr_t) edge->left) >> 2) ^ (((uintptr_t)edge->right) >> 4) ^ (((uintptr_t)edge->dst) >> 6);
 120         return (uint) hash;
 121 }
 122
 123 bool equalsEncodingEdge(EncodingEdge *e1, EncodingEdge *e2) {
 124         return e1->left == e2->left && e1->right == e2->right && e1->dst == e2->dst;
 125 }