RegisterParts.h

#ifndef ROSE_BinaryAnalysis_RegisterParts_H
#define ROSE_BinaryAnalysis_RegisterParts_H
#include <featureTests.h>
#ifdef ROSE_ENABLE_BINARY_ANALYSIS
 
#include <Rose/BinaryAnalysis/BasicTypes.h>
 
#include <Sawyer/IntervalSet.h>
#include <Sawyer/Map.h>
 
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
#include <boost/serialization/access.hpp>
#endif
 
namespace Rose {
namespace BinaryAnalysis {
 
class RegisterParts {
 
private:
    typedef Sawyer::Container::Interval<size_t> BitRange;
    typedef Sawyer::Container::IntervalSet<BitRange> BitSet;
 
 // DQ (2/13/2017): Testing a simpler case.
 // BitSet XXX;
 
private:
    class MajorMinor {
        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:
        MajorMinor(): majr_(0), minr_(0) {}
 
        MajorMinor(RegisterDescriptor reg) /*implicit*/
            : majr_(reg.majorNumber()), minr_(reg.minorNumber()) {}
 
        bool operator<(const MajorMinor &other) const {
            return majr_ < other.majr_ || (majr_ == other.majr_ && minr_ < other.minr_);
        }
 
        unsigned get_major() const { return majr_; }    // "get_" works around Windows #define pollution
        unsigned get_minor() const { return minr_; }    // "get_" works around Windows #define pollution
    };
 
private:
 // DQ (2/13/2017): Test alternative formulation.
    typedef Sawyer::Container::Map<MajorMinor, BitSet> Map;
 
 // DQ (2/13/2017): Testing a simpler case.
 // typedef Sawyer::Container::Map<MajorMinor, BitSet > MapXXX;
 // MapXXX Map_YYY;
 
 // DQ (2/13/2017): Both of these work fine.
 // typedef Sawyer::Container::Map<MajorMinor, Sawyer::Container::IntervalSet< Sawyer::Container::Interval<size_t> > > Map;
 // typedef Sawyer::Container::Map<MajorMinor, Sawyer::Container::IntervalSet< BitRange > > Map;
    Map map_;
 
 
#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(map_);
    }
#endif
    
public:
    RegisterParts() {}
 
    explicit RegisterParts(RegisterDescriptor reg) {
        insert(reg);
    }
 
    bool isEmpty() const {
        return map_.isEmpty();
    }
 
    bool existsAny(RegisterDescriptor reg) const {
        return map_.exists(reg) && map_[reg].overlaps(bitRange(reg));
    }
 
    bool existsAll(RegisterDescriptor reg) const {
        return map_.exists(reg) && map_[reg].contains(bitRange(reg));
    }
 
    void insert(RegisterDescriptor reg) {
        map_.insertMaybeDefault(reg).insert(bitRange(reg));
    }
 
    void erase(RegisterDescriptor reg);
 
    void clear() {
        map_.clear();
    }
 
    RegisterParts& operator-=(const RegisterParts &other);
 
    RegisterParts operator-(const RegisterParts &other) const;
 
    RegisterParts& operator|=(const RegisterParts &other);
 
    RegisterParts operator|(const RegisterParts &other) const;
 
    RegisterParts& operator&=(const RegisterParts &other);
 
    RegisterParts operator&(const RegisterParts &other) const;
    
    std::vector<RegisterDescriptor> extract(const RegisterDictionaryPtr &regDict, bool extractAll = false);
 
    std::vector<RegisterDescriptor> listAll(const RegisterDictionaryPtr&) const;
    std::vector<RegisterDescriptor> listNamed(const RegisterDictionaryPtr&) const;
private:
    static BitRange bitRange(RegisterDescriptor reg) {
        ASSERT_forbid(reg.isEmpty());
        return BitRange::baseSize(reg.offset(), reg.nBits());
    }
 
};
 
} // namespace
} // namespace
 
#endif
#endif