DataFlowSemantics2.h

#ifndef Rose_BinaryAnalysis_DataFlowSemantics_H
#define Rose_BinaryAnalysis_DataFlowSemantics_H
#include <featureTests.h>
#ifdef ROSE_ENABLE_BINARY_ANALYSIS

#include "AbstractLocation.h"
#include "BaseSemantics2.h"
#include "MultiSemantics2.h"
#include "NullSemantics2.h"

#include <boost/foreach.hpp>
#include <Sawyer/Assert.h>
#include <Sawyer/Graph.h>

namespace Rose {
namespace BinaryAnalysis {
namespace InstructionSemantics2 {
namespace DataFlowSemantics {

struct DataFlowEdge {
    enum EdgeType {
        CLOBBER,                                            
        AUGMENT                                             
    };

    size_t sequence;                                    
    EdgeType edgeType;                                  
    DataFlowEdge(): sequence(INVALID_INDEX), edgeType(CLOBBER) {}
    DataFlowEdge(size_t sequence, EdgeType edgeType): sequence(sequence), edgeType(edgeType) {}
};

typedef Sawyer::Container::Graph<AbstractLocation, DataFlowEdge> DataFlowGraph;

typedef boost::shared_ptr<class RiscOperators> RiscOperatorsPtr;

class RiscOperators: public MultiSemantics::RiscOperators {
    typedef                 MultiSemantics::RiscOperators Super;

    const RegisterDictionary *regdict_;                 // register dictionary used to print abstract locations
    size_t innerDomainId_;                              // subdomain identifier for the dataflow's inner domain
    size_t userDomainId_;                               // subdomain identifier for the user-supplied domain (memory addrs)
    DataFlowGraph dflow_;                               // dataflow graph accumulated over processInstruction() calls.

    void init(const BaseSemantics::RiscOperatorsPtr &userDomain);

    // The normal C++ constructors; protected because this object is reference counted
protected:
    explicit RiscOperators(const BaseSemantics::RiscOperatorsPtr &userDomain)
        : MultiSemantics::RiscOperators(MultiSemantics::SValue::instance(), SmtSolverPtr()) {
        init(userDomain);
    }

public:
    static RiscOperatorsPtr instance(const BaseSemantics::RiscOperatorsPtr &childOps) {
        return RiscOperatorsPtr(new RiscOperators(childOps));
    }

    // Virtual constructors inherited from the super class.  These are disabled because users are expected to create this
    // dataflow semantics framework only through the "instance" method. (But we still must override them.)
private:
    virtual BaseSemantics::RiscOperatorsPtr create(const BaseSemantics::SValuePtr &protoval,
                                                   const SmtSolverPtr &solver = SmtSolverPtr()) const ROSE_OVERRIDE {
        ASSERT_not_reachable("should not be called by user code");
#ifdef _MSC_VER
        return BaseSemantics::RiscOperatorsPtr();
#endif
    }

    virtual BaseSemantics::RiscOperatorsPtr create(const BaseSemantics::StatePtr &state,
                                                   const SmtSolverPtr &solver = SmtSolverPtr()) const ROSE_OVERRIDE {
        ASSERT_not_reachable("should not be called by user code");
#ifdef _MSC_VER
        return BaseSemantics::RiscOperatorsPtr();
#endif
    }

    // Dynamic pointer cast
public:
    static RiscOperatorsPtr promote(const BaseSemantics::RiscOperatorsPtr &x) {
        RiscOperatorsPtr retval = boost::dynamic_pointer_cast<RiscOperators>(x);
        ASSERT_not_null(retval);
        return retval;
    }

public:
    void clearGraph() { dflow_.clear(); }

    const DataFlowGraph& getGraph() const { return dflow_; }

private:
    // Temporarily disables a subdomain, restoring it the its original state when this object is canceled or destroyed.
    class TemporarilyDeactivate {
        MultiSemantics::RiscOperators *ops_;
        size_t id_;
        bool wasActive_, canceled_;
    public:
        TemporarilyDeactivate(MultiSemantics::RiscOperators *ops, size_t id)
            : ops_(ops), id_(id), wasActive_(ops->is_active(id)), canceled_(false) {
            ops->set_active(id, false);
        }
        ~TemporarilyDeactivate() {
            cancel();
        }
        void cancel() {
            if (!canceled_) {
                ops_->set_active(id_, wasActive_);
                canceled_ = true;
            }
        }
    };

    // Insert edges (and vertices if necessary) into the data flow graph, dgraph_
    void insertDataFlowEdge(const AbstractLocation &source, const AbstractLocation &target, DataFlowEdge::EdgeType);
    void insertDataFlowEdges(const BaseSemantics::SValuePtr &svalue, const AbstractLocation &target);
    
    // Override state-accessing methods.  These methods do the normal thing in the user domain, but in the dataflow domain they
    // behave differently.  When reading, they return the set of abstract locations that were read (either a register or the
    // address for the bytes of memory); when writing they add vertices and edges to the dataflow graph.
public:
    virtual BaseSemantics::SValuePtr readRegister(RegisterDescriptor reg,
                                                  const BaseSemantics::SValuePtr &dflt) ROSE_OVERRIDE;
    virtual BaseSemantics::SValuePtr peekRegister(RegisterDescriptor reg,
                                                  const BaseSemantics::SValuePtr &dflt) ROSE_OVERRIDE;

    virtual void writeRegister(RegisterDescriptor reg, const BaseSemantics::SValuePtr &a_) ROSE_OVERRIDE;

    virtual BaseSemantics::SValuePtr readMemory(RegisterDescriptor segreg, const BaseSemantics::SValuePtr &addr_,
                                                const BaseSemantics::SValuePtr &dflt_,
                                                const BaseSemantics::SValuePtr &cond) ROSE_OVERRIDE;

    virtual BaseSemantics::SValuePtr peekMemory(RegisterDescriptor segreg, const BaseSemantics::SValuePtr &addr_,
                                                const BaseSemantics::SValuePtr &dflt_) ROSE_OVERRIDE;

    virtual void writeMemory(RegisterDescriptor segreg, const BaseSemantics::SValuePtr &addr_,
                             const BaseSemantics::SValuePtr &data_, const BaseSemantics::SValuePtr &cond) ROSE_OVERRIDE;

protected:
    BaseSemantics::SValuePtr readOrPeekMemory(RegisterDescriptor segreg, const BaseSemantics::SValuePtr &addr,
                                              const BaseSemantics::SValuePtr &dflt,
                                              const BaseSemantics::SValuePtr &cond, bool allowSideEffects);

};

} // namespace
} // namespace
} // namespace
} // namespace

#endif
#endif