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>
#include <Rose/BinaryAnalysis/ByteCode/Analysis.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:
    size_t frameId_ = 0; // unique frame identifier
    Sawyer::Optional<Address> returnAddress_ = Sawyer::Nothing(); // caller resume address
    std::vector<SValuePtr> stack_;  // operand stack for the frame
    std::vector<SValuePtr> locals_; // local variables for the frame
    ByteCode::Method::Ptr method_;  // method associated with this invocation frame
    SValuePtr currentException_;    // exception currently associated with this 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(frameId_);
        s & BOOST_SERIALIZATION_NVP(returnAddress_);
        s & BOOST_SERIALIZATION_NVP(stack_);
        s & BOOST_SERIALIZATION_NVP(locals_);
        s & BOOST_SERIALIZATION_NVP(method_);
        s & BOOST_SERIALIZATION_NVP(currentException_);
    }
#endif
 
public:
    ~FrameState();
 
protected:
    FrameState(); // for serialization
 
    // All memory states should be heap allocated; use instance(), create(), or clone() instead.
    explicit FrameState(const SValue::Ptr &valProtoval, const Sawyer::Optional<Address> &, const ByteCode::Method::Ptr &);
    explicit FrameState(const FrameState &other);
 
public:
    static FrameStatePtr instance(const SValuePtr &, const Sawyer::Optional<Address> &, const ByteCode::Method::Ptr &);
 
public:
    // documented in base class
    MemoryStatePtr create(const SValuePtr &addrProtoval, const SValuePtr &valProtoval) const override;
 
    // documented in base class
    AddressSpacePtr clone() const override;
 
    static FrameStatePtr promote(const AddressSpacePtr&);
 
public:
    void clear() override;
    void clearFrame();
 
    bool merge(const AddressSpacePtr &other, RiscOperators *addrOps, RiscOperators *valOps) override;
 
    SValuePtr readMemory(const SValuePtr &address, const SValuePtr &dflt,
                         RiscOperators *addrOps, RiscOperators *valOps) override;
 
    void writeMemory(const SValuePtr &address, const SValuePtr &value,
                     RiscOperators *addrOps, RiscOperators *valOps) override;
 
    SValuePtr peekMemory(const SValuePtr &address, const SValuePtr &dflt,
                         RiscOperators *addrOps, RiscOperators *valOps) override;
 
    SValuePtr readLocal(size_t index) const override;
    void writeLocal(size_t index, const SValuePtr &value) override;
 
    SValuePtr peekOperand(size_t depth = 0) override;
    SValuePtr popOperand() override;
    void pushOperand(const SValuePtr &value) override;
 
    SValuePtr currentException() const;
    void currentException(const SValuePtr &value);
 
public:
    void hash(Combinatorics::Hasher&, RiscOperators* addrOps, RiscOperators* valOps) const override;
    void print(std::ostream&, Formatter&) const override;
 
    ByteCode::Method::Ptr method() const;
 
    SValuePtr createArgument(const std::string &descriptor, size_t argIdx);
    static std::string argumentDescriptor(const std::string &descriptor, size_t argIdx);
 
    const Sawyer::Optional<Address>& returnAddress() const;
    void returnAddress(Address);
 
    size_t frameId() const;
    void frameId(size_t);
    static size_t newFrameId();
 
    std::string frameLabel() const;
    std::string frameName() const;
 
    // Short form of frameLabel
    std::string label() const override;
 
    static bool isCategory1(const SValuePtr&);
    static bool isCategory2(const SValuePtr&);
    static bool isCategory2Tail(const SValuePtr&);
 
private:
    void initializeForRootFrame();
 
    void clearLocalRange(size_t begin, size_t nSlots);
};
    
} // namespace
} // namespace
} // namespace
} // namespace
 
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
BOOST_CLASS_EXPORT_KEY(Rose::BinaryAnalysis::InstructionSemantics::BaseSemantics::FrameState);
#endif
 
#endif
#endif