MemoryCell.h

#ifndef ROSE_BinaryAnalysis_InstructionSemantics_BaseSemantics_MemoryCell_H
#define ROSE_BinaryAnalysis_InstructionSemantics_BaseSemantics_MemoryCell_H
#include <featureTests.h>
#ifdef ROSE_ENABLE_BINARY_ANALYSIS
#include <Rose/BinaryAnalysis/InstructionSemantics/BaseSemantics/BasicTypes.h>
 
#include <Rose/BinaryAnalysis/AddressSet.h>
#include <Combinatorics.h>                              // rose
 
#include <Sawyer/Set.h>
 
#include <boost/enable_shared_from_this.hpp>
#include <boost/serialization/access.hpp>
#include <boost/serialization/export.hpp>
#include <boost/serialization/list.hpp>
#include <list>
 
namespace Rose {
namespace BinaryAnalysis {
namespace InstructionSemantics {
namespace BaseSemantics {
 
class MemoryCell: public boost::enable_shared_from_this<MemoryCell> {
public:
    using Ptr = MemoryCellPtr;
 
    class Visitor {
    public:
        virtual ~Visitor() {}
        virtual void operator()(MemoryCellPtr&) = 0;
    };
 
    class Predicate {
    public:
        virtual ~Predicate() {};
 
        virtual bool operator()(const MemoryCellPtr&) = 0;
    };
 
    class AllCells: public Predicate {
    public:
        virtual bool operator()(const MemoryCellPtr&) override {
            return true;
        }
    };
 
    class NonWrittenCells: public Predicate {
    public:
        virtual bool operator()(const MemoryCellPtr&) override;
    };
 
private:
    SValuePtr address_;                                 // Address of memory cell.
    SValuePtr value_;                                   // Value stored at that address.
    AddressSet writers_;                                // Instructions that wrote to this cell
    InputOutputPropertySet ioProperties_;
    unsigned position_ = 0;                             // position when printing a memory state
 
    // Serialization
#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_NVP(address_);
        s & BOOST_SERIALIZATION_NVP(value_);
        s & BOOST_SERIALIZATION_NVP(writers_);
        s & BOOST_SERIALIZATION_NVP(ioProperties_);
        if (version >= 1)
            s & BOOST_SERIALIZATION_NVP(position_);
    }
#endif
 
    // Real constructors
protected:
    MemoryCell();                                       // for serialization
 
    MemoryCell(const SValuePtr &address, const SValuePtr &value);
 
    // deep-copy cell list so modifying this new one doesn't alter the existing one
    MemoryCell(const MemoryCell &other);
 
public:
    virtual ~MemoryCell();
 
    // Static allocating constructors
public:
    static MemoryCellPtr instance(const SValuePtr &address, const SValuePtr &value) {
        return MemoryCellPtr(new MemoryCell(address, value));
    }
 
    static MemoryCellPtr instance(const MemoryCellPtr &other) {
        return MemoryCellPtr(new MemoryCell(*other));
    }
 
    // Virtual constructors
public:
    virtual MemoryCellPtr create(const SValuePtr &address, const SValuePtr &value) {
        return instance(address, value);
    }
 
    virtual MemoryCellPtr clone() const {
        return MemoryCellPtr(new MemoryCell(*this));
    }
 
    // Dynamic pointer casts. No-op since this is the base class.
public:
    static MemoryCellPtr promote(const MemoryCellPtr &x) {
        ASSERT_not_null(x);
        return x;
    }
    
    // Methods first declared at this level of the class hierarchy
public:
    virtual SValuePtr address() const;
    virtual void address(const SValuePtr &addr);
    virtual SValuePtr value() const;
    virtual void value(const SValuePtr &v);
    virtual const AddressSet& getWriters() const {
        return writers_;
    }
 
    bool insertWriter(rose_addr_t writerVa) /*final*/ { return writers_.insert(writerVa); }
    virtual bool insertWriters(const AddressSet &writerVas) { return writers_.insert(writerVas); }
    bool eraseWriter(rose_addr_t writerVa) /*final*/ { return writers_.erase(writerVa); }
    virtual bool eraseWriters(const AddressSet &writerVas) { return writers_.erase(writerVas); }
    void setWriter(rose_addr_t writerVa) /*final*/;
    virtual void setWriters(const AddressSet &writerVas) { writers_.insert(writerVas); }
    virtual void eraseWriters() { writers_.clear(); }
 
    const InputOutputPropertySet& ioProperties() const { return ioProperties_; }
    InputOutputPropertySet& ioProperties() { return ioProperties_; }
    unsigned position() const { return position_; }
    void position(unsigned p) { position_ = p; }
    bool mayAlias(const MemoryCellPtr &other, RiscOperators *addrOps) const;
 
    bool mustAlias(const MemoryCellPtr &other, RiscOperators *addrOps) const;
 
    virtual void hash(Combinatorics::Hasher&) const;
 
    void print(std::ostream &stream) const;
    virtual void print(std::ostream&, Formatter&) const;
    class WithFormatter {
        MemoryCellPtr obj;
        Formatter &fmt;
    public:
        WithFormatter(const MemoryCellPtr &obj, Formatter &fmt): obj(obj), fmt(fmt) {}
        void print(std::ostream &stream) const { obj->print(stream, fmt); }
    };
 
    WithFormatter with_format(Formatter&);
    WithFormatter operator+(Formatter&);
    WithFormatter operator+(const std::string &linePrefix);
};
 
using CellList = std::list<MemoryCellPtr>;
 
std::ostream& operator<<(std::ostream&, const MemoryCell&);
std::ostream& operator<<(std::ostream&, const MemoryCell::WithFormatter&);
 
} // namespace
} // namespace
} // namespace
} // namespace
 
BOOST_CLASS_EXPORT_KEY(Rose::BinaryAnalysis::InstructionSemantics::BaseSemantics::MemoryCell);
BOOST_CLASS_VERSION(Rose::BinaryAnalysis::InstructionSemantics::BaseSemantics::MemoryCell, 1);
 
#endif
#endif