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/AddressSet.h>
#include <Rose/BinaryAnalysis/BasicTypes.h>
#include <Rose/BinaryAnalysis/InstructionSemantics/BaseSemantics/RegisterState.h>
#include <Rose/Exception.h>
 
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
#include <boost/serialization/access.hpp>
#include <boost/serialization/base_object.hpp>
#include <boost/serialization/export.hpp>
#endif
 
#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);
    };
    class RegisterNotPresent: public Rose::Exception {…};
 
    using BitRange = Sawyer::Container::Interval<size_t>;
 
    struct RegStore {
        unsigned majr, minr;
 
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
    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
        RegStore(RegisterDescriptor);
        bool operator<(const RegStore&) const;
    };
    struct RegStore {…};
 
 
    //                                  Types for storing values
public:
    struct RegPair {
        RegisterDescriptor desc;
        SValuePtr value;
 
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
    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();
        RegPair();                                      // for serialization
 
    public:
        RegPair(RegisterDescriptor, const SValuePtr&);
        BitRange location() const;
        SValuePtr get(RegisterDescriptor, RiscOperators*) const;
    };
    struct RegPair {…};
 
    using RegPairs = std::vector<RegPair>;
 
    using Registers = Sawyer::Container::Map<RegStore, RegPairs>;
 
 
    //                                  Types for Boolean properties
public:
    using BitProperties = Sawyer::Container::IntervalSetMap<BitRange, InputOutputPropertySet>;
 
    using RegisterProperties = Sawyer::Container::Map<RegStore, BitProperties>;
 
 
    //                                  Types for storing addresses
public:
    using BitAddressSet = Sawyer::Container::IntervalSetMap<BitRange, AddressSet>;
 
    using RegisterAddressSet = Sawyer::Container::Map<RegStore, BitAddressSet>;
 
 
    //                                  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_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(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.
public:
    ~RegisterStateGeneric();
 
protected:
    RegisterStateGeneric();                             // for serialization
 
 
    RegisterStateGeneric(const SValuePtr &protoval, const RegisterDictionaryPtr&);
 
    RegisterStateGeneric(const RegisterStateGeneric&);
 
    //                                  Static allocating constructors
public:
    static RegisterStateGenericPtr instance(const SValuePtr &protoval, const RegisterDictionaryPtr&);
 
    static RegisterStateGenericPtr instance(const RegisterStateGenericPtr &other);
 
    //                                  Virtual constructors
public:
    virtual RegisterStatePtr create(const SValuePtr &protoval, const RegisterDictionaryPtr&) const override;
    virtual AddressSpacePtr clone() const override;
 
    //                                  Dynamic pointer casts
public:
    static RegisterStateGenericPtr promote(const AddressSpacePtr &from);
 
    //                                  Object properties
public:
    bool accessModifiesExistingLocations() const /*final*/;
    virtual void accessModifiesExistingLocations(bool);
    class AccessModifiesExistingLocationsGuard {
        RegisterStateGeneric *rstate_;
        bool savedValue_;
    public:
        AccessModifiesExistingLocationsGuard(RegisterStateGeneric *rstate, bool newValue);
        ~AccessModifiesExistingLocationsGuard();
    };
    class AccessModifiesExistingLocationsGuard {…};
 
    bool accessCreatesLocations() const /*final*/;
    virtual void accessCreatesLocations(bool);
    class AccessCreatesLocationsGuard {
        RegisterStateGeneric *rstate_;
        bool savedValue_;
    public:
        AccessCreatesLocationsGuard(RegisterStateGeneric *rstate, bool newValue);
        ~AccessCreatesLocationsGuard();
    };
    class AccessCreatesLocationsGuard {…};
 
 
    //                                  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 AddressSpacePtr &other, RiscOperators *addrOps, RiscOperators *valOps) override;
    virtual void hash(Combinatorics::Hasher&, RiscOperators *addrOps, RiscOperators *valOps) 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;
    };
    class Visitor {…};
 
    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;
};
class RegisterStateGeneric: public RegisterState {…};
 
} // namespace
} // namespace
} // namespace
} // namespace
 
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
BOOST_CLASS_EXPORT_KEY(Rose::BinaryAnalysis::InstructionSemantics::BaseSemantics::RegisterStateGeneric);
#endif
 
#endif
#endif