SValue.h

#ifndef ROSE_BinaryAnalysis_InstructionSemantics_BaseSemantics_SValue_H
#define ROSE_BinaryAnalysis_InstructionSemantics_BaseSemantics_SValue_H
#include <featureTests.h>
#ifdef ROSE_ENABLE_BINARY_ANALYSIS
 
#include <Rose/BinaryAnalysis/InstructionSemantics/BaseSemantics/BasicTypes.h>
#include <Rose/BinaryAnalysis/SmtSolver.h>
#include <Combinatorics.h>                              // rose
 
#include <boost/serialization/access.hpp>
#include <boost/serialization/export.hpp>
#include <boost/serialization/nvp.hpp>
#include <Sawyer/SharedPointer.h>
 
namespace Rose {
namespace BinaryAnalysis {
namespace InstructionSemantics {
namespace BaseSemantics {
 
//                                      Semantic Values
 
// This is leftover for compatibility with an older API.  The old API had code like this:
//    User::SValue user_svalue = BaseSemantics::dynamic_pointer_cast<User::SValue>(base_svalue);
// Which can be replaced now with
//    User::SValue user_svalue = base_svalue.dynamicCast<User::SValue>();
template<class To, class From>
Sawyer::SharedPointer<To> dynamic_pointer_cast(const Sawyer::SharedPointer<From> &from) {
    return from.template dynamicCast<To>();
}
 
class SValue: public Sawyer::SharedObject, public Sawyer::SharedFromThis<SValue>, public Sawyer::SmallObject {
public:
    using Ptr = SValuePtr;
 
protected:
    size_t width;                               
    // Serialization
#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_NVP(width);
    }
#endif
    
    // Normal, protected, C++ constructors
protected:
    SValue(): width(0) {}                               // needed for serialization
    explicit SValue(size_t nbits): width(nbits) {}      // hot
    SValue(const SValue &other): Sawyer::SharedObject(other), width(other.width) {}
 
public:
    virtual ~SValue() {}
 
    // Allocating static constructor.  None are needed--this class is abstract.
 
    // Allocating virtual constructors.  undefined_() needs underscores, so we do so consistently for all
    // these allocating virtual c'tors.  However, we use copy() rather than copy_() because this one is fundamentally
    // different: the object (this) is use for more than just selecting which virtual method to invoke.
    //
    // The naming scheme we use here is a bit different than for most other objects for historical reasons.  Most other classes
    // use "create" and "clone" as the virtual constructor names, but SValue uses names ending in undercore, and "copy". The
    // other difference (at least in this base class) is that we don't define any real constructors or static allocating
    // constructors (usually named "instance")--it's because this is an abstract class.
public:
    virtual SValuePtr undefined_(size_t nbits) const = 0; // hot
 
    virtual SValuePtr unspecified_(size_t nbits) const = 0;
 
    virtual SValuePtr bottom_(size_t nBits) const = 0;
 
    virtual SValuePtr number_(size_t nbits, uint64_t number) const = 0; // hot
 
    virtual SValuePtr boolean_(bool value) const { return number_(1, value?1:0); }
 
    virtual SValuePtr copy(size_t new_width=0) const = 0;
 
    virtual Sawyer::Optional<SValuePtr>
    createOptionalMerge(const SValuePtr &other, const MergerPtr &merger, const SmtSolverPtr &solver) const = 0;
 
    SValuePtr createMerged(const SValuePtr &other, const MergerPtr &merger, const SmtSolverPtr &solver) const /*final*/ {
        return createOptionalMerge(other, merger, solver).orElse(copy());
    }
 
    // Dynamic pointer casts. No-ops since this is the base class
public:
    static SValuePtr promote(const SValuePtr &x) {
        ASSERT_not_null(x);
        return x;
    }
 
    // The rest of the API...
public:
    size_t nBits() const /*final*/;
 
    virtual bool isBottom() const = 0;
 
    bool isConcrete() const /*final*/;
 
    Sawyer::Optional<uint64_t> toUnsigned() const /*final*/;
 
    Sawyer::Optional<int64_t> toSigned() const /*final*/;
 
    bool mustEqual(const SValuePtr &other, const SmtSolverPtr &solver = SmtSolverPtr()) const /*final*/;
 
    bool mayEqual(const SValuePtr &other, const SmtSolverPtr &solver = SmtSolverPtr()) const /*final*/;
 
    bool isTrue() const /*final*/;
 
    bool isFalse() const /*final*/;
 
    std::string comment() const /*final*/;
    void comment(const std::string&) const /*final*/;   // const is intentional (see documentation)
    virtual void hash(Combinatorics::Hasher&) const = 0;
 
    void print(std::ostream&) const;
    virtual void print(std::ostream&, Formatter&) const = 0;
    std::string toString() const;
 
    class WithFormatter {
        SValuePtr obj;
        Formatter &fmt;
    public:
        WithFormatter(const SValuePtr &svalue, Formatter &fmt): obj(svalue), fmt(fmt) {}
        void print(std::ostream &stream) const { obj->print(stream, fmt); }
    };
 
    WithFormatter with_format(Formatter &fmt) { return WithFormatter(SValuePtr(this), fmt); }
    WithFormatter operator+(Formatter &fmt) { return with_format(fmt); }
    WithFormatter operator+(const std::string &linePrefix);
    // This is the virtual interface that uses names that are not consistent with most of the rest of binary analysis.  Calling
    // these directly is deprecated and we may make them protected at some time. [Robb Matzke 2021-03-18].
public: // for backward compatibility for now, but assume protected
    virtual bool is_number() const = 0;
 
    virtual uint64_t get_number() const = 0;
 
    virtual size_t get_width() const { return width; }
    virtual void set_width(size_t nbits) { width = nbits; }
    virtual bool must_equal(const SValuePtr &other, const SmtSolverPtr &solver = SmtSolverPtr()) const = 0;
 
    virtual bool may_equal(const SValuePtr &other, const SmtSolverPtr &solver = SmtSolverPtr()) const = 0;
 
    virtual std::string get_comment() const { return ""; }
    virtual void set_comment(const std::string&) const {} // const is intended; cf. doxygen comment
};
 
std::ostream& operator<<(std::ostream&, const SValue&);
std::ostream& operator<<(std::ostream&, const SValue::WithFormatter&);
 
} // namespace
} // namespace
} // namespace
} // namespace
 
BOOST_CLASS_EXPORT_KEY(Rose::BinaryAnalysis::InstructionSemantics::BaseSemantics::SValue);
 
#endif
#endif