ConcreteLocation.h

#ifndef ROSE_BinaryAnalysis_ConcreteLocation_H
#define ROSE_BinaryAnalysis_ConcreteLocation_H
#include <featureTests.h>
#ifdef ROSE_ENABLE_BINARY_ANALYSIS
 
#include <Rose/BinaryAnalysis/BasicTypes.h>
#include <Rose/BinaryAnalysis/RegisterDescriptor.h>
#include <Rose/Location.h>
 
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
#include <boost/serialization/access.hpp>
#endif
 
#include <ostream>
#include <Sawyer/Optional.h>
#include <string>
 
namespace Rose {
namespace BinaryAnalysis {
 
class ConcreteLocation: public Location {
public:
    enum Type {
        NO_LOCATION,                                    
        REGISTER,                                       
        RELATIVE,                                       
        ABSOLUTE                                        
    };
 
private:
    RegisterDescriptor reg_;
    Sawyer::Optional<uint64_t> va_;
    RegisterDictionaryPtr regdict_;                     // not hashed or compared; only for generating string output
 
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
    friend class boost::serialization::access;
    template<class S> void serialize(S&, unsigned);
#endif
 
public:
    ConcreteLocation();
    virtual ~ConcreteLocation();
 
    ConcreteLocation(const ConcreteLocation&);
    ConcreteLocation& operator=(const ConcreteLocation&);
 
    explicit ConcreteLocation(RegisterDescriptor);
    explicit ConcreteLocation(RegisterDescriptor, const RegisterDictionaryPtr&);
    explicit ConcreteLocation(Address);
 
    ConcreteLocation(RegisterDescriptor, int64_t offset);
    ConcreteLocation(RegisterDescriptor, int64_t offset, const RegisterDictionaryPtr&);
    static ConcreteLocation parse(const std::string&);
 
    // Inherited methods
    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;
 
    void print(std::ostream&, const RegisterDictionaryPtr&) const;
 
    int compare(const ConcreteLocation&) const;
 
    Type type() const;
 
    RegisterDictionaryPtr registerDictionary() const;
    void registerDictionary(const RegisterDictionaryPtr&);
    RegisterDescriptor reg() const;
 
    Address address() const;
 
    int64_t offset() const;
};
 
} // namespace
} // namespace
 
#endif
#endif