DataBlock.h

#ifndef ROSE_BinaryAnalysis_Partitioner2_DataBlock_H
#define ROSE_BinaryAnalysis_Partitioner2_DataBlock_H
#include <featureTests.h>
#ifdef ROSE_ENABLE_BINARY_ANALYSIS
#include <Rose/BinaryAnalysis/Partitioner2/BasicTypes.h>
 
#include <Rose/BinaryAnalysis/BasicTypes.h>
#include <Rose/SourceLocation.h>
#include <SageBuilderAsm.h>
 
#include <Sawyer/Attribute.h>
#include <Sawyer/SharedPointer.h>
 
#ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
#include <boost/serialization/access.hpp>
#endif
 
#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&, unsigned version);
#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;
    void sourceLocation(const SourceLocation&);
    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 MemoryMapPtr&) 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