Able to evaluate predicate expression against a 'context' and generate concrete predi...

[c11tester.git] / funcnode.cc

diff --git a/funcnode.cc b/funcnode.cc
index e08ca1b..d328a4c 100644 (file)
--- a/funcnode.cc
+++ b/funcnode.cc
@@ -321,10 +321,9 @@ bool FuncNode::follow_branch(Predicate ** curr_pred, FuncInst * next_inst, Model
                if (branch->get_func_inst() != next_inst)
                        continue;
 
                if (branch->get_func_inst() != next_inst)
                        continue;
 

-               /* check against predicate expressions */
+               /* Check against predicate expressions */

                bool predicate_correct = true;
                PredExprSet * pred_expressions = branch->get_pred_expressions();
                bool predicate_correct = true;
                PredExprSet * pred_expressions = branch->get_pred_expressions();

-               PredExprSetIter * pred_expr_it = pred_expressions->iterator();

 
                /* Only read and rmw actions my have unset predicate expressions */
                if (pred_expressions->getSize() == 0) {
 
                /* Only read and rmw actions my have unset predicate expressions */
                if (pred_expressions->getSize() == 0) {


@@ -332,33 +331,26 @@ bool FuncNode::follow_branch(Predicate ** curr_pred, FuncInst * next_inst, Model
                        unset_predicates->push_back(branch);
                }
 
                        unset_predicates->push_back(branch);
                }
 

-               while (pred_expr_it->hasNext()) {
-                       pred_expr * pred_expression = pred_expr_it->next();
-                       uint64_t last_read, next_read;
+               SnapVector<struct concrete_pred_expr> concrete_exprs = branch->evaluate(inst_act_map);
+               for (uint i = 0; i < concrete_exprs.size(); i++) {
+                       struct concrete_pred_expr concrete = concrete_exprs[i];
+                       uint64_t next_read;

                        bool equality;
 
                        bool equality;
 

-                       switch(pred_expression->token) {
+                       switch (concrete.token) {

                                case NOPREDICATE:
                                        predicate_correct = true;
                                        break;
                                case EQUALITY:
                                case NOPREDICATE:
                                        predicate_correct = true;
                                        break;
                                case EQUALITY:

-                                       FuncInst * to_be_compared;
-                                       ModelAction * last_act;
-
-                                       to_be_compared = pred_expression->func_inst;
-                                       last_act = inst_act_map->get(to_be_compared);
-
-                                       last_read = last_act->get_reads_from_value();

                                        next_read = next_act->get_reads_from_value();
                                        next_read = next_act->get_reads_from_value();

-                                       equality = (last_read == next_read);
-                                       if (equality != pred_expression->value)
+                                       equality = (next_read == concrete.value);
+                                       if (equality != concrete.equality)

                                                predicate_correct = false;
                                                predicate_correct = false;

-

                                        break;
                                case NULLITY:
                                        next_read = next_act->get_reads_from_value();
                                        equality = ((void*)next_read == NULL);
                                        break;
                                case NULLITY:
                                        next_read = next_act->get_reads_from_value();
                                        equality = ((void*)next_read == NULL);

-                                       if (equality != pred_expression->value)
+                                       if (equality != concrete.equality)

                                                predicate_correct = false;
                                        break;
                                default:
                                                predicate_correct = false;
                                        break;
                                default: