AbstractLocation.h

#ifndef Rose_BinaryAnalysis_AbstractLocation_H
#define Rose_BinaryAnalysis_AbstractLocation_H
#include <featureTests.h>
#ifdef ROSE_ENABLE_BINARY_ANALYSIS

#include <Rose/BinaryAnalysis/InstructionSemantics2/BaseSemantics.h>

namespace Rose {
namespace BinaryAnalysis {

class AbstractLocation {
public:
    typedef InstructionSemantics2::BaseSemantics::SValuePtr Address; 
private:
    RegisterDescriptor reg_;
    Address addr_;
    size_t nBytes_;                                     // size of memory location, or zero if unknown
    const RegisterDictionary *regdict_;

public:
    AbstractLocation(): nBytes_(0), regdict_(NULL) {}

    AbstractLocation(const AbstractLocation &other)
        : reg_(other.reg_), addr_(other.addr_), nBytes_(other.nBytes_), regdict_(other.regdict_) {}

    explicit AbstractLocation(RegisterDescriptor reg, const RegisterDictionary *regdict=NULL)
        : reg_(reg), nBytes_(0), regdict_(regdict) {}

    explicit AbstractLocation(const Address &addr, size_t nBytes=0): addr_(addr), nBytes_(nBytes), regdict_(NULL) {}

    AbstractLocation& operator=(const AbstractLocation &other) {
        reg_ = other.reg_;
        addr_ = other.addr_;
        nBytes_ = other.nBytes_;
        regdict_ = other.regdict_;
        return *this;
    }

    bool isValid() const { return isRegister() || isAddress(); }

    bool isRegister() const { return !reg_.isEmpty(); }

    bool isAddress() const { return addr_!=NULL; }

    RegisterDescriptor getRegister() const { return reg_; }

    const Address getAddress() const { return addr_; }

    size_t nBytes() const { ASSERT_require(isAddress()); return nBytes_; }

    bool mayAlias(const AbstractLocation &other, const SmtSolverPtr &solver = SmtSolverPtr()) const;

    bool mustAlias(const AbstractLocation &other, const SmtSolverPtr &solver = SmtSolverPtr()) const;

    void print(std::ostream &out, const RegisterDictionary *regdict=NULL) const {
        InstructionSemantics2::BaseSemantics::Formatter fmt;
        print(out, regdict, fmt);
    }
    void print(std::ostream &out, InstructionSemantics2::BaseSemantics::Formatter &fmt) const {
        print(out, NULL, fmt);
    }
    void print(std::ostream &out, const RegisterDictionary *regdict, InstructionSemantics2::BaseSemantics::Formatter &fmt) const;
};

std::ostream& operator<<(std::ostream&, const AbstractLocation&);

} // namespace
} // namespace

#endif
#endif