RegisterStateGeneric.h

#ifndef ROSE_BinaryAnalysis_InstructionSemantics_BaseSemantics_RegisterStateGeneric_H
#define ROSE_BinaryAnalysis_InstructionSemantics_BaseSemantics_RegisterStateGeneric_H
#include <featureTests.h>
#ifdef ROSE_ENABLE_BINARY_ANALYSIS
 
#include <Rose/BinaryAnalysis/BasicTypes.h>
#include <Rose/BinaryAnalysis/InstructionSemantics/BaseSemantics/BasicTypes.h>
#include <Rose/BinaryAnalysis/InstructionSemantics/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 InstructionSemantics {
namespace BaseSemantics {
 
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()); }
        SValuePtr get(RegisterDescriptor, RiscOperators*) const;
    };
 
    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 RegisterDictionaryPtr &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 RegisterDictionaryPtr &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 RegisterDictionaryPtr &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;
 
    // Documented in super class
    virtual void updateWriteProperties(RegisterDescriptor, InputOutputProperty) override;
    virtual void updateReadProperties(RegisterDescriptor) override;
 
    //                                  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::InstructionSemantics::BaseSemantics::RegisterStateGeneric);
#endif
 
#endif
#endif