BaseSemantics/RegisterStateGeneric.h

#ifndef ROSE_BinaryAnalysis_InstructionSemantics2_BaseSemantics_RegisterStateGeneric_H
#define ROSE_BinaryAnalysis_InstructionSemantics2_BaseSemantics_RegisterStateGeneric_H
#include <featureTests.h>
#ifdef ROSE_ENABLE_BINARY_ANALYSIS

#include <Rose/BinaryAnalysis/InstructionSemantics2/BaseSemantics/Types.h>
#include <Rose/BinaryAnalysis/InstructionSemantics2/BaseSemantics/RegisterState.h>
#include <Rose/Exception.h>

#include <boost/serialization/access.hpp>
#include <boost/serialization/base_object.hpp>
#include <boost/serialization/export.hpp>
#include <Sawyer/IntervalSetMap.h>

namespace Rose {
namespace BinaryAnalysis {
namespace InstructionSemantics2 {
namespace BaseSemantics {

typedef boost::shared_ptr<class RegisterStateGeneric> RegisterStateGenericPtr;

class RegisterStateGeneric: public RegisterState {
    //                                  Basic Types
public:
    using Super = RegisterState;

    using Ptr = RegisterStateGenericPtr;

    class RegisterNotPresent: public Rose::Exception {
        RegisterDescriptor desc_;
    public:
        explicit RegisterNotPresent(RegisterDescriptor)
            : Rose::Exception("accessed register is not available in register state") {}
    };

    typedef Sawyer::Container::Interval<size_t> BitRange;

    struct RegStore {
        unsigned majr, minr;

#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(majr);
            s & BOOST_SERIALIZATION_NVP(minr);
        }
#endif

    public:
        RegStore()                                      // for serialization
            : majr(0), minr(0) {}
        RegStore(RegisterDescriptor d) // implicit
            : majr(d.majorNumber()), minr(d.minorNumber()) {}
        bool operator<(const RegStore &other) const {
            return majr<other.majr || (majr==other.majr && minr<other.minr);
        }
    };


    //                                  Types for storing values
public:
    struct RegPair {
        RegisterDescriptor desc;
        SValuePtr value;

#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(desc);
            s & BOOST_SERIALIZATION_NVP(value);
        }
#endif

    public:
        RegPair() {}                                    // for serialization

    public:
        RegPair(RegisterDescriptor desc, const SValuePtr &value): desc(desc), value(value) {}
        BitRange location() const { return BitRange::baseSize(desc.offset(), desc.nBits()); }
    };

    typedef std::vector<RegPair> RegPairs;

    typedef Sawyer::Container::Map<RegStore, RegPairs> Registers;


    //                                  Types for Boolean properties
public:
    typedef Sawyer::Container::IntervalSetMap<BitRange, InputOutputPropertySet> BitProperties;

    typedef Sawyer::Container::Map<RegStore, BitProperties> RegisterProperties;


    //                                  Types for storing addresses
public:
    typedef Sawyer::Container::Set<rose_addr_t> AddressSet;

    typedef Sawyer::Container::IntervalSetMap<BitRange, AddressSet> BitAddressSet;

    typedef Sawyer::Container::Map<RegStore, BitAddressSet> RegisterAddressSet;


    //                                  Data members
private:
    RegisterProperties properties_;                     // Boolean properties for each bit of each register.
    RegisterAddressSet writers_;                        // Writing instruction address set for each bit of each register
    bool accessModifiesExistingLocations_;              // Can read/write modify existing locations?
    bool accessCreatesLocations_;                       // Can new locations be created?

protected:
    Registers registers_;

    //                                  Serialization
#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_BASE_OBJECT_NVP(RegisterState);
        s & BOOST_SERIALIZATION_NVP(properties_);
        s & BOOST_SERIALIZATION_NVP(writers_);
        s & BOOST_SERIALIZATION_NVP(accessModifiesExistingLocations_);
        s & BOOST_SERIALIZATION_NVP(accessCreatesLocations_);
        s & BOOST_SERIALIZATION_NVP(registers_);
    }
#endif
    
