DataBlock.h

#ifndef ROSE_Partitioner2_DataBlock_H
#define ROSE_Partitioner2_DataBlock_H

#include <Partitioner2/BasicTypes.h>
#include <SageBuilderAsm.h>

#include <boost/serialization/access.hpp>
#include <Sawyer/Attribute.h>
#include <Sawyer/SharedPointer.h>

#include <string>

namespace Rose {
namespace BinaryAnalysis {
namespace Partitioner2 {

class DataBlock: public Sawyer::SharedObject, public Sawyer::Attribute::Storage<> {
public:
    typedef Sawyer::SharedPointer<DataBlock> Ptr;

private:
    bool isFrozen_;                                     // true if object is read-only because it's in the CFG
    rose_addr_t startVa_;                               // starting address
    SgAsmType *type_;                                   // type of data stored in this block
    size_t nAttachedOwners_;                            // number of attached basic blocks and functions that own this data
    std::string comment_;

#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<Sawyer::Attribute::Storage>(*this); -- not serialized
        s & BOOST_SERIALIZATION_NVP(isFrozen_);
        s & BOOST_SERIALIZATION_NVP(startVa_);
        if (version >= 1) {
            s & BOOST_SERIALIZATION_NVP(type_);
            s & BOOST_SERIALIZATION_NVP(comment_);
        } else if (S::is_loading::value) {
            size_t nBytes = 0;
            s & boost::serialization::make_nvp("size_", nBytes);
            type_ = SageBuilderAsm::buildTypeVector(nBytes, SageBuilderAsm::buildTypeU8());
        }
        s & BOOST_SERIALIZATION_NVP(nAttachedOwners_);
    }
#endif
    
protected:
    // needed for serialization
    DataBlock()
        : isFrozen_(false), startVa_(0), type_(NULL), nAttachedOwners_(0) {}

    DataBlock(rose_addr_t startVa, SgAsmType *type)
        : isFrozen_(false), startVa_(startVa), type_(type), nAttachedOwners_(0) {}

public:
    static Ptr instance(rose_addr_t startVa, SgAsmType*);

    static Ptr instanceBytes(rose_addr_t startVa, size_t nBytes);

    bool isFrozen() const { return isFrozen_; }

    rose_addr_t address() const { return startVa_; }

    size_t size() const;

    SgAsmType* type() const { return type_; }
    void type(SgAsmType *t);
    const std::string& comment() const { return comment_; }
    void comment(const std::string& s) { comment_ = s; }
    size_t nAttachedOwners() const { return nAttachedOwners_; }

    AddressInterval extent() const;

    std::string printableName() const;

    std::vector<uint8_t> read(const MemoryMap::Ptr&) const;

private:
    friend class Partitioner;
    void freeze() { isFrozen_ = true; }
    void thaw() { isFrozen_ = false; }
    size_t incrementOwnerCount();
    size_t decrementOwnerCount();
    void nAttachedOwners(size_t);
};


} // namespace
} // namespace
} // namespace

// Class versions must be at global scope
BOOST_CLASS_VERSION(Rose::BinaryAnalysis::Partitioner2::DataBlock, 1);

#endif