Register.hpp

// <Register> -*- C++ -*-
 
#pragma once
 
#include <iostream>
#include <ios>
#include <iomanip>
#include <sstream>
#include <math.h>
#include <memory>
#include <climits>
#include <cassert>
 
#include "sparta/simulation/TreeNode.hpp"
#include "sparta/functional/DataView.hpp"
#include "sparta/functional/RegisterBits.hpp"
#include "sparta/utils/Utils.hpp"
#include "sparta/log/NotificationSource.hpp"
#include "sparta/utils/SpartaException.hpp"
#include "sparta/utils/SpartaAssert.hpp"
#include "sparta/utils/StringUtils.hpp"
#include "sparta/utils/ValidValue.hpp"
 
namespace sparta
{
 
class RegisterBase : public TreeNode
{
 
public:
    class Field;
 
    typedef DataView::ident_type ident_type;
 
    typedef DataView::index_type index_type;
 
    typedef DataView::offset_type size_type;
 
    typedef uint32_t group_num_type;
 
    typedef TreeNode::group_idx_type group_idx_type;
 
    typedef uint32_t bank_idx_type;
 
    typedef std::vector<const char*> AliasVector;
 
    typedef std::vector<Field*> FieldVector;
 
    typedef std::function<sparta::utils::ValidValue<uint64_t>(RegisterBase*)> register_read_callback_type;
 
    typedef std::function<bool(RegisterBase*, uint64_t)> register_write_callback_type;
 
 
    static constexpr bank_idx_type BANK_IDX_DEFAULT = 0;
 
    class Field : public TreeNode
    {
        RegisterBits computeFieldMask_(uint32_t start, uint32_t end, uint32_t reg_size)
        {
            const auto num_ones = start - end + 1;
            RegisterBits mask(reg_size);
            // For 31-0:
 
            // max() & (max() >> ((8 * 8) - 31))
            const uint64_t masked_bits = std::numeric_limits<uint64_t>::max() &
                (std::numeric_limits<uint64_t>::max() >> ((sizeof(uint64_t) * CHAR_BIT) - num_ones));
            mask.set(masked_bits);
            mask <<= end;
            return mask;
        }
 
    public:
 
        typedef uint64_t access_type;
 
        static const size_type MAX_FIELD_BITS = sizeof(access_type) * 8;
 
        struct Definition
        {
            Definition() = delete;
 
            Definition(const char* _name,
                       const char* _desc,
                       size_type _low_bit,
                       size_type _high_bit) :
                name(_name),
                desc(_desc),
                low_bit(_low_bit),
                high_bit(_high_bit),
                read_only(false)
            {;}
            Definition(const char* _name, {…}
 
            Definition(const char* _name,
                       const char* _desc,
                       size_type _low_bit,
                       size_type _high_bit,
                       bool _read_only) :
                name(_name),
                desc(_desc),
                low_bit(_low_bit),
                high_bit(_high_bit),
                read_only(_read_only)
            {;}
 
            const char* name;   
            const char* desc;   
            size_type low_bit;  
            size_type high_bit; 
            bool read_only;     
        };
        struct Definition {…};
 