    //                                  Normal constructors
    //
    // These are protected because objects of this class are reference counted and always allocated on the heap.
protected:
    RegisterStateGeneric()                              // for serialization
        : accessModifiesExistingLocations_(true), accessCreatesLocations_(true) {}

    explicit RegisterStateGeneric(const SValuePtr &protoval, const RegisterDictionary *regdict)
        : RegisterState(protoval, regdict), accessModifiesExistingLocations_(true), accessCreatesLocations_(true) {
        clear();
    }

    RegisterStateGeneric(const RegisterStateGeneric &other)
        : RegisterState(other), properties_(other.properties_), writers_(other.writers_),
          accessModifiesExistingLocations_(other.accessModifiesExistingLocations_),
          accessCreatesLocations_(other.accessCreatesLocations_), registers_(other.registers_) {
        deep_copy_values();
    }


    //                                  Static allocating constructors
public:
    static RegisterStateGenericPtr instance(const SValuePtr &protoval, const RegisterDictionary *regdict) {
        return RegisterStateGenericPtr(new RegisterStateGeneric(protoval, regdict));
    }

    static RegisterStateGenericPtr instance(const RegisterStateGenericPtr &other) {
        return RegisterStateGenericPtr(new RegisterStateGeneric(*other));
    }

    
    //                                  Virtual constructors
public:
    virtual RegisterStatePtr create(const SValuePtr &protoval, const RegisterDictionary *regdict) const override {
        return instance(protoval, regdict);
    }

    virtual RegisterStatePtr clone() const override {
        return RegisterStateGenericPtr(new RegisterStateGeneric(*this));
    }

    //                                  Dynamic pointer casts
public:
    static RegisterStateGenericPtr promote(const RegisterStatePtr &from) {
        RegisterStateGenericPtr retval = boost::dynamic_pointer_cast<RegisterStateGeneric>(from);
        ASSERT_not_null(retval);
        return retval;
    }


    //                                  Object properties
public:
    bool accessModifiesExistingLocations() const /*final*/ { return accessModifiesExistingLocations_; }
    virtual void accessModifiesExistingLocations(bool b) { accessModifiesExistingLocations_ = b; }
    class AccessModifiesExistingLocationsGuard {
        RegisterStateGeneric *rstate_;
        bool savedValue_;
    public:
        AccessModifiesExistingLocationsGuard(RegisterStateGeneric *rstate, bool newValue)
            : rstate_(rstate), savedValue_(rstate->accessModifiesExistingLocations()) {
            rstate_->accessModifiesExistingLocations(newValue);
        }
        ~AccessModifiesExistingLocationsGuard() {
            rstate_->accessModifiesExistingLocations(savedValue_);
        }
    };

    bool accessCreatesLocations() const /*final*/ { return accessCreatesLocations_; }
    virtual void accessCreatesLocations(bool b) { accessCreatesLocations_ = b; }
    class AccessCreatesLocationsGuard {
        RegisterStateGeneric *rstate_;
        bool savedValue_;
    public:
        AccessCreatesLocationsGuard(RegisterStateGeneric *rstate, bool newValue)
            : rstate_(rstate), savedValue_(rstate->accessCreatesLocations()) {
            rstate_->accessCreatesLocations(newValue);
        }
        ~AccessCreatesLocationsGuard() {
            rstate_->accessCreatesLocations(savedValue_);
        }
    };


    //                                  Inherited non-constructors
public:
    virtual void clear() override;
    virtual void zero() override;
    virtual SValuePtr readRegister(RegisterDescriptor, const SValuePtr &dflt, RiscOperators*) override;
    virtual SValuePtr peekRegister(RegisterDescriptor, const SValuePtr &dflt, RiscOperators*) override;
    virtual void writeRegister(RegisterDescriptor, const SValuePtr &value, RiscOperators*) override;
    virtual void print(std::ostream&, Formatter&) const override;
    virtual bool merge(const RegisterStatePtr &other, RiscOperators*) override;
    virtual void hash(Combinatorics::Hasher&, RiscOperators*) const override;


