MemoryCellState.h

#ifndef ROSE_BinaryAnalysis_InstructionSemantics2_MemoryCellState_H
#define ROSE_BinaryAnalysis_InstructionSemantics2_MemoryCellState_H
#include <rosePublicConfig.h>
#ifdef ROSE_BUILD_BINARY_ANALYSIS_SUPPORT

#include <BaseSemantics2.h>
#include <MemoryCell.h>

#include <boost/serialization/access.hpp>
#include <boost/serialization/base_object.hpp>
#include <boost/serialization/export.hpp>

namespace Rose {
namespace BinaryAnalysis {
namespace InstructionSemantics2 {
namespace BaseSemantics {

typedef boost::shared_ptr<class MemoryCellState> MemoryCellStatePtr;

class MemoryCellState: public MemoryState {
protected:
    MemoryCellPtr protocell;                            // prototypical memory cell used for its virtual constructors
    MemoryCellPtr latestWrittenCell_;                   // the cell whose value was most recently written to, if any

#ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
private:
    friend class boost::serialization::access;

    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        s & BOOST_SERIALIZATION_BASE_OBJECT_NVP(MemoryState);
        s & BOOST_SERIALIZATION_NVP(protocell);
        s & BOOST_SERIALIZATION_NVP(latestWrittenCell_);
    }
#endif

protected:
    MemoryCellState() {}                                // for serialization

    explicit MemoryCellState(const MemoryCellPtr &protocell)
        : MemoryState(protocell->get_address(), protocell->get_value()), protocell(protocell) {}

    MemoryCellState(const SValuePtr &addrProtoval, const SValuePtr &valProtoval)
        : MemoryState(addrProtoval, valProtoval), protocell(MemoryCell::instance(addrProtoval, valProtoval)) {}

    MemoryCellState(const MemoryCellState &other)
        : MemoryState(other), protocell(other.protocell) {} // latestWrittenCell_ is cleared

public:
    static MemoryCellStatePtr promote(const BaseSemantics::MemoryStatePtr &m) {
        MemoryCellStatePtr retval = boost::dynamic_pointer_cast<MemoryCellState>(m);
        ASSERT_not_null(retval);
        return retval;
    }

public:
    virtual void clear() ROSE_OVERRIDE;

public:
    virtual MemoryCellPtr latestWrittenCell() const {
        return latestWrittenCell_;
    }
    virtual void latestWrittenCell(const MemoryCellPtr &cell) {
        latestWrittenCell_ = cell;
    }
    virtual MemoryCell::AddressSet getWritersUnion(const SValuePtr &addr, size_t nBits, RiscOperators *addrOps,
                                                   RiscOperators *valOps) = 0;

    virtual MemoryCell::AddressSet getWritersIntersection(const SValuePtr &addr, size_t nBits, RiscOperators *addrOps,
                                                          RiscOperators *valOps) = 0;

    virtual std::vector<MemoryCellPtr> matchingCells(const MemoryCell::Predicate&) const = 0;

    virtual std::vector<MemoryCellPtr> leadingCells(const MemoryCell::Predicate&) const = 0;
    
    virtual void eraseMatchingCells(const MemoryCell::Predicate&) = 0;

    virtual void eraseLeadingCells(const MemoryCell::Predicate&) = 0;

    virtual void traverse(MemoryCell::Visitor&) = 0;

    void eraseNonWritten() {
        eraseMatchingCells(MemoryCell::NonWrittenCells());
    }

    std::vector<MemoryCellPtr> allCells() const {
        return matchingCells(MemoryCell::AllCells());
    }
};

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

#ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
BOOST_CLASS_EXPORT_KEY(Rose::BinaryAnalysis::InstructionSemantics2::BaseSemantics::MemoryCellState);
#endif

#endif
#endif