State.h

#ifndef ROSE_BinaryAnalysis_InstructionSemantics_BaseSemantics_State_H
#define ROSE_BinaryAnalysis_InstructionSemantics_BaseSemantics_State_H
#include <featureTests.h>
#ifdef ROSE_ENABLE_BINARY_ANALYSIS
#include <Rose/BinaryAnalysis/InstructionSemantics/BaseSemantics/BasicTypes.h>
#include <Rose/BinaryAnalysis/InstructionSemantics/BaseSemantics/State.h>
#include <Rose/BinaryAnalysis/InstructionSemantics/BaseSemantics/SValue.h>
 
#include <Rose/BinaryAnalysis/RegisterDescriptor.h>
#include <Combinatorics.h>                              // rose
 
#include <boost/enable_shared_from_this.hpp>
 
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
#include <boost/serialization/access.hpp>
#include <boost/serialization/export.hpp>
#include <boost/serialization/nvp.hpp>
#include <boost/serialization/shared_ptr.hpp>
#endif
 
namespace Rose {
namespace BinaryAnalysis {
namespace InstructionSemantics {
namespace BaseSemantics {
 
//                                      State
 
class State: public boost::enable_shared_from_this<State> {
public:
    using Ptr = StatePtr;
 
private:
    SValuePtr protoval_;                                // Initial value used to create additional values as needed.
    std::vector<AddressSpacePtr> addressSpaces_;        // All address spaces for this semantic state.
    RegisterStatePtr registers_;                        // All machine register values for this semantic state.
    MemoryStatePtr memory_;                             // All memory for this semantic state.
    RegisterStatePtr interrupts_;                       // Whether interrupts occurred.
    SValuePtr returnValue_;                             // Result returned by the root method, if any.
    bool terminated_ = false;                           // No further instructions execute on this path.
 
    // Serialization.
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned version) {
        ASSERT_require2(version >= 2, version);
        s & BOOST_SERIALIZATION_NVP(protoval_);
        s & BOOST_SERIALIZATION_NVP(addressSpaces_);
        s & BOOST_SERIALIZATION_NVP(registers_);
        s & BOOST_SERIALIZATION_NVP(memory_);
        s & BOOST_SERIALIZATION_NVP(interrupts_);
        s & BOOST_SERIALIZATION_NVP(returnValue_);
        s & BOOST_SERIALIZATION_NVP(terminated_);
    }
#endif
 
 
    // Real constructors.
protected:
    // needed for serialization
    State();
 
    State(const RegisterStatePtr &registers, const MemoryStatePtr &memory, const RegisterStatePtr &interrupts, const FrameStatePtr &frame);
    State(const RegisterStatePtr &registers, const MemoryStatePtr &memory, const RegisterStatePtr &interrupts);
    State(const RegisterStatePtr &registers, const MemoryStatePtr &memory);
 
    // deep-copy the registers and memory
    State(const State &other);
 
public:
    virtual ~State();
 
    // Static allocating constructors
public:
    static StatePtr instance(const RegisterStatePtr &registers, const MemoryStatePtr &memory,
                             const RegisterStatePtr &interrupts, const FrameStatePtr &frame);
 
    static StatePtr instance(const RegisterStatePtr &registers, const MemoryStatePtr &memory, const RegisterStatePtr &interrupts);
 
    static StatePtr instance(const RegisterStatePtr &registers, const MemoryStatePtr &memory);
 
    static StatePtr instance(const StatePtr &other);
 
    // Virtual constructors.
public:
    virtual StatePtr create(const RegisterStatePtr &registers, const MemoryStatePtr &memory) const;
 
    virtual StatePtr clone() const;
 
    // Dynamic pointer casts.  No-op since this is the base class.
public:
    static StatePtr promote(const StatePtr&);
 
    // Properties of a state.
public:
    SValuePtr protoval() const;
 
    // Address space declaration and searching.
public:
    void insertAddressSpace(const AddressSpacePtr&);
 
    const std::vector<AddressSpacePtr>& addressSpaces() const;
 
    AddressSpacePtr findFirstAddressSpace(AddressSpacePurpose) const;
 
    AddressSpacePtr findFirstAddressSpace(AddressSpacePurpose, const std::string &name) const;
 
    // Low-level operations on address spaces.
public:
    virtual SValuePtr read(const AddressSpacePtr&, const AddressSpaceAddress&, const SValuePtr &dflt,
                           RiscOperators &addrOps, RiscOperators &valOps);
 
    virtual SValuePtr peek(const AddressSpacePtr&, const AddressSpaceAddress&, const SValuePtr &dflt,
                           RiscOperators &addrOps, RiscOperators &valOps);
 
    virtual void write(const AddressSpacePtr&, const AddressSpaceAddress&, const SValuePtr &value,
                       RiscOperators &addrOps, RiscOperators &valOps);
 
    virtual bool merge(const StatePtr &other, RiscOperators *addrOps, RiscOperators *valOps);
 
    // Operations on address spaces found by searching.
public:
    virtual void clear();
 
    void zeroRegisters();
 
    void clearMemory();
 
    RegisterStatePtr registerState() const;
 
    MemoryStatePtr memoryState() const;
 
    RegisterStatePtr interruptState() const;
 
    void interruptState(const RegisterStatePtr&);
 
    bool hasInterruptState() const;
 
    FrameStatePtr frameState() const;
 
    bool hasFrameState() const;
 
    void terminate();
    void terminate(SValuePtr returnValue);
 
    bool isTerminated() const;
 
    SValuePtr returnValue() const;
 
    virtual SValuePtr readLocal(size_t index);
    virtual void writeLocal(size_t index, const SValuePtr &value);
 
    virtual SValuePtr peekOperand(size_t depth = 0);
 
    virtual void pushOperand(const SValuePtr &value);
 
    virtual SValuePtr popOperand();
 
    virtual void pushFrame(const FrameStatePtr &frame);
 
    virtual FrameStatePtr popFrame();
 
    virtual FrameStatePtr currentFrame() const;
 
    virtual SValuePtr readRegister(RegisterDescriptor desc, const SValuePtr &dflt, RiscOperators *ops);
 
    virtual SValuePtr peekRegister(RegisterDescriptor desc, const SValuePtr &dflt, RiscOperators *ops);
 
    virtual void writeRegister(RegisterDescriptor desc, const SValuePtr &value, RiscOperators *ops);
 
    virtual SValuePtr readMemory(const SValuePtr &address, const SValuePtr &dflt,
                                 RiscOperators *addrOps, RiscOperators *valOps);
 
    virtual SValuePtr peekMemory(const SValuePtr &address, const SValuePtr &dflt, RiscOperators *addrOps, RiscOperators *valOps);
 
    virtual void writeMemory(const SValuePtr &addr, const SValuePtr &value, RiscOperators *addrOps, RiscOperators *valOps);
 
    virtual SValuePtr readInterrupt(unsigned major, unsigned minor, const SValuePtr &dflt, RiscOperators *valOps);
 
    virtual SValuePtr peekInterrupt(unsigned major, unsigned minor, const SValuePtr &dflt, RiscOperators *valOps);
 
    virtual bool writeInterrupt(unsigned major, unsigned minor, const SValuePtr &value, RiscOperators *valOps);
 
    SValuePtr raiseInterrupt(unsigned major, unsigned minor, RiscOperators *valOps);
 
    SValuePtr clearInterrupt(unsigned major, unsigned minor, RiscOperators *valOps);
 
    bool isInterruptDefinitelyRaised(unsigned major, unsigned minor, RiscOperators *valOps);
 
    bool isInterruptDefinitelyClear(unsigned major, unsigned minor, RiscOperators *valOps);
 
    virtual void hash(Combinatorics::Hasher&, RiscOperators *addrOps, RiscOperators *valOps) const;
 
    void printRegisters(std::ostream &stream, const std::string &prefix = "");
    virtual void printRegisters(std::ostream &stream, Formatter &fmt) const;
    void printMemory(std::ostream &stream, const std::string &prefix = "") const;
    virtual void printMemory(std::ostream &stream, Formatter &fmt) const;
    void printInterrupts(std::ostream&, const std::string &prefix = "");
    virtual void printInterrupts(std::ostream &stream, Formatter &fmt) const;
    void print(std::ostream &stream, const std::string &prefix = "") const;
    virtual void print(std::ostream&, Formatter&) const;
    std::string toString() const;
 
    class WithFormatter {
        StatePtr obj;
        Formatter &fmt;
    public:
        WithFormatter(const StatePtr &obj, Formatter &fmt): obj(obj), fmt(fmt) {}
        void print(std::ostream &stream) const { obj->print(stream, fmt); }
    };
 
    WithFormatter with_format(Formatter &fmt) { return WithFormatter(shared_from_this(), fmt); }
    WithFormatter operator+(Formatter &fmt) { return with_format(fmt); }
    WithFormatter operator+(const std::string &linePrefix);
    virtual bool merge(const StatePtr &other, RiscOperators *ops);
};
 
std::ostream& operator<<(std::ostream&, const State&);
std::ostream& operator<<(std::ostream&, const State::WithFormatter&);
 
} // namespace
} // namespace
} // namespace
} // namespace
 
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
BOOST_CLASS_VERSION(Rose::BinaryAnalysis::InstructionSemantics::BaseSemantics::State, 2);
BOOST_CLASS_EXPORT_KEY(Rose::BinaryAnalysis::InstructionSemantics::BaseSemantics::State);
#endif
 
#endif
#endif