DataFlowSemantics.h

#ifndef ROSE_BinaryAnalysis_InstructionSemantics_DataFlowSemantics_H
#define ROSE_BinaryAnalysis_InstructionSemantics_DataFlowSemantics_H
#include <featureTests.h>
#ifdef ROSE_ENABLE_BINARY_ANALYSIS
 
#include <Rose/BinaryAnalysis/AbstractLocation.h>
#include <Rose/BinaryAnalysis/BasicTypes.h>
#include <Rose/BinaryAnalysis/InstructionSemantics/BaseSemantics.h>
#include <Rose/BinaryAnalysis/InstructionSemantics/MultiSemantics.h>
#include <Rose/BinaryAnalysis/InstructionSemantics/NullSemantics.h>
 
#include <Sawyer/Assert.h>
#include <Sawyer/Graph.h>
 
namespace Rose {
namespace BinaryAnalysis {
namespace InstructionSemantics {
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 {
public:
    using Super = MultiSemantics::RiscOperators;
 
    using Ptr = RiscOperatorsPtr;
 
private:
    RegisterDictionaryPtr 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& = SmtSolverPtr()) const 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&,
                                                   const SmtSolverPtr& = SmtSolverPtr()) const 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) override;
    virtual BaseSemantics::SValuePtr peekRegister(RegisterDescriptor reg,
                                                  const BaseSemantics::SValuePtr &dflt) override;
 
    virtual void writeRegister(RegisterDescriptor reg, const BaseSemantics::SValuePtr &a_) override;
 
    virtual BaseSemantics::SValuePtr readMemory(RegisterDescriptor segreg, const BaseSemantics::SValuePtr &addr_,
                                                const BaseSemantics::SValuePtr &dflt_,
                                                const BaseSemantics::SValuePtr &cond) override;
 
    virtual BaseSemantics::SValuePtr peekMemory(RegisterDescriptor segreg, const BaseSemantics::SValuePtr &addr_,
                                                const BaseSemantics::SValuePtr &dflt_) override;
 
    virtual void writeMemory(RegisterDescriptor segreg, const BaseSemantics::SValuePtr &addr_,
                             const BaseSemantics::SValuePtr &data_, const BaseSemantics::SValuePtr &cond) 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