        Field(RegisterBase &reg, const Definition &def) :
            TreeNode(NULL_TO_EMPTY_STR(def.name), TreeNode::GROUP_NAME_NONE,
                     TreeNode::GROUP_IDX_NONE, NULL_TO_EMPTY_STR(def.desc)),
            reg_(reg),
            def_(def),
            reg_size_(reg_.getNumBytes()),
            field_mask_(computeFieldMask_(def.high_bit, def.low_bit, reg_.getNumBytes())),
            not_field_mask_(~field_mask_)
        {
            setExpectedParent_(&reg);
 
            sparta_assert(def_.name != 0, "Register::Field::Definition::name cannot be empty");
 
            if(def_.high_bit < def_.low_bit){
                throw SpartaException("Register Field ")
                    << getLocation() << " definition contains high bit (" << def_.high_bit
                    << ") less than a low bit (" << def_.low_bit << ")";
            }
 
            if(def_.low_bit >= reg.getNumBits()){
                throw SpartaException("Register Field ")
                    << getLocation() << " definition contains a low bit (" << def_.low_bit
                    << ") greater than or equal to the number of bits in the register ("
                    << reg.getNumBits() << ")";
            }
            if(def_.high_bit >= reg.getNumBits()){
                throw SpartaException("Register Field ")
                    << getLocation() << " definition contains a high bit (" << def_.high_bit
                    << ") greater than or equal to the number of bits in the register ("
                    << reg.getNumBits() << ")";
            }
 
            if(getNumBits() > MAX_FIELD_BITS){
                throw SpartaException("Cannot currently support more than ")
                    << (size_type)MAX_FIELD_BITS << "bit-wide fields. "
                    << "Problem with field \"" << getLocation() << "\"";
            }
 
            // Add self as child after successful initialization
            reg.addChild(this);
        }
        Field(RegisterBase &reg, const Definition &def) : {…}
 
 
        access_type read()
        {
            return ((readBitArray_() & field_mask_) >> getLowBit()).dataAs<access_type>();
        }
        access_type read() {…}
 
        access_type peek() const
        {
            return ((peekBitArray_() & field_mask_) >> getLowBit()).dataAs<access_type>();
        }
        access_type peek() const {…}
 
        void write(access_type t)
        {
            write_(newRegisterValue_(t));
        }
        void write(access_type t) {…}
 
        void poke(access_type t)
        {
            poke_(newRegisterValue_(t));
        }
        void poke(access_type t) {…}
 
        void pokeUnmasked(access_type t)
        {
            pokeUnmasked_(newRegisterValue_(t));
        }
        void pokeUnmasked(access_type t) {…}
 
 
 
        size_type getLowBit() const { return def_.low_bit; }
 
        size_type getHighBit() const { return def_.high_bit; }
 
        bool isReadOnly() const { return def_.read_only; }
 
        size_type getNumBits() const
        {
            return getHighBit() - getLowBit() + 1;
        }
        size_type getNumBits() const {…}
 
        const Definition& getDefinition() const {
            return def_;
        }
        const Definition& getDefinition() const  {…}
 
 
        // Override from TreeNode
        virtual std::string stringize(bool pretty=false) const override{
            (void) pretty;
            std::stringstream ss;
            ss << '<' << getLocation() << " [" << def_.low_bit << "-"
               << def_.high_bit << "] " << getNumBits();
            ss << " bits LE:0x" << std::hex << peek();
            if(def_.read_only){
                ss << " READ-ONLY";
            }
            ss << '>';
            return ss.str();
        }
        virtual std::string stringize(bool pretty=false) const override {…}
 
    private:
        RegisterBits readBitArray_() const
        {
            RegisterBits reg_bits(reg_size_);
            reg_.read(reg_bits.data(), reg_size_, 0);
            return reg_bits;
        }
 
        RegisterBits peekBitArray_() const
        {
            RegisterBits reg_bits(reg_size_);
            reg_.peek(reg_bits.data(), reg_size_, 0);
            return reg_bits;
        }
 
        void write_(const RegisterBits &value)
        {
            reg_.write(value.data(), value.getSize(), 0);
        }
 
        void poke_(const RegisterBits &value)
        {
            reg_.poke(value.data(), value.getSize(), 0);
        }
 
        void pokeUnmasked_(const RegisterBits &value)
        {
            reg_.pokeUnmasked(value.data(), value.getSize(), 0);
        }
 
        RegisterBits newRegisterValue_(access_type value) const
        {
            const auto old_register_value  = peekBitArray_();
 
            RegisterBits field_value_to_be_written_shifted(std::max((size_t)reg_size_, sizeof(access_type)), value);
            field_value_to_be_written_shifted <<= getLowBit();
 
            // Check to see if the number of bits being written to the
            // field is larger than the field itself.
            sparta_assert((field_value_to_be_written_shifted & not_field_mask_).none(),
                          "Value of " << value <<  " too large for bit field "
                          << getLocation() << " of size " << getNumBits());
 
            return (old_register_value & not_field_mask_) | field_value_to_be_written_shifted;
        }
 
