RegisterDescriptor.h

#ifndef ROSE_BinaryAnalysis_RegisterDescriptor_H
#define ROSE_BinaryAnalysis_RegisterDescriptor_H
#include <featureTests.h>
#ifdef ROSE_ENABLE_BINARY_ANALYSIS
 
#include <Sawyer/Interval.h>
 
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
#include <boost/serialization/access.hpp>
#endif
 
namespace Rose {
namespace BinaryAnalysis {
 
class RegisterDescriptor {
    // The major, minor, offset, and size are packed together into this single data member.
    //
    //   + The major number is the high order four bits at position 28-31 (inclusive) with bit #0 being the LSB.
    //   + The minor number is the 10 bits at position 18-27.
    //   + The offset is the 9 bits at position 9-17, but see note below and offset in [0,511].
    //   + The width-1 is the 9 bits at position 0-8, but see note below and width in [1,512].
    //
    // We need to be able to store a width of zero in order to distinguish between valid descriptors and invalid (default
    // constructed) descriptors, but there aren't enough bits in the width field by itself to do that.  We also need to be able
    // to store and retrive the full range of major, minor, and offset values for zero-width descriptors. To accomplish that,
    // we use the invarant that the offset+width of a valid descriptor cannot exceed 512 bits. Therefore, if the width field
    // plus offset field equals 512 then the actual offset is as specified in the range [1,511] and the actual offset is zero;
    // and if the offset field is 2 and the width field is 511 (the EMPTY_PATTERN constant) then the actual offset and actual
    // width are both zero.
    //
    // There are still unused bit combinations that we could use to extend the ranges of any of the four fields. For instance,
    // we don't necessarily need to align the fields on bit boundaries. We could use the fact that registers of size R bits need
    // (R+1)*R/2 values to represent all combinations of offset and size, although this requires integer division to retrieve
    // the values.
    uint32_t data_;
 
    // This pattern represents major=0, minor=0, offset=0, width=0 (offset field = 2, width field = 511)
    static const uint32_t EMPTY_PATTERN     = 0x000005ff; // EMPTY_PATTERN & ~OFFSET_WIDTH_MASK == 0
    static const uint32_t OFFSET_WIDTH_MASK = 0x0003ffff; // 9-bit offset and 9-bit width
 
#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(data_);
    }
#endif
 
public:
    RegisterDescriptor()
        : data_(EMPTY_PATTERN) {}
    RegisterDescriptor() {…}
 
    RegisterDescriptor(unsigned majr, unsigned minr, size_t offset, size_t width)
        : data_(0) {
        majorNumber(majr);
        minorNumber(minr);
        setOffsetWidth(offset, width);
    }
    RegisterDescriptor(unsigned majr, unsigned minr, size_t offset, size_t width) {…}
 
    static RegisterDescriptor fromRaw(uint32_t raw) {
        RegisterDescriptor retval;
        retval.data_ = raw;
        return retval;
    }
    static RegisterDescriptor fromRaw(uint32_t raw) {…}
 
    static unsigned maxMajor();
 
    static unsigned maxMinor();
 
    static unsigned maxOffset();
 
    static unsigned maxNBits();
 
    unsigned majorNumber() const {
        return data_ >> 28;                             // bits 28-31 (4 bits)
    }
    unsigned majorNumber() const  {…}
    void majorNumber(unsigned);
    unsigned minorNumber() const {
        return (data_ >> 18) & 0x3ff;                   // bits 18-27 (10 bits)
    }
    unsigned minorNumber() const  {…}
    void minorNumber(unsigned);
    inline size_t offset() const {
        if ((data_ & OFFSET_WIDTH_MASK) == EMPTY_PATTERN)
            return 0;
        unsigned offsetField = (data_ >> 9) & 0x1ff;    // bits 9-17 (9 bits)
        unsigned widthField = data_ & 0x1ff;            // bits 0-8 (9 bits)
        if (offsetField + widthField == 512)
            return offsetField;
        return offsetField;
    }
    inline size_t offset() const  {…}
    void offset(size_t);
    inline size_t nBits() const {
        if ((data_ & OFFSET_WIDTH_MASK) == EMPTY_PATTERN)
            return 0;
        unsigned offsetField = (data_ >> 9) & 0x1ff;    // bits 9-17 (9 bits)
        unsigned widthField = data_ & 0x1ff;            // bits 0-8 (9 bits)
        if (offsetField + widthField == 512)
            return 0;
        return widthField + 1;
    }
    inline size_t nBits() const  {…}
    void nBits(size_t);
    Sawyer::Container::Interval<size_t> bits() const {
        if (const size_t n = nBits()) {
            return Sawyer::Container::Interval<size_t>::baseSize(offset(), n);
        } else {
            return {};
        }
    }
    Sawyer::Container::Interval<size_t> bits() const  {…}
 
    void setOffsetWidth(size_t offset, size_t nBits);
 
    bool isEmpty() const {
        return 0 == nBits();
    }
    bool isEmpty() const  {…}
 
    bool isValid() const {
        return nBits() != 0;
    }
    bool isValid() const  {…}
 
    uint32_t raw() const {
        return data_;
    }
    uint32_t raw() const  {…}
    void raw(uint32_t r) {
        data_ = r;
    }
    void raw(uint32_t r) {…}
    // The following trickery is to have something like "explicit operator bool" before C++11
private:
    typedef void(RegisterDescriptor::*unspecified_bool)() const;
    void this_type_does_not_support_comparisons() const {}
public:
    operator unspecified_bool() const {
        return isEmpty() ? 0 : &RegisterDescriptor::this_type_does_not_support_comparisons;
    }
 
    bool operator<(RegisterDescriptor other) const {
        return data_ < other.data_;
    }
    bool operator<(RegisterDescriptor other) const  {…}
 
    bool operator==(RegisterDescriptor other) const {
        return data_ == other.data_;
    }
    bool operator==(RegisterDescriptor other) const  {…}
 
    bool operator!=(RegisterDescriptor other) const {
        return data_ != other.data_;
    }
    bool operator!=(RegisterDescriptor other) const  {…}
 
    RegisterDescriptor operator&(RegisterDescriptor other) const;
 
    bool isSubsetOf(RegisterDescriptor other) const;
 
    unsigned hash() const {
        return data_;
    }
    unsigned hash() const  {…}
 
    void print(std::ostream &o) const {
        o <<"{" <<majorNumber() <<"," <<minorNumber() <<"," <<offset() <<"," <<nBits() <<"}";
    }
    void print(std::ostream &o) const  {…}
 
    std::string toString() const;
 
    friend std::ostream& operator<<(std::ostream&, RegisterDescriptor);
 
    // Old interface  (not deprecated yet, just implemented in terms of the new interface)
 
    unsigned get_major() const {
        return majorNumber();
    }
    bool is_valid() const {
        return !isEmpty();
    }
    RegisterDescriptor &set_major(unsigned majr) {
        majorNumber(majr);
        return *this;
    }
    unsigned get_minor() const {
        return minorNumber();
    }
    RegisterDescriptor &set_minor(unsigned minr) {
        this->minorNumber(minr);
        return *this;
    }
    unsigned get_offset() const {
        return offset();
    }
    RegisterDescriptor &set_offset(unsigned offset) {
        this->offset(offset);
        return *this;
    }
    unsigned get_nbits() const {
        return nBits();
    }
    RegisterDescriptor &set_nbits(unsigned nbits) {
        this->nBits(nbits);
        return *this;
    }
};
class RegisterDescriptor {…};
 
} // namespace
} // namespace
 
#endif
#endif