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/BasicTypes.h>
#include <Combinatorics.h>                              // ROSE
 
#include <Sawyer/SharedObject.h>
#include <Sawyer/SmallObject.h>
 
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
#include <boost/serialization/access.hpp>
#include <boost/serialization/export.hpp>
#include <boost/serialization/nvp.hpp>
#endif
 
namespace Rose {
namespace BinaryAnalysis {
namespace InstructionSemantics {
namespace BaseSemantics {
 
//                                     CIL and JVM Semantic Values
 
enum class ValueKind {
    Unknown,
    Integer32,       // JVM Integer
    Integer64,       // JVM Long
    NativeInt,       // CIL native integer
    Float32,         // JVM Float
    Float64,         // JVM Double
    ArrayReference,
    ObjectReference,
    ManagedPointer,
    UnmanagedPointer,
    ReturnAddress,
 
    Category2Tail,   // second slot of long/double
    Invalid          // unusable/destroyed/corrupted slot
};
 
enum class Nullness {
    DefinitelyNull,
    MaybeNull,
    DefinitelyNonNull
};
 
std::string toString(ValueKind);
 
std::ostream& operator<<(std::ostream&, ValueKind);
 
 
//                                      Semantic Values
 
class SValue: public Sawyer::SharedObject, public Sawyer::SharedFromThis<SValue>, public Sawyer::SmallObject {
public:
    using Ptr = SValuePtr;
 
protected:
    size_t width = 0;                           
    ValueKind kind_ = ValueKind::Unknown;       
    Nullness nullness_ = Nullness::MaybeNull;   
    SValuePtr arrayLength_;                     
    std::vector<SValuePtr> arrayDimensions_;    
    std::string typeDescriptor_;   
    std::string symbolName_;       
    // Serialization
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        s & BOOST_SERIALIZATION_NVP(width);
        s & BOOST_SERIALIZATION_NVP(kind_);
        s & BOOST_SERIALIZATION_NVP(nullness_);
        s & BOOST_SERIALIZATION_NVP(arrayLength_);
        s & BOOST_SERIALIZATION_NVP(arrayDimensions_);
        s & BOOST_SERIALIZATION_NVP(typeDescriptor_);
        s & BOOST_SERIALIZATION_NVP(symbolName_);
    }
#endif
    
    // Normal, protected, C++ constructors
protected:
    SValue() = default;
    explicit SValue(size_t nbits);
 
    SValue(const SValue&);
    SValue& operator=(const SValue&);
 
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 used 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;
 
    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;
 
    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&, const SmtSolverPtr&) const /*final*/;
 
    // Dynamic pointer casts. No-ops since this is the base class
public:
    static SValuePtr promote(const SValuePtr&);
 
    // The rest of the API...
public:
    size_t nBits() const /*final*/;
 
    virtual ValueKind kind() const;
    virtual void kind(ValueKind k);
 
    virtual void arrayLength(const SValuePtr &sval);
    virtual SValuePtr arrayLength() const;
    virtual bool hasArrayLength() const;
 
    virtual void arrayDimensions(const std::vector<SValuePtr> &dims);
    virtual const std::vector<SValuePtr>& arrayDimensions() const;
 
    virtual void typeDescriptor(const std::string &s);
    virtual const std::string& typeDescriptor() const;
    virtual bool hasTypeDescriptor() const;
 
    virtual void symbolName(const std::string &s);
    virtual const std::string& symbolName() const;
    virtual bool hasSymbolName() const;
 
    bool isJvmCategory1();
 
    bool isJvmCategory2();
 
    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*/;
 
    Nullness nullness() const;
    void nullness(Nullness value);
 
    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&, Formatter&);
        void print(std::ostream&) const;
    };
 
    WithFormatter with_format(Formatter&);
    WithFormatter operator+(Formatter&);
    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;
    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
 
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
BOOST_CLASS_EXPORT_KEY(Rose::BinaryAnalysis::InstructionSemantics::BaseSemantics::SValue);
#endif
 
#endif
#endif