FrameState.h

#ifndef ROSE_BinaryAnalysis_InstructionSemantics_BaseSemantics_FrameState_H
#define ROSE_BinaryAnalysis_InstructionSemantics_BaseSemantics_FrameState_H
#include <featureTests.h>
#ifdef ROSE_ENABLE_BINARY_ANALYSIS
 
#include <Rose/BinaryAnalysis/InstructionSemantics/BaseSemantics/BasicTypes.h>
#include <Rose/BinaryAnalysis/InstructionSemantics/BaseSemantics/AddressSpace.h>
#include <Rose/BinaryAnalysis/InstructionSemantics/BaseSemantics/MemoryState.h>
 
namespace Rose {
namespace BinaryAnalysis {
namespace InstructionSemantics {
namespace BaseSemantics {
 
using FrameStatePtr = boost::shared_ptr<class FrameState>;
 
//                                      Frame State
 
class FrameState: public MemoryState {
public:
    using Super = MemoryState;
 
    using Ptr = FrameStatePtr;
 
private:
    std::vector<SValuePtr> stack_; // operand stack for the frame
    std::vector<SValuePtr> locals_; // local variables array for the frame
 
    // Serialization
#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(stack_);
        s & BOOST_SERIALIZATION_NVP(locals_);
    }
#endif
 
public:
    ~FrameState();
 
protected:
    FrameState(); // for serialization
 
    // All memory states should be heap allocated; use instance(), create(), or clone() instead.
    explicit FrameState(const SValuePtr &valProtoval);
 
public:
    static FrameStatePtr instance(const SValuePtr &valProtoval);
 
public:
    // documented in base class
    virtual MemoryStatePtr create(const SValuePtr &addrProtoval, const SValuePtr &valProtoval) const override;
 
    // documented in base class
    virtual AddressSpacePtr clone() const override;
 
    static FrameStatePtr promote(const AddressSpacePtr&);
 
public:
    virtual bool merge(const AddressSpacePtr &other, RiscOperators *addrOps, RiscOperators *valOps) override;
 
    virtual void clear() override;
 
    virtual SValuePtr readMemory(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 SValuePtr peekMemory(const SValuePtr &address, const SValuePtr &dflt,
                                 RiscOperators *addrOps, RiscOperators *valOps) override;
 
    SValuePtr readLocal(uint8_t index) override;
    void writeLocal(uint8_t index, const SValuePtr &value) override;
 
    SValuePtr popOperand() override;
    void pushOperand(const SValuePtr &value) override;
 
public:
    virtual void hash(Combinatorics::Hasher&, RiscOperators *addrOps, RiscOperators *valOps) const override;
 
    virtual void print(std::ostream&, Formatter&) const override;
};
    
} // namespace
} // namespace
} // namespace
} // namespace
 
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
BOOST_CLASS_EXPORT_KEY(Rose::BinaryAnalysis::InstructionSemantics::BaseSemantics::FrameState);
#endif
 
#endif
#endif