BaseVariable.h

#ifndef ROSE_BinaryAnalysis_Variables_BaseVariable_H
#define ROSE_BinaryAnalysis_Variables_BaseVariable_H
#include <featureTests.h>
#ifdef ROSE_ENABLE_BINARY_ANALYSIS
 
#include <Rose/BinaryAnalysis/InstructionSemantics/BaseSemantics/BasicTypes.h>
#include <Rose/BinaryAnalysis/Variables/InstructionAccess.h>
 
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
#include <boost/serialization/access.hpp>
#endif
 
namespace Rose {
namespace BinaryAnalysis {
namespace Variables {
 
class BaseVariable {
private:
    Address maxSizeBytes_ = 0;                      // maximum possible size of this variable in bytes
    std::vector<InstructionAccess> insns_;              // instructions accessing the variable
    std::string name_;                                  // optional variable name
 
#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(maxSizeBytes_);
        s & BOOST_SERIALIZATION_NVP(insns_);
        s & BOOST_SERIALIZATION_NVP(name_);
    }
#endif
 
protected:
    BaseVariable();
 
    BaseVariable(size_t maxSizeBytes, const std::vector<InstructionAccess> &definingInstructions, const std::string &name);
 
public:
    BaseVariable(const BaseVariable&);
    BaseVariable& operator=(const BaseVariable&);
    ~BaseVariable();
 
public:
    Address maxSizeBytes() const;
    void maxSizeBytes(Address size);
    const std::vector<InstructionAccess>& instructionsAccessing() const;
    void instructionsAccessing(const std::vector<InstructionAccess>&);
    AccessFlags accessFlags() const;
 
    InstructionSemantics::BaseSemantics::InputOutputPropertySet ioProperties() const;
 
    const std::string& name() const;
    void name(const std::string &s);
    void insertAccess(Address insnAddr, AccessFlags);
};
 
} // namespace
} // namespace
} // namespace
 
#endif
#endif