    //                                  Initialization
public:
    virtual void initialize_large();

    virtual void initialize_small();

    void initialize_nonoverlapping(const std::vector<RegisterDescriptor>&, bool initialize_to_zero);


    //                                  Value storage queries
public:
    virtual RegPairs get_stored_registers() const;

    virtual bool is_partly_stored(RegisterDescriptor) const;

    virtual bool is_wholly_stored(RegisterDescriptor) const;

    virtual bool is_exactly_stored(RegisterDescriptor) const;

    virtual ExtentMap stored_parts(RegisterDescriptor) const;

    virtual RegPairs overlappingRegisters(RegisterDescriptor) const;

    virtual void erase_register(RegisterDescriptor, RiscOperators*);


    //                                  Traversals
public:
    class Visitor {
    public:
        virtual ~Visitor() {}
        virtual SValuePtr operator()(RegisterDescriptor, const SValuePtr&) = 0;
    };

    virtual void traverse(Visitor&);


    //                                  Writer addresses
public:
    virtual bool hasWritersAny(RegisterDescriptor) const;
    virtual bool hasWritersAll(RegisterDescriptor) const;
    virtual AddressSet getWritersUnion(RegisterDescriptor) const;

    virtual AddressSet getWritersIntersection(RegisterDescriptor) const;

    virtual bool insertWriters(RegisterDescriptor, const AddressSet &writerVas);

    virtual void eraseWriters(RegisterDescriptor, const AddressSet &writerVas);

    virtual void setWriters(RegisterDescriptor, const AddressSet &writers);

    virtual void eraseWriters(RegisterDescriptor);
    virtual void eraseWriters();
    //                                  Per-register bit Boolean properties
public:
    virtual bool hasPropertyAny(RegisterDescriptor, InputOutputProperty) const;
    virtual bool hasPropertyAll(RegisterDescriptor, InputOutputProperty) const;
    virtual InputOutputPropertySet getPropertiesUnion(RegisterDescriptor) const;
    virtual InputOutputPropertySet getPropertiesIntersection(RegisterDescriptor) const;
    virtual bool insertProperties(RegisterDescriptor, const InputOutputPropertySet&);

    virtual bool eraseProperties(RegisterDescriptor, const InputOutputPropertySet&);

    virtual void setProperties(RegisterDescriptor, const InputOutputPropertySet&);

    virtual void eraseProperties(RegisterDescriptor);
    virtual void eraseProperties();
    virtual std::vector<RegisterDescriptor>
    findProperties(const InputOutputPropertySet &required,
                   const InputOutputPropertySet &prohibited = InputOutputPropertySet()) const;

    virtual void updateWriteProperties(RegisterDescriptor, InputOutputProperty);

    virtual void updateReadProperties(RegisterDescriptor);

    //                                  Non-public APIs
protected:
    void deep_copy_values();

    // Given a register descriptor return information about what's stored in the state. The two return values are:
    //
    //     accessedParts represent the parts of the reigster (matching major and minor numbers) that are present in the
    //     state and overlap with the specified register.
    //
    //     preservedParts represent the parts of the register that are present in the state but don't overlap with the
    //     specified register.
    void scanAccessedLocations(RegisterDescriptor reg, RiscOperators *ops,
                               RegPairs &accessedParts /*out*/, RegPairs &preservedParts /*out*/) const;

    // Given a register descriptor, zero out all the stored parts of the same register (by matching major and minor numbers)
    // if the stored part overlaps with the specified register.
    void clearOverlappingLocations(RegisterDescriptor);

    void assertStorageConditions(const std::string &where, RegisterDescriptor what) const;
};

} // namespace
} // namespace
} // namespace
} // namespace

#ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
BOOST_CLASS_EXPORT_KEY(Rose::BinaryAnalysis::InstructionSemantics2::BaseSemantics::RegisterStateGeneric);
#endif

#endif
#endif