src/AST/function.cc

   1 #include "function.h"
   2 #include "table.h"
   3 #include "set.h"
   4 #include "csolver.h"
   5 #include "serializer.h"
   6
   7 FunctionOperator::FunctionOperator(ArithOp _op, Set *_range, OverFlowBehavior _overflowbehavior) :
   8         Function(OPERATORFUNC),
   9         op(_op),
  10         range(_range),
  11         overflowbehavior(_overflowbehavior) {
  12 }
  13
  14 FunctionTable::FunctionTable (Table *_table, UndefinedBehavior _undefBehavior) :
  15         Function(TABLEFUNC),
  16         table(_table),
  17         undefBehavior(_undefBehavior) {
  18 }
  19
  20 uint64_t FunctionOperator::applyFunctionOperator(uint numVals, uint64_t *values) {
  21         ASSERT(numVals == 2);
  22         switch (op) {
  23         case SATC_ADD:
  24                 return values[0] + values[1];
  25                 break;
  26         case SATC_SUB:
  27                 return values[0] - values[1];
  28                 break;
  29         default:
  30                 ASSERT(0);
  31         }
  32 }
  33
  34 bool FunctionOperator::isInRangeFunction(uint64_t val) {
  35         return range->exists(val);
  36 }
  37
  38 Function *FunctionOperator::clone(CSolver *solver, CloneMap *map) {
  39         Function *f = (Function *) map->get(this);
  40         if (f != NULL)
  41                 return f;
  42
  43         Set *rcopy = range->clone(solver, map);
  44         f = solver->createFunctionOperator(op, rcopy, overflowbehavior);
  45         map->put(this, f);
  46         return f;
  47 }
  48
  49 Function *FunctionTable::clone(CSolver *solver, CloneMap *map) {
  50         Function *f = (Function *) map->get(this);
  51         if (f != NULL)
  52                 return f;
  53
  54         Table *tcopy = table->clone(solver, map);
  55         f = solver->completeTable(tcopy, undefBehavior);
  56         map->put(this, f);
  57         return f;
  58 }
  59
  60 Set *FunctionTable::getRange() {
  61         return table->getRange();
  62 }
  63
  64 void FunctionTable::serialize(Serializer *serializer) {
  65         if (serializer->isSerialized(this))
  66                 return;
  67         serializer->addObject(this);
  68
  69         table->serialize(serializer);
  70
  71         ASTNodeType type = FUNCTABLETYPE;
  72         serializer->mywrite(&type, sizeof(ASTNodeType));
  73         FunctionTable *This = this;
  74         serializer->mywrite(&This, sizeof(FunctionTable *));
  75         serializer->mywrite(&table, sizeof(Table *));
  76         serializer->mywrite(&undefBehavior, sizeof(UndefinedBehavior));
  77
  78 }
  79
  80 void FunctionTable::print() {
  81         model_print("{FunctionTable<%p>:\n", this);
  82         table->print();
  83         model_print("}\n");
  84 }
  85
  86 void FunctionOperator::serialize(Serializer *serializer) {
  87         if (serializer->isSerialized(this))
  88                 return;
  89         serializer->addObject(this);
  90         range->serialize(serializer);
  91
  92         ASTNodeType nodeType = FUNCOPTYPE;
  93         serializer->mywrite(&nodeType, sizeof(ASTNodeType));
  94         FunctionOperator *This = this;
  95         serializer->mywrite(&This, sizeof(FunctionOperator *));
  96         serializer->mywrite(&op, sizeof(ArithOp));
  97         serializer->mywrite(&range, sizeof(Set *));
  98         serializer->mywrite(&overflowbehavior, sizeof(OverFlowBehavior));
  99 }
 100
 101 void FunctionOperator::print() {
 102         model_print("{FunctionOperator<%p>: %s}\n", this, op == SATC_ADD ? "ADD" : "SUB" );
 103 }