BaseSemanticsSValue.h

#ifndef ROSE_BinaryAnalysis_InstructionSemantics2_BaseSemantics_SValue_H
#define ROSE_BinaryAnalysis_InstructionSemantics2_BaseSemantics_SValue_H

#include <BaseSemanticsTypes.h>
#include <BinarySmtSolver.h>

#include <boost/serialization/access.hpp>
#include <boost/serialization/nvp.hpp>
#include <Sawyer/SharedPointer.h>

namespace Rose {
namespace BinaryAnalysis {
namespace InstructionSemantics2 {
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 {
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:
    typedef SValuePtr Ptr;

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:
    virtual bool isBottom() const = 0;

    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 may_equal(const SValuePtr &other, const SmtSolverPtr &solver = SmtSolverPtr()) const = 0;

    virtual bool must_equal(const SValuePtr &other, const SmtSolverPtr &solver = SmtSolverPtr()) const = 0;

    bool isTrue() const {
        return is_number() && get_number()!=0;
    }

    bool isFalse() const {
        return is_number() && get_number()==0;
    }

    void print(std::ostream&) const;
    virtual void print(std::ostream&, Formatter&) const = 0;
    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); }
    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

#endif