AddressSpace.h

#ifndef ROSE_BinaryAnalysis_InstructionSemantics_BaseSemantics_AddressSpace_H
#define ROSE_BinaryAnalysis_InstructionSemantics_BaseSemantics_AddressSpace_H
#include <featureTests.h>
#ifdef ROSE_ENABLE_BINARY_ANALYSIS
#include <Rose/BinaryAnalysis/InstructionSemantics/BaseSemantics/BasicTypes.h>
 
#include <Rose/BinaryAnalysis/Address.h>
#include <Rose/BinaryAnalysis/RegisterDescriptor.h>
#include <Combinatorics.h>                              // ROSE
 
#include <boost/enable_shared_from_this.hpp>
#include <boost/serialization/access.hpp>
#include <boost/serialization/nvp.hpp>
#include <boost/serialization/shared_ptr.hpp>
 
namespace Rose {
namespace BinaryAnalysis {
namespace InstructionSemantics {
namespace BaseSemantics {
 
class AddressSpaceAddress {
private:
    RegisterDescriptor reg_;
    Sawyer::Optional<Address> concrete_;
    SValuePtr abstract_;
 
public:
    ~AddressSpaceAddress();
 
    AddressSpaceAddress();
 
    AddressSpaceAddress(RegisterDescriptor);            // implicit
 
    AddressSpaceAddress(Address);                       // implicit
 
    AddressSpaceAddress(const SValuePtr&);              // implicit
 
    bool isEmpty() const;
 
    RegisterDescriptor registerDescriptor() const;
    const Sawyer::Optional<Address>& concrete() const;
    SValuePtr abstract() const;
    Sawyer::Optional<Address> toConcrete() const;
 
    SValuePtr toAbstract(RiscOperators &addrOps) const;
};
 
 
class AddressSpace: public boost::enable_shared_from_this<AddressSpace> {
public:
    using Ptr = AddressSpacePtr;
 
    using Purpose = AddressSpacePurpose;
 
private:
    Purpose purpose_;
    std::string name_;
 
#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(purpose_);
        s & BOOST_SERIALIZATION_NVP(name_);
    }
#endif
 
public:
    virtual ~AddressSpace();
protected:
    AddressSpace();                                     // for de-serialization
    AddressSpace(Purpose, const std::string &name);
    AddressSpace(const AddressSpace&);
    AddressSpace& operator=(const AddressSpace&) = delete;
 
public:
    virtual Ptr clone() const = 0;
 
public:
    Purpose purpose() const;
    void purpose(Purpose);
    const std::string& name() const;
    void name(const std::string&);
    virtual void clear() = 0;
 
    virtual SValuePtr read(const AddressSpaceAddress&, const SValuePtr &dflt, RiscOperators &addrOps, RiscOperators &valOps);
 
    virtual SValuePtr peek(const AddressSpaceAddress&, const SValuePtr &dflt, RiscOperators &addrOps, RiscOperators &valOps);
 
    virtual void write(const AddressSpaceAddress&, const SValuePtr &value, RiscOperators &addrOps, RiscOperators &valOps);
 
    virtual void hash(Combinatorics::Hasher&, RiscOperators *addrOps, RiscOperators *valOps) const = 0;
 
    virtual bool merge(const AddressSpacePtr &other, RiscOperators *addrOps, RiscOperators *valOps) = 0;
 
    std::string printableName() const;
 
    void print(std::ostream&, const std::string &prefix = "") const;
    virtual void print(std::ostream&, Formatter&) const = 0;
    class WithFormatter {
        AddressSpacePtr obj;
        Formatter &fmt;
    public:
        ~WithFormatter();
        WithFormatter() = delete;
        WithFormatter(const AddressSpacePtr&, Formatter&);
        void print(std::ostream&) const;
    };
 
    WithFormatter with_format(Formatter&);
    WithFormatter operator+(Formatter&);
    WithFormatter operator+(const std::string &linePrefix);
};
 
std::ostream& operator<<(std::ostream&, const AddressSpace&);
std::ostream& operator<<(std::ostream&, const AddressSpace::WithFormatter&);
 
} // namespace
} // namespace
} // namespace
} // namespace
 
#endif
#endif