GlobalVariable.h

#ifndef ROSE_BinaryAnalysis_Variables_GlobalVariable_H
#define ROSE_BinaryAnalysis_Variables_GlobalVariable_H
#include <featureTests.h>
#ifdef ROSE_ENABLE_BINARY_ANALYSIS
 
#include <Rose/BinaryAnalysis/AddressInterval.h>
#include <Rose/BinaryAnalysis/Partitioner2/BasicTypes.h>
#include <Rose/BinaryAnalysis/Variables/BaseVariable.h>
 
#include <Sawyer/IntervalMap.h>
 
namespace Rose {
namespace BinaryAnalysis {
namespace Variables {
 
class GlobalVariable: public BaseVariable {
    Address address_ = 0;                               // starting (lowest) virtual address
 
#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_NVP(BaseVariable);
        s & BOOST_SERIALIZATION_NVP(address_);
    }
#endif
 
public:
    GlobalVariable();
 
    GlobalVariable(Address startingAddress, rose_addr_t maxSizeBytes,
                   const std::vector<InstructionAccess> &definingInstructions = std::vector<InstructionAccess>(),
                   const std::string &name = "");
 
    ~GlobalVariable();
 
    Address address() const;
    void address(Address va);
    const std::string& setDefaultName();
 
    bool operator==(const GlobalVariable &other) const;
    bool operator!=(const GlobalVariable &other) const;
    AddressInterval interval() const;
 
    void print(std::ostream&) const;
    std::string toString() const;
    explicit operator bool() const {
        return !interval().isEmpty();
    }
 
    bool operator!() const {
        return interval().isEmpty();
    }
 
    friend std::ostream& operator<<(std::ostream&, const Rose::BinaryAnalysis::Variables::GlobalVariable&);
};
 
using GlobalVariables = Sawyer::Container::IntervalMap<AddressInterval, GlobalVariable>;
 
void erase(GlobalVariables&, const AddressInterval &toErase);
 
void print(const GlobalVariables&,const Partitioner2::PartitionerConstPtr&, std::ostream &out, const std::string &prefix = "");
 
AddressInterval isInconsistent(const GlobalVariables&, Sawyer::Message::Stream&);
 
} // namespace
} // namespace
} // namespace
 
#endif
#endif