MemoryCellMap.h

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

#include <Rose/BinaryAnalysis/InstructionSemantics/BaseSemantics/BasicTypes.h>
#include <Rose/BinaryAnalysis/InstructionSemantics/BaseSemantics/MemoryCellState.h>

#include <Sawyer/Map.h>

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

namespace Rose {
namespace BinaryAnalysis {
namespace InstructionSemantics {
namespace BaseSemantics {

typedef boost::shared_ptr<class MemoryCellMap> MemoryCellMapPtr;

class MemoryCellMap: public MemoryCellState {
public:
    using Super = MemoryCellState;

    using Ptr = MemoryCellMapPtr;

    typedef uint64_t CellKey;

    typedef Sawyer::Container::Map<CellKey, MemoryCellPtr> CellMap;

private:
    uint32_t lastPosition_ = 0;                         // used when inserting new cells

protected:
    CellMap cells;

#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(MemoryCellState);
        s & BOOST_SERIALIZATION_NVP(cells);
    }
#endif
    
protected:
    MemoryCellMap() {}                                  // for serialization

    explicit MemoryCellMap(const MemoryCellPtr &protocell)
        : MemoryCellState(protocell) {}

    MemoryCellMap(const SValuePtr &addrProtoval, const SValuePtr &valProtoval)
        : MemoryCellState(addrProtoval, valProtoval) {}

    MemoryCellMap(const MemoryCellMap&);

private:
    MemoryCellMap& operator=(MemoryCellMap&) /*delete*/;

public:
    static MemoryCellMapPtr promote(const MemoryStatePtr &x) {
        MemoryCellMapPtr retval = boost::dynamic_pointer_cast<MemoryCellMap>(x);
        ASSERT_not_null(retval);
        return retval;
    }

public:
    virtual CellKey generateCellKey(const SValuePtr &address) const = 0;

    virtual MemoryCellPtr findCell(const SValuePtr &addr) const;

    virtual bool isAllPresent(const SValuePtr &address, size_t nBytes, RiscOperators *addrOps) const;

public:
    virtual void hash(Combinatorics::Hasher&, RiscOperators *addrOps, RiscOperators *valOps) const override;
    virtual void clear() override;
    virtual bool merge(const MemoryStatePtr &other, RiscOperators *addrOps, RiscOperators *valOps) override;
    virtual SValuePtr readMemory(const SValuePtr &address, const SValuePtr &dflt,
                                 RiscOperators *addrOps, RiscOperators *valOps) override;
    virtual SValuePtr peekMemory(const SValuePtr &address, const SValuePtr &dflt,
                                 RiscOperators *addrOps, RiscOperators *valOps) override;
    virtual void writeMemory(const SValuePtr &address, const SValuePtr &value,
                             RiscOperators *addrOps, RiscOperators *valOps) override;
    virtual void print(std::ostream&, Formatter&) const override;
    virtual std::vector<MemoryCellPtr> matchingCells(MemoryCell::Predicate&) const override;
    virtual std::vector<MemoryCellPtr> leadingCells(MemoryCell::Predicate&) const override;
    virtual void eraseMatchingCells(MemoryCell::Predicate&) override;
    virtual void eraseLeadingCells(MemoryCell::Predicate&) override;
    virtual void traverse(MemoryCell::Visitor&) override;
    virtual AddressSet getWritersUnion(const SValuePtr &addr, size_t nBits, RiscOperators *addrOps,
                                       RiscOperators *valOps) override;
    virtual AddressSet getWritersIntersection(const SValuePtr &addr, size_t nBits, RiscOperators *addrOps,
                                              RiscOperators *valOps) override;

private:
    // Increment lastPosition_ and return its new value.
    unsigned nextPosition();

    // Last position returned by nextPosition
    unsigned lastPosition() const;
    void lastPosition(unsigned);
};

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

#ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
BOOST_CLASS_EXPORT_KEY(Rose::BinaryAnalysis::InstructionSemantics::BaseSemantics::MemoryCellMap);
#endif

#endif
#endif