BinaryStackVariable.h

#ifndef ROSE_BinaryAnalysis_StackVariable_H
#define ROSE_BinaryAnalysis_StackVariable_H

#include <BaseSemantics2.h>
#include <MemoryCellList.h>
#include <Sawyer/Interval.h>
#include <boost/serialization/access.hpp>

namespace Rose {
namespace BinaryAnalysis {

struct StackVariableLocation {
    int64_t offset;                                     
    size_t nBytes;                                      
    InstructionSemantics2::BaseSemantics::SValuePtr address; 
#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(offset);
        s & BOOST_SERIALIZATION_NVP(nBytes);
        s & BOOST_SERIALIZATION_NVP(address);
    }
#endif

public:
    StackVariableLocation()
        : offset(0), nBytes(0) {}
    StackVariableLocation(int64_t offset, size_t nBytes, const InstructionSemantics2::BaseSemantics::SValuePtr &address)
        : offset(offset), nBytes(nBytes), address(address) {}
    typedef Sawyer::Container::Interval<int64_t> Interval;
    Interval interval() const { return Interval::baseSize(offset, nBytes); }
};

struct StackVariableMeta {
    InstructionSemantics2::BaseSemantics::MemoryCellList::AddressSet writers; 
    InstructionSemantics2::BaseSemantics::InputOutputPropertySet ioProperties; 
#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(writers);
        s & BOOST_SERIALIZATION_NVP(ioProperties);
    }
#endif

public:
    StackVariableMeta() {}
    StackVariableMeta(const InstructionSemantics2::BaseSemantics::MemoryCellList::AddressSet &writers, 
                      const InstructionSemantics2::BaseSemantics::InputOutputPropertySet &ioProperties)
        : writers(writers), ioProperties(ioProperties) {}
    bool operator==(const StackVariableMeta &other) const {
        return writers == other.writers && ioProperties == other.ioProperties;
    }
};

struct StackVariable {
    StackVariableLocation location;                     
    StackVariableMeta meta;                             
#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(location);
        s & BOOST_SERIALIZATION_NVP(meta);
    }
#endif

public:
    StackVariable() {}
    StackVariable(const StackVariableLocation &location, const StackVariableMeta &meta)
        : location(location), meta(meta) {}
};

typedef std::vector<StackVariable> StackVariables;

} // namespace
} // namespace

#endif