        RegisterBase &reg_;
 
        const Definition &def_;
 
        const RegisterBase::size_type reg_size_ = 0;
 
        const RegisterBits field_mask_;
 
        const RegisterBits not_field_mask_;
 
    }; // class Field
    class Field : public TreeNode {…};
 
    struct ReadAccess
    {
        ReadAccess() = delete;
 
        ReadAccess(const RegisterBase *_reg, const DataView *_value_dview)
        : reg(_reg), value(_value_dview)
        {
        }
 
        const RegisterBase *const reg;
 
        const DataView *const value;
    };
    struct ReadAccess {…};
 
    typedef NotificationSource<ReadAccess> ReadNotiSrc;
 
    struct PostWriteAccess
    {
        PostWriteAccess() = delete;
 
        PostWriteAccess(const RegisterBase *_reg,
                        const DataView *_prior_dview,
                        const DataView *_final_dview)
        : reg(_reg), prior(_prior_dview), final(_final_dview)
        {
        }
 
        const RegisterBase *const reg;
 
        const DataView *const prior;
 
        const DataView *const final;
    };
    struct PostWriteAccess {…};
 
    typedef NotificationSource<PostWriteAccess> PostWriteNotiSrc;
 
    struct Definition
    {
        const ident_type id;
 
        const char*              name;
 
        const group_num_type     group_num;
 
        const char*              group;
 
        const group_idx_type     group_idx;
 
        const char*              desc;
 
        const size_type          bytes;
 
        const std::vector<Field::Definition> fields;
 
        const std::vector<bank_idx_type> bank_membership;
 
        const char**             aliases;
 
        const ident_type         subset_of;
 
        const size_type          subset_offset;
 
        const unsigned char*     initial_value;
 
        typedef uint16_t         HintsT;
        const HintsT             hints;
 
        typedef uint16_t         RegDomainT;
        const RegDomainT         regdomain;
 
        const bool               writable = true;
    };
    struct Definition {…};
 
    static constexpr ident_type INVALID_ID = DataView::INVALID_ID;
 
    static constexpr group_num_type GROUP_NUM_NONE = ~(group_num_type)0;
 
    static const Definition DEFINITION_END;
 
    friend class Field;
 
 
    RegisterBase(TreeNode *parent, const Definition & def)
        : TreeNode(nullptr,
                   NULL_TO_EMPTY_STR(def.name),
                   NULL_TO_EMPTY_STR(def.group),
                   def.group_idx,
                   NULL_TO_EMPTY_STR(def.desc),
                   false),
          def_(def),
          bits_(def.bytes * 8),
          mask_(computeWriteMask_(&def_)),
          post_write_noti_(this,
                           "post_write",
                           "Notification immediately after the register has been written",
                           "post_write"),
          post_read_noti_(this,
                          "post_read",
                          "Notification immediately after the register has been read",
                          "post_read")
    {
        if(parent != nullptr){
            setExpectedParent_(parent);
        }
 
        sparta_assert(def.name != 0, "Cannot have a null name in a register definition");
 
        if(!strcmp(def_.group, GROUP_NAME_NONE) && (def.group_num != GROUP_NUM_NONE)){
            throw SpartaException("Attempted to add register \"")
                << getLocation() << "\" which had group number " << def.group_num
                << " but had group name \"\". A group name is required if a group number is specified.";
        }
 
        if(strcmp(def.group, GROUP_NAME_NONE) && (def.group_num == GROUP_NUM_NONE)){
            throw SpartaException("Attempted to add register \"")
                << getLocation() << "\" which had group number GROUP_NUM_NONE"
                << " but had group name \"" << def.group
                << "\". A group number is required if a group name is specified.\"" << GROUP_NAME_NONE << "\"";
        }
 
        // Ensure byte-size is valid
        static_assert(std::is_unsigned<decltype(def.bytes)>::value == true);
        if(!isPowerOf2(def.bytes) || def.bytes == 0){
            throw SpartaException("Register \"")
                << getName() << "\" size in bytes must be a power of 2 larger than 0, is "
                << def.bytes;
        }
 
        // Add all fields
        for(auto & fdp : def_.fields){
            addField(fdp);
        }
 
        // Add all aliases
        const char* const * ap = def_.aliases;
        if(ap != 0){
            while(*ap != 0){
                addAlias(*ap); // From sparta::TreeNode
                ++ap;
            }
        }
 
        // Must add child only after assigning all aliases
        if(parent != nullptr){
            parent->addChild(this);
        }
    }
    RegisterBase(TreeNode *parent, const Definition & def) {…}
 
    virtual ~RegisterBase()
    {
        for(Field* f : owned_fields_){
            delete f;
        }
    }
    virtual ~RegisterBase() {…}
 
    void reset(bool unmasked=true) {
        // Poke the whole value, one-byte at a time
        for(size_type i=0; i<def_.bytes; i++){
            if(unmasked){
                pokeUnmasked(def_.initial_value[i], i);
            }else{
                poke(def_.initial_value[i], i);
            }
        }
    }
    void reset(bool unmasked=true) {…}
 
    Field* addField(const Field::Definition & fd) {
        sparta_assert(!isBuilt());
        owned_fields_.push_back(new Field(*this, fd));
        return owned_fields_.back();
    }
    Field* addField(const Field::Definition & fd) {…}
 
 
 
    ident_type getID() const { return def_.id; }
 
    group_num_type getGroupNum() const { return def_.group_num; }
 
    std::string getGroupName() const {
        // Return group. Guaranteed not to be null by Register::Register
        return def_.group;
    }
    std::string getGroupName() const  {…}
 
    group_idx_type getGroupIdx() const { return def_.group_idx; }
 
    size_type getNumBytes() const { return def_.bytes; }
 
    size_type getNumBits() const { return bits_; }
 
    size_type getNumFields() const { return (size_type)fields_.size(); }
 
    bool isInBank(bank_idx_type bank) const {
        if(isBanked() == false){
            return true;
        }
 
        auto itr = std::find(def_.bank_membership.begin(), def_.bank_membership.end(), bank);
        return itr != def_.bank_membership.end();
    }
    bool isInBank(bank_idx_type bank) const  {…}
 
    bool isBanked() const {
        return def_.bank_membership.size() != 0;
    }
    bool isBanked() const  {…}
 
    FieldVector& getFields() { return fields_; }
 
    const FieldVector& getFields() const { return fields_; }
 
    ident_type getSubsetOf() const { return def_.subset_of; }
 
    size_type getSubsetOffset() const { return def_.subset_offset; }
 
    Definition::HintsT getHintFlags() const { return def_.hints; }
 
    Definition::RegDomainT getRegDomain() const { return def_.regdomain; }
 
    const Definition& getDefinition() const {
        return def_;
    }
    const Definition& getDefinition() const  {…}
 
 
 
    template <typename T>
    T read(index_type idx=0)
    {
        T tmp;
        read(&tmp, sizeof(tmp), idx * sizeof(tmp));
        return tmp;
    }
    T read(index_type idx=0) {…}
 
    sparta::utils::ValidValue<uint64_t> readWithCheck()
    {
        if (hasReadCB()) {
            return read_with_check_cb_(this);
        } else if (getNumBytes()==4) {
            return read<uint32_t>();
        }
 
        sparta_assert(getNumBytes()==8,
                    "read callback only support for 4- and 8-byte registers");
        return read<uint64_t>();
    }
    sparta::utils::ValidValue<uint64_t> readWithCheck() {…}
 
    template <typename T>
    void write(T val, index_type idx=0)
    {
        assert(isWritable());
        write(&val, sizeof(val), idx * sizeof(val));
    }
    void write(T val, index_type idx=0) {…}
 
    template <typename T>
    bool writeWithCheck(T val)
    {
        assert(isWritable());
        if (hasWriteCB()) {
            static_assert((sizeof(T)==4) || (sizeof(T)==8),
                          "write callback only support for 4- and 8-byte registers");
            return write_with_check_cb_(this, val);
        }
        write<T>(val);
        return true;
    }
    bool writeWithCheck(T val) {…}
 
    template <typename T>
    void writeUnmasked(T val, index_type idx=0)
    {
        assert(isWritable());
        writeUnmasked(&val, sizeof(val), idx * sizeof(val));
    }
    void writeUnmasked(T val, index_type idx=0) {…}
 
    template <typename T>
    T peek(index_type idx=0) const
    {
        T tmp;
        peek(&tmp, sizeof(tmp), idx * sizeof(tmp));
        return tmp;
    }
 
    template <typename T>
    void poke(T val, index_type idx=0)
    {
        assert(isWritable());
        poke(&val, sizeof(val), idx * sizeof(val));
    }
    void poke(T val, index_type idx=0) {…}
 
    template <typename T>
    void pokeUnmasked(T val, index_type idx=0)
    {
        assert(isWritable());
        pokeUnmasked(&val, sizeof(val), idx * sizeof(val));
    }
    void pokeUnmasked(T val, index_type idx=0) {…}
 
    template <typename T>
    T dmiRead(index_type idx = 0) const
    {
        T res;
        dmiRead_(&res, sizeof(res), sizeof(res) * idx);
        return res;
    }
    T dmiRead(index_type idx = 0) const {…}
 
    template <typename T>
    void dmiWrite(T val, index_type idx = 0)
    {
        assert(isWritable());
        dmiWrite_(&val, sizeof(val), sizeof(val) * idx);
    }
    void dmiWrite(T val, index_type idx = 0) {…}
 
    template <typename T>
    T getWriteMask(index_type idx=0) const
    {
        sparta_assert((idx + 1) * sizeof(T) <= mask_.getSize());
        return *(reinterpret_cast<const T*>(mask_.data()) + idx);
    }
    T getWriteMask(index_type idx=0) const {…}
 
    bool isWritable() const
    {
        return def_.writable;
    }
 
 
 
    std::string getValueAsByteString() const
    {
        const auto size = getNumBytes();
        std::vector<uint8_t> value(size);
        peek(value.data(), size, 0);
        return utils::bin_to_hexstr(value.data(), size);
    }
    std::string getValueAsByteString() const {…}
 
    std::string getWriteMaskAsByteString() const
    {
        return utils::bin_to_hexstr(
            reinterpret_cast<const uint8_t *>(mask_.data()), mask_.getSize());
    }
    std::string getWriteMaskAsByteString() const {…}
 
    std::string getWriteMaskAsBitString() const
    {
        return utils::bin_to_bitstr(
            reinterpret_cast<const uint8_t *>(mask_.data()), mask_.getSize());
    }
    std::string getWriteMaskAsBitString() const {…}
 
 
    Field *getField(const std::string &name)
    {
        return getChildAs<Field *>(name);
    }
    Field *getField(const std::string &name) {…}
 
    const Field *getField(const std::string &name) const
    {
        return getChildAs<Field *>(name);
    }
    const Field *getField(const std::string &name) const {…}
 
 
    void read(void *buf, size_t size, size_t offset)
    {
        sparta_assert(offset + size <= getNumBytes(), "Access out of bounds");
        read_(buf, size, offset);
    }
 
    void peek(void *buf, size_t size, size_t offset) const
    {
        sparta_assert(offset + size <= getNumBytes(), "Access out of bounds");
        peek_(buf, size, offset);
    }
 
    void write(const void *buf, size_t size, size_t offset)
    {
        assert(isWritable());
        sparta_assert(offset + size <= getNumBytes(), "Access out of bounds");
        RegisterBits val(reinterpret_cast<const uint8_t *>(buf), size);
        RegisterBits mask = mask_ >> 8 * offset;
        RegisterBits old = (peekRegisterBits_(size, offset) & ~mask) | (val & mask);
        write_(old.data(), size, offset);
    }
 
    void writeUnmasked(const void *buf, size_t size, size_t offset)
    {
        assert(isWritable());
        sparta_assert(offset + size <= getNumBytes(), "Access out of bounds");
        write_(buf, size, offset);
    }
 
    void poke(const void *buf, size_t size, size_t offset)
    {
        assert(isWritable());
        sparta_assert(offset + size <= getNumBytes(), "Access out of bounds");
        RegisterBits val(reinterpret_cast<const uint8_t *>(buf), size);
        RegisterBits mask = mask_ >> 8 * offset;
        RegisterBits old = (peekRegisterBits_(size, offset) & ~mask) | (val & mask);
        poke_(old.data(), size, offset);
    }
 
    void pokeUnmasked(const void *buf, size_t size, size_t offset)
    {
        assert(isWritable());
        sparta_assert(offset + size <= getNumBytes(), "Access out of bounds");
        poke_(buf, size, offset);
    }
 
 
    PostWriteNotiSrc &getPostWriteNotificationSource()
    {
        return post_write_noti_;
    }
    PostWriteNotiSrc &getPostWriteNotificationSource() {…}
 
    ReadNotiSrc &getReadNotificationSource()
    {
        return post_read_noti_;
    }
    ReadNotiSrc &getReadNotificationSource() {…}
 
    void addReadCB(register_read_callback_type callback)
    {
        read_with_check_cb_ = callback;
    }
    void addReadCB(register_read_callback_type callback) {…}
 
    bool hasReadCB() const
    {
        return read_with_check_cb_ != nullptr;
    }
    bool hasReadCB() const {…}
 
    void addWriteCB(register_write_callback_type callback)
    {
        write_with_check_cb_ = callback;
    }
    void addWriteCB(register_write_callback_type callback) {…}
 
    bool hasWriteCB() const
    {
        return write_with_check_cb_ != nullptr;
    }
    bool hasWriteCB() const {…}
 
protected:
 
    virtual void onAddingChild_(TreeNode* child) override {
        Field* fld = dynamic_cast<Field*>(child);
        if(nullptr != fld){
            // Add Field to fields_ list for tracking.
            fields_.push_back(fld);
        }
    }
    virtual void onAddingChild_(TreeNode* child) override  {…}
 
    virtual void read_(void *buf, size_t size, size_t offset = 0) = 0;
 
    virtual void peek_(void *buf, size_t size, size_t offset = 0) const = 0;
 
    virtual void write_(const void *buf, size_t size, size_t offset = 0) = 0;
 
    virtual void poke_(const void *buf, size_t size, size_t offset = 0) = 0;
 
    virtual void dmiRead_(void *buf, size_t size, size_t offset = 0) const
    {
        (void)buf; (void)size; (void)offset;
        sparta_assert(!"Register DMI not supported");
    }
 
    virtual void dmiWrite_(const void *buf, size_t size, size_t offset = 0)
    {
        (void)buf; (void)size; (void)offset;
        sparta_assert(!"Register DMI not supported");
    }
 
private:
    RegisterBits computeWriteMask_(const Definition *def) const
    {
        if(!isPowerOf2(def->bytes)) {
            throw SpartaException("Register \"")
                << getName() << "\" size in bytes must be a power of 2 larger than 0, is "
                << def->bytes;
        }
 
        const auto mask_size = def->bytes;
        RegisterBits write_mask(mask_size);
        RegisterBits partial_mask(mask_size);
        partial_mask.fill(0xff);
 
        for (auto &fdp : def->fields) {
            if (fdp.read_only) {
                const uint64_t field_size = fdp.high_bit - fdp.low_bit + 1;
                const uint64_t shift_down = 8 * mask_size - field_size;
                const uint64_t shift_up = fdp.low_bit;
 
                write_mask |= ((partial_mask >> shift_down) << shift_up);
            }
        }
 
        return ~write_mask;
    }
 
    RegisterBits peekRegisterBits_(size_t size, size_t offset=0) const
    {
        RegisterBits bits(size);
        peek_(bits.data(), size, offset);
        return bits;
    }
 
    const Definition def_;
 
    FieldVector owned_fields_;
 
    FieldVector fields_;
 
    const size_type bits_;
 
    const RegisterBits mask_;
 
    PostWriteNotiSrc post_write_noti_;
 
    ReadNotiSrc post_read_noti_;
 
    register_read_callback_type read_with_check_cb_ {nullptr};
    register_write_callback_type write_with_check_cb_ {nullptr};
}; // class RegisterBase
class RegisterBase : public TreeNode {…};
 
inline bool operator==(const RegisterBase::Definition &a,
                       const RegisterBase::Definition &b)
{
    if (a.id != b.id) {
        return false;
    }
    if (!utils::strcmp_with_null(a.name, b.name)) {
        return false;
    }
    if (a.group_num != b.group_num) {
        return false;
    }
    if (!utils::strcmp_with_null(a.group, b.group)) {
        return false;
    }
    if (a.group_idx != b.group_idx) {
        return false;
    }
    if (!utils::strcmp_with_null(a.desc, b.desc)) {
        return false;
    }
    if (a.bytes != b.bytes) {
        return false;
    }
 
    /* TODO: Compare fields. This require a == operator for Field::Definition */
 
    if (a.bank_membership != b.bank_membership) {
        return false;
    }
 
    auto a_aliases = a.aliases;
    auto b_aliases = b.aliases;
    if (a_aliases != nullptr && b_aliases != nullptr) {
        for (; *a_aliases != 0 || *b_aliases != 0; ++a_aliases, ++b_aliases) {
            if (!utils::strcmp_with_null(*a_aliases, *b_aliases)) {
                return false;
            }
        }
    } else if (!(a_aliases == nullptr && b_aliases == nullptr)) {
        return false;
    }
 
    if (a.subset_of != b.subset_of) {
        return false;
    }
    if (!utils::strcmp_with_null((const char *)a.initial_value, (const char *)b.initial_value)) {
        return false;
    }
    if (a.hints != b.hints) {
        return false;
    }
    if (a.regdomain != b.regdomain) {
        return false;
    }
 
    return true;
}
 
inline bool operator!=(const RegisterBase::Definition &a,
                       const RegisterBase::Definition &b)
{
    return !(a == b);
}
 
class Register : public RegisterBase
{
public:
    Register(TreeNode *parent, const Definition def, ArchData *adata) :
        RegisterBase(parent, def),
        dview_(adata, def.id, def.bytes, def.subset_of, def.subset_offset, def.initial_value),
        prior_val_dview_(adata, DataView::INVALID_ID, def.bytes),
        post_write_noti_data_(this, &prior_val_dview_, &dview_),
        post_read_noti_data_(this, &dview_)
    {
    }
 
    // Override from TreeNode
    std::string stringize(bool pretty = false) const override
    {
        (void)pretty;
        std::stringstream ss;
        ss << '<' << getLocation() << " " << getNumBits() << " bits ";
        if (dview_.isPlaced()) {
            ss << getValueAsByteString();
        } else {
            ss << DataView::DATAVIEW_UNPLACED_STR;
        }
        ss << '>';
        return ss.str();
    }
    std::string stringize(bool pretty = false) const override {…}
 
    typedef RegisterBase::index_type index_type;
 
    template <typename T>
    inline T dmiRead(index_type idx = 0) const
    {
        T res;
        dmiReadImpl_(&res, sizeof(res), sizeof(res) * idx);
        return res;
    }
    inline T dmiRead(index_type idx = 0) const {…}
 
    template <typename T>
    inline void dmiWrite(T val, index_type idx = 0)
    {
        assert(isWritable());
        dmiWriteImpl_(&val, sizeof(val), sizeof(val) * idx);
    }
    inline void dmiWrite(T val, index_type idx = 0) {…}
 
    template <typename T>
    inline void writeUnmasked(T val, index_type idx = 0)
    {
        assert(isWritable());
        dmiWriteImpl_(&val, sizeof(T), idx);
    }
    inline void writeUnmasked(T val, index_type idx = 0) {…}
 
private:
    void onBindTreeEarly_() override
    {
        /* Arch data must laid out before we can get pointer into it */
        sparta_assert(dview_.getArchData()->isLaidOut());
        raw_data_ptr_ = dview_.getLine()->getRawDataPtr(dview_.getOffset());
    }
 
    void read_(void *buf, size_t size, size_t offset=0) override final
    {
        auto &post_read_noti = getReadNotificationSource();
 
        peek_(buf, size, offset);
        if (SPARTA_EXPECT_FALSE(post_read_noti.observed())) {
            post_read_noti.postNotification(post_read_noti_data_);
        }
    }
 
    void peek_(void *buf, size_t size, size_t offset=0) const override final
    {
        dview_.getLine()->read(
            dview_.getOffset() + offset, size, static_cast<uint8_t *>(buf));
    }
 
    void dmiRead_(void *buf, size_t size, size_t offset = 0) const override final
    {
        dmiReadImpl_(buf, size, offset);
    }
 
    void write_(const void *buf, size_t size, size_t offset=0) override final
    {
        assert(isWritable());
        auto &post_write_noti = getPostWriteNotificationSource();
 
        if (SPARTA_EXPECT_FALSE(post_write_noti.observed())) {
            prior_val_dview_ = dview_;
            poke_(buf, size, offset);
            post_write_noti.postNotification(post_write_noti_data_);
        } else {
            poke_(buf, size, offset);
        }
    }
 
    void poke_(const void *buf, size_t size, size_t offset=0) override final
    {
        assert(isWritable());
        dview_.getLine()->write(
            dview_.getOffset() + offset, size, static_cast<const uint8_t *>(buf));
    }
 
    void dmiWrite_(const void *buf, size_t size, size_t offset = 0) override final
    {
        assert(isWritable());
        dmiWriteImpl_(buf, size, offset);
    }
 
    inline void dmiReadImpl_(void *buf, size_t size, size_t offset = 0) const
    {
        memcpy(buf, raw_data_ptr_ + offset, size);
    }
 
    inline void dmiWriteImpl_(const void *buf, size_t size, size_t offset = 0)
    {
        assert(isWritable());
        memcpy(raw_data_ptr_ + offset, buf, size);
        dview_.getLine()->flagDirty();
    }
 
    DataView dview_;
 
    DataView prior_val_dview_;
 
    PostWriteNotiSrc::data_type post_write_noti_data_;
 
    ReadNotiSrc::data_type post_read_noti_data_;
 
    uint8_t *raw_data_ptr_ = nullptr;
};
class Register : public RegisterBase {…};
 
} // namespace sparta
 
 
inline std::ostream& operator<<(std::ostream& o, const sparta::Register& reg){
    o << reg.stringize();
    return o;
}
 
inline std::ostream& operator<<(std::ostream& o, const sparta::Register* reg){
    if(reg == 0){
        o << "null";
    }else{
        o << reg->stringize();
    }
    return o;
}
 
 
inline std::ostream& operator<<(std::ostream& o, const sparta::Register::Field& field){
    o << field.stringize();
    return o;
}
 
inline std::ostream& operator<<(std::ostream& o, const sparta::Register::Field* field){
    if(field == 0){
        o << "null";
    }else{
        o << field->stringize();
    }
    return o;
}
 
 
#define SPARTA_REGISTER_BODY                                              \
    const sparta::RegisterBase::Definition sparta::RegisterBase::DEFINITION_END{0, nullptr, 0, nullptr, 0, nullptr, 0, { }, { }, nullptr, 0, 0, 0, 0, 0};