AbstractLocation.h

#ifndef ROSE_BinaryAnalysis_AbstractLocation_H
#define ROSE_BinaryAnalysis_AbstractLocation_H
#include <featureTests.h>
#ifdef ROSE_ENABLE_BINARY_ANALYSIS
 
#include <Rose/Location.h>
#include <Rose/BinaryAnalysis/BasicTypes.h>
#include <Rose/BinaryAnalysis/SmtSolver.h>
 
#include <ostream>
#include <string>
 
namespace Rose {
namespace BinaryAnalysis {
 
class AbstractLocation: public Location {
public:
    using Address = InstructionSemantics::BaseSemantics::SValuePtr; 
private:
    RegisterDescriptor reg_;                            // empty for absolute addresses
    Address addr_;                                      // null for register locations
    size_t nBytes_ = 0;                                 // size of memory location, or zero if unknown
    RegisterDictionaryPtr regdict_;                     // not hashed or compared; only used to generate string output
 
public:
    AbstractLocation();
    virtual ~AbstractLocation();
 
    AbstractLocation(const AbstractLocation&);
 
    AbstractLocation& operator=(const AbstractLocation&);
 
    explicit AbstractLocation(RegisterDescriptor);
    explicit AbstractLocation(RegisterDescriptor, const RegisterDictionaryPtr &regdict);
    explicit AbstractLocation(const Address&, size_t nBytes = 0);
 
    AbstractLocation(RegisterDescriptor base, const Address &offset, size_t nBytes = 0);
    AbstractLocation(RegisterDescriptor base, const RegisterDictionaryPtr&, const Address &offset, size_t nBytes = 0);
    static AbstractLocation parse(const std::string&);
 
    // Overrides are documented in the base class.
    virtual bool isValid() const override;
    virtual uint64_t hash() const override;
    virtual std::string toString() const override;
    virtual void print(std::ostream&) const override;
    virtual std::string printableName() const override;
    virtual bool isEqual(const Location&) const override;
    virtual bool operator<(const Location&) const override;
    virtual bool operator<=(const Location&) const override;
    virtual bool operator>(const Location&) const override;
    virtual bool operator>=(const Location&) const override;
 
    int compare(const AbstractLocation &other) const;
 
    bool isRegister() const;
 
    bool isAddress() const;
 
    bool isAbsoluteAddress() const;
 
    bool isRelativeAddress() const;
 
    RegisterDictionaryPtr registerDictionary() const;
 
    RegisterDescriptor getRegister() const;
 
    const Address getAddress() const;
 
    const Address getOffset() const;
 
    size_t nBytes() const;
 
    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 RegisterDictionaryPtr &regdict) const;
    void print(std::ostream &out, InstructionSemantics::BaseSemantics::Formatter &fmt) const;
    void print(std::ostream &out, const RegisterDictionaryPtr &regdict, InstructionSemantics::BaseSemantics::Formatter &fmt) const;
};
class AbstractLocation: public Location {…};
 
} // namespace
} // namespace
 
#endif
#endif