DataBlock.h

#ifndef ROSE_Partitioner2_DataBlock_H
#define ROSE_Partitioner2_DataBlock_H

#include <featureTests.h>
#ifdef ROSE_ENABLE_BINARY_ANALYSIS

#include <Partitioner2/BasicTypes.h>
#include <SageBuilderAsm.h>
#include <SourceLocation.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
    std::string comment_;                               // arbitrary comment, shown by printableName.
    std::vector<BasicBlockPtr> attachedBasicBlockOwners_; // attached basic blocks that own this data block, sorted and unique
    std::vector<FunctionPtr> attachedFunctionOwners_;   // attached functions that own this data block, sorted and unique
    SourceLocation sourceLocation_;                     // optional location of data in source code
    

#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());
        }
        if (version < 2) {
            ASSERT_not_reachable("Rose::BinaryAnalysis::Partitioner2::DataBlock version 2 is no longer supported");
        } else {
            s & BOOST_SERIALIZATION_NVP(attachedBasicBlockOwners_);
            s & BOOST_SERIALIZATION_NVP(attachedFunctionOwners_);
        }
        if (version >= 3)
            s & BOOST_SERIALIZATION_NVP(sourceLocation_);
    }
#endif
    
protected:
    // needed for serialization
    DataBlock();
    DataBlock(rose_addr_t startVa, SgAsmType *type);

public:
    ~DataBlock();

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;
    void comment(const std::string& s);
    const SourceLocation& sourceLocation() const { return sourceLocation_; }
    void sourceLocation(const SourceLocation &loc) { sourceLocation_ = loc; }
    size_t nAttachedOwners() const;

    const std::vector<FunctionPtr>& attachedFunctionOwners() const;

    const std::vector<BasicBlockPtr>& attachedBasicBlockOwners() const;    
    AddressInterval extent() const;

    std::string printableName() const;

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

private:
    friend class Partitioner;
    void freeze();
    void thaw();

    // Insert the specified owner into this data block.
    void insertOwner(const BasicBlockPtr&);
    void insertOwner(const FunctionPtr&);

    // Erase the specified owner of this data block.
    void eraseOwner(const BasicBlockPtr&);
    void eraseOwner(const FunctionPtr&);
};


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

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

#endif
#endif