MemoryCellList.h

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

#include <Rose/BinaryAnalysis/InstructionSemantics/BaseSemantics/MemoryCellState.h>
#include <Rose/BinaryAnalysis/InstructionSemantics/BaseSemantics/RiscOperators.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 MemoryCellList> MemoryCellListPtr;

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

    using Ptr = MemoryCellListPtr;

protected:
    CellList cells;                                     // list of cells in reverse chronological order
    bool occlusionsErased_;                             // prune away old cells that are occluded by newer ones.

    // 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_BASE_OBJECT_NVP(MemoryCellState);
        s & BOOST_SERIALIZATION_NVP(cells);
        s & BOOST_SERIALIZATION_NVP(occlusionsErased_);
    }
#endif

    // Real constructors
protected:
    MemoryCellList()                                    // for serialization
        : occlusionsErased_(false) {}

    explicit MemoryCellList(const MemoryCellPtr &protocell)
        : MemoryCellState(protocell), occlusionsErased_(false) {}

    MemoryCellList(const SValuePtr &addrProtoval, const SValuePtr &valProtoval)
        : MemoryCellState(addrProtoval, valProtoval), occlusionsErased_(false) {}

    // deep-copy cell list so that modifying this new state does not modify the existing state
    MemoryCellList(const MemoryCellList &other)
        : MemoryCellState(other), occlusionsErased_(other.occlusionsErased_) {
        for (CellList::const_iterator ci=other.cells.begin(); ci!=other.cells.end(); ++ci)
            cells.push_back((*ci)->clone());
    }

    // Static allocating constructors
public:
    static MemoryCellListPtr instance(const SValuePtr &addrProtoval, const SValuePtr &valProtoval) {
        return MemoryCellListPtr(new MemoryCellList(addrProtoval, valProtoval));
    }
    
    static MemoryCellListPtr instance(const MemoryCellPtr &protocell) {
        return MemoryCellListPtr(new MemoryCellList(protocell));
    }

    static MemoryCellListPtr instance(const MemoryCellListPtr &other) {
        return MemoryCellListPtr(new MemoryCellList(*other));
    }


    // Virtual constructors
public:
    virtual MemoryStatePtr create(const SValuePtr &addrProtoval, const SValuePtr &valProtoval) const override {
        return instance(addrProtoval, valProtoval);
    }
    
    virtual MemoryStatePtr create(const MemoryCellPtr &protocell) const {
        return instance(protocell);
    }

    virtual MemoryStatePtr clone() const override {
        return MemoryStatePtr(new MemoryCellList(*this));
    }

    // Dynamic pointer casts
public:
    static MemoryCellListPtr promote(const BaseSemantics::MemoryStatePtr &m) {
        MemoryCellListPtr retval = boost::dynamic_pointer_cast<MemoryCellList>(m);
        ASSERT_not_null(retval);
        return retval;
    }

    // Methods we inherited
public:
    virtual void clear() override;
    virtual bool merge(const MemoryStatePtr &other, RiscOperators *addrOps, RiscOperators *valOps) 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 void hash(Combinatorics::Hasher&, RiscOperators *addrOps, RiscOperators *valOps) const 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 &addr, const SValuePtr &value,
                             RiscOperators *addrOps, RiscOperators *valOps) override;

    virtual void print(std::ostream&, Formatter&) const override;

    // Methods first declared at this level of the class hierarchy
public:
    bool mergeNoAliasing(const MemoryStatePtr &other, RiscOperators *addrOps, RiscOperators *valOps);

    bool mergeWithAliasing(const MemoryStatePtr &other, RiscOperators *addrOps, RiscOperators *valOps);

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

    bool occlusionsErased() const { return occlusionsErased_; }
    void occlusionsErased(bool b) { occlusionsErased_ = b; }
    template<class Iterator>
    CellList scan(Iterator &cursor /*in,out*/, const SValuePtr &addr, size_t nBits,
                  RiscOperators *addrOps, RiscOperators *valOps) const {
        ASSERT_not_null(addr);
        CellList retval;
        MemoryCellPtr tempCell = protocell->create(addr, valOps->undefined_(nBits));
        for (/*void*/; cursor!=cells.end(); ++cursor) {
            if (tempCell->mayAlias(*cursor, addrOps)) {
                retval.push_back(*cursor);
                if (tempCell->mustAlias(*cursor, addrOps))
                    break;
            }
        }
        return retval;
    }

    virtual const CellList& get_cells() const { return cells; }
    virtual       CellList& get_cells()       { return cells; }
    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;

protected:
    // Compute a new value by merging the specified cells.  If the cell list is empty return the specified default.
    virtual SValuePtr mergeCellValues(const CellList &cells, const SValuePtr &dflt, RiscOperators *addrOps,
                                      RiscOperators *valOps);

    // Returns the union of all writers from the specified cells.
    virtual AddressSet mergeCellWriters(const CellList &cells);

    // Returns the union of all properties from the specified cells.
    virtual InputOutputPropertySet mergeCellProperties(const CellList &cells);

    // Insert a new cell at the head of the list. It's writers set is empty and its I/O properties will be READ,
    // READ_BEFORE_WRITE, and READ_UNINITIALIZED.
    virtual MemoryCellPtr insertReadCell(const SValuePtr &addr, const SValuePtr &value);

    // Insert a new cell at the head of the list.  The specified writers and I/O properties are used.
    virtual MemoryCellPtr insertReadCell(const SValuePtr &addr, const SValuePtr &value,
                                         const AddressSet &writers, const InputOutputPropertySet &props);
};

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

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

#endif
#endif