BaseSemantics/MemoryCellState.h

#ifndef ROSE_BinaryAnalysis_InstructionSemantics_BaseSemantics_MemoryCellState_H
#define ROSE_BinaryAnalysis_InstructionSemantics_BaseSemantics_MemoryCellState_H
#include <featureTests.h>
#ifdef ROSE_ENABLE_BINARY_ANALYSIS
 
#include <Rose/BinaryAnalysis/InstructionSemantics/BaseSemantics/MemoryCell.h>
#include <Rose/BinaryAnalysis/InstructionSemantics/BaseSemantics/MemoryState.h>
 
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
#include <boost/serialization/access.hpp>
#include <boost/serialization/base_object.hpp>
#include <boost/serialization/export.hpp>
#endif
 
namespace Rose {
namespace BinaryAnalysis {
namespace InstructionSemantics {
namespace BaseSemantics {
 
class MemoryCellState: public MemoryState {
public:
    using Super = MemoryState;
 
    using Ptr = MemoryCellStatePtr;
 
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_ENABLE_BOOST_SERIALIZATION
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);
 
    MemoryCellState(const SValuePtr &addrProtoval, const SValuePtr &valProtoval);
 
    MemoryCellState(const MemoryCellState &other);
 
public:
    ~MemoryCellState();
 
public:
    static MemoryCellStatePtr promote(const BaseSemantics::AddressSpacePtr&);
 
public:
    virtual void clear() override;
 
public:
    virtual MemoryCellPtr latestWrittenCell() const;
    virtual void latestWrittenCell(const MemoryCellPtr&);
    virtual AddressSet getWritersUnion(const SValuePtr &addr, size_t nBits, RiscOperators *addrOps,
                                       RiscOperators *valOps) = 0;
 
    virtual AddressSet getWritersIntersection(const SValuePtr &addr, size_t nBits, RiscOperators *addrOps,
                                              RiscOperators *valOps) = 0;
 
    virtual std::vector<MemoryCellPtr> matchingCells(MemoryCell::Predicate&) const = 0;
 
    virtual std::vector<MemoryCellPtr> leadingCells(MemoryCell::Predicate&) const = 0;
    
    virtual void eraseMatchingCells(MemoryCell::Predicate&) = 0;
 
    virtual void eraseLeadingCells(MemoryCell::Predicate&) = 0;
 
    virtual void traverse(MemoryCell::Visitor&) = 0;
 
    virtual void updateReadProperties(const CellList&);
 
    virtual void updateWriteProperties(const CellList&, InputOutputPropertySet);
 
    void eraseNonWritten();
 
    std::vector<MemoryCellPtr> allCells() const;
};
class MemoryCellState: public MemoryState {…};
 
} // namespace
} // namespace
} // namespace
} // namespace
 
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
BOOST_CLASS_EXPORT_KEY(Rose::BinaryAnalysis::InstructionSemantics::BaseSemantics::MemoryCellState);
#endif
 
#endif
#endif