Semantics.h

#ifndef ROSE_BinaryAnalysis_Partitioner2_Semantics_H
#define ROSE_BinaryAnalysis_Partitioner2_Semantics_H
#include <featureTests.h>
#ifdef ROSE_ENABLE_BINARY_ANALYSIS

#include <Rose/BinaryAnalysis/Partitioner2/BasicTypes.h>
#include <Rose/BinaryAnalysis/InstructionSemantics/SymbolicSemantics.h>
#include <Rose/BinaryAnalysis/SymbolicExpression.h>

#include <boost/serialization/access.hpp>
#include <boost/serialization/base_object.hpp>
#include <boost/serialization/export.hpp>
#include <boost/serialization/vector.hpp>

namespace Rose {
namespace BinaryAnalysis {
namespace Partitioner2 {

namespace Semantics {

typedef InstructionSemantics::SymbolicSemantics::SValue SValue;

typedef InstructionSemantics::SymbolicSemantics::SValuePtr SValuePtr;

typedef InstructionSemantics::BaseSemantics::RegisterStateGeneric RegisterState;

typedef InstructionSemantics::BaseSemantics::RegisterStateGenericPtr RegisterStatePtr;

typedef InstructionSemantics::BaseSemantics::State State;

typedef InstructionSemantics::BaseSemantics::StatePtr StatePtr;

//                                      Memory State

template<class Super = InstructionSemantics::SymbolicSemantics::MemoryListState> // or MemoryMapState
class MemoryState: public Super {
public:
    typedef boost::shared_ptr<MemoryState> Ptr;

private:
    MemoryMap::Ptr map_;
    std::vector<SValuePtr> addressesRead_;
    bool enabled_;

#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_BASE_OBJECT_NVP(Super);
        s & BOOST_SERIALIZATION_NVP(map_);
        s & BOOST_SERIALIZATION_NVP(addressesRead_);
        s & BOOST_SERIALIZATION_NVP(enabled_);
    }
#endif

protected:
    MemoryState()                                       // for serialization
        : enabled_(true) {}

    explicit MemoryState(const InstructionSemantics::BaseSemantics::MemoryCellPtr &protocell)
        : Super(protocell), enabled_(true) {}

    MemoryState(const InstructionSemantics::BaseSemantics::SValuePtr &addrProtoval,
                const InstructionSemantics::BaseSemantics::SValuePtr &valProtoval)
        : Super(addrProtoval, valProtoval), enabled_(true) {}

public:
    static Ptr instance(const InstructionSemantics::BaseSemantics::MemoryCellPtr &protocell) {
        return Ptr(new MemoryState(protocell));
    }

    static  Ptr instance(const InstructionSemantics::BaseSemantics::SValuePtr &addrProtoval,
                         const InstructionSemantics::BaseSemantics::SValuePtr &valProtoval) {
        return Ptr(new MemoryState(addrProtoval, valProtoval));
    }

    static Ptr instance(const Ptr &other) {
        return Ptr(new MemoryState(*other));
    }

public:
    virtual InstructionSemantics::BaseSemantics::MemoryStatePtr
    create(const InstructionSemantics::BaseSemantics::SValuePtr &addrProtoval,
           const InstructionSemantics::BaseSemantics::SValuePtr &valProtoval) const override {
        return instance(addrProtoval, valProtoval);
    }

    virtual InstructionSemantics::BaseSemantics::MemoryStatePtr
    create(const InstructionSemantics::BaseSemantics::MemoryCellPtr &protocell) const override {
        return instance(protocell);
    }

    virtual InstructionSemantics::BaseSemantics::MemoryStatePtr
    clone() const override {
        return Ptr(new MemoryState(*this));
    }

public:
    static Ptr
    promote(const InstructionSemantics::BaseSemantics::MemoryStatePtr &x) {
        Ptr retval = boost::dynamic_pointer_cast<MemoryState>(x);
        assert(x!=NULL);
        return retval;
    }

public:
    bool enabled() const { return enabled_; }
    void enabled(bool b) { enabled_ = b; }
    MemoryMap::Ptr memoryMap() const { return map_; }
    void memoryMap(const MemoryMap::Ptr &map) { map_ = map; }
    const std::vector<SValuePtr>& addressesRead() const { return addressesRead_; }
    std::vector<SValuePtr>& addressesRead() { return addressesRead_; }
public:
    virtual InstructionSemantics::BaseSemantics::SValuePtr
    readMemory(const InstructionSemantics::BaseSemantics::SValuePtr &addr,
               const InstructionSemantics::BaseSemantics::SValuePtr &dflt,
               InstructionSemantics::BaseSemantics::RiscOperators *addrOps,
               InstructionSemantics::BaseSemantics::RiscOperators *valOps) override;

    virtual void
    writeMemory(const InstructionSemantics::BaseSemantics::SValuePtr &addr,
                const InstructionSemantics::BaseSemantics::SValuePtr &value,
                InstructionSemantics::BaseSemantics::RiscOperators *addrOps,
                InstructionSemantics::BaseSemantics::RiscOperators *valOps) override;

    virtual InstructionSemantics::BaseSemantics::SValuePtr
    peekMemory(const InstructionSemantics::BaseSemantics::SValuePtr &addr,
               const InstructionSemantics::BaseSemantics::SValuePtr &dflt,
               InstructionSemantics::BaseSemantics::RiscOperators *addrOps,
               InstructionSemantics::BaseSemantics::RiscOperators *valOps) override;

private:
    InstructionSemantics::BaseSemantics::SValuePtr
    readOrPeekMemory(const InstructionSemantics::BaseSemantics::SValuePtr &addr,
                     const InstructionSemantics::BaseSemantics::SValuePtr &dflt,
                     InstructionSemantics::BaseSemantics::RiscOperators *addrOps,
                     InstructionSemantics::BaseSemantics::RiscOperators *valOps,
                     bool withSideEffects);

public:
    void print(std::ostream&, InstructionSemantics::BaseSemantics::Formatter&) const override;
};

typedef MemoryState<InstructionSemantics::SymbolicSemantics::MemoryListState> MemoryListState;

typedef MemoryState<InstructionSemantics::SymbolicSemantics::MemoryMapState> MemoryMapState;

typedef boost::shared_ptr<MemoryListState> MemoryListStatePtr;

typedef boost::shared_ptr<MemoryMapState> MemoryMapStatePtr;

//                                      RISC Operators

typedef boost::shared_ptr<class RiscOperators> RiscOperatorsPtr;

class RiscOperators: public InstructionSemantics::SymbolicSemantics::RiscOperators {
public:
    using Super = InstructionSemantics::SymbolicSemantics::RiscOperators;
    using Ptr = RiscOperatorsPtr;

private:
    static const size_t TRIM_THRESHOLD_DFLT = 100;

    // 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_BASE_OBJECT_NVP(Super);
    }
#endif

    // Real constructors
protected:
    RiscOperators();                                    // for serialization

    explicit RiscOperators(const InstructionSemantics::BaseSemantics::SValuePtr &protoval,
                           const SmtSolverPtr &solver = SmtSolverPtr());

    explicit RiscOperators(const InstructionSemantics::BaseSemantics::StatePtr &state,
                           const SmtSolverPtr &solver = SmtSolverPtr());

public:
    ~RiscOperators();

    // Static allocating constructors
public:
    static RiscOperatorsPtr instance(const RegisterDictionaryPtr &regdict, const SmtSolverPtr &solver = SmtSolverPtr(),
                                     SemanticMemoryParadigm memoryParadigm = LIST_BASED_MEMORY) {
        InstructionSemantics::BaseSemantics::SValuePtr protoval = SValue::instance();
        InstructionSemantics::BaseSemantics::RegisterStatePtr registers = RegisterState::instance(protoval, regdict);
        InstructionSemantics::BaseSemantics::MemoryStatePtr memory;
        switch (memoryParadigm) {
            case LIST_BASED_MEMORY:
                memory = MemoryListState::instance(protoval, protoval);
                break;
            case MAP_BASED_MEMORY:
                memory = MemoryMapState::instance(protoval, protoval);
                break;
        }
        InstructionSemantics::BaseSemantics::StatePtr state = State::instance(registers, memory);
        return RiscOperatorsPtr(new RiscOperators(state, solver));
    }

    static RiscOperatorsPtr
    instance(const InstructionSemantics::BaseSemantics::SValuePtr &protoval, const SmtSolverPtr &solver = SmtSolverPtr()) {
        return RiscOperatorsPtr(new RiscOperators(protoval, solver));
    }

    static RiscOperatorsPtr
    instance(const InstructionSemantics::BaseSemantics::StatePtr &state, const SmtSolverPtr &solver = SmtSolverPtr()) {
        return RiscOperatorsPtr(new RiscOperators(state, solver));
    }

    // Virtual constructors
public:
    virtual InstructionSemantics::BaseSemantics::RiscOperatorsPtr
    create(const InstructionSemantics::BaseSemantics::SValuePtr &protoval,
           const SmtSolverPtr &solver = SmtSolverPtr()) const override {
        return instance(protoval, solver);
    }

    virtual InstructionSemantics::BaseSemantics::RiscOperatorsPtr
    create(const InstructionSemantics::BaseSemantics::StatePtr &state,
           const SmtSolverPtr &solver = SmtSolverPtr()) const override {
        return instance(state, solver);
    }

    // Dynamic pointer casts
public:
    static RiscOperatorsPtr
    promote(const InstructionSemantics::BaseSemantics::RiscOperatorsPtr &x) {
        RiscOperatorsPtr retval = boost::dynamic_pointer_cast<RiscOperators>(x);
        assert(retval!=NULL);
        return retval;
    }
    
    // Override methods from base class.
public:
    virtual void startInstruction(SgAsmInstruction*) override;
};

//                                      Memory State

template<class Super>
InstructionSemantics::BaseSemantics::SValuePtr
MemoryState<Super>::readMemory(const InstructionSemantics::BaseSemantics::SValuePtr &addr,
                               const InstructionSemantics::BaseSemantics::SValuePtr &dflt,
                               InstructionSemantics::BaseSemantics::RiscOperators *addrOps,
                               InstructionSemantics::BaseSemantics::RiscOperators *valOps) {
    return readOrPeekMemory(addr, dflt, addrOps, valOps, true/*with side effects*/);
}

template<class Super>
InstructionSemantics::BaseSemantics::SValuePtr
MemoryState<Super>::peekMemory(const InstructionSemantics::BaseSemantics::SValuePtr &addr,
                               const InstructionSemantics::BaseSemantics::SValuePtr &dflt,
                               InstructionSemantics::BaseSemantics::RiscOperators *addrOps,
                               InstructionSemantics::BaseSemantics::RiscOperators *valOps) {
    return readOrPeekMemory(addr, dflt, addrOps, valOps, false/*no side effects*/);
}

template<class Super>
InstructionSemantics::BaseSemantics::SValuePtr
MemoryState<Super>::readOrPeekMemory(const InstructionSemantics::BaseSemantics::SValuePtr &addr,
                                     const InstructionSemantics::BaseSemantics::SValuePtr &dflt,
                                     InstructionSemantics::BaseSemantics::RiscOperators *addrOps,
                                     InstructionSemantics::BaseSemantics::RiscOperators *valOps,
                                     bool withSideEffects) {
    using namespace InstructionSemantics;

    if (!enabled_)
        return dflt->copy();

    addressesRead_.push_back(SValue::promote(addr));
    if (map_ && addr->toUnsigned()) {
        ASSERT_require2(8==dflt->nBits(), "multi-byte reads should have been handled above this call");
        rose_addr_t va = addr->toUnsigned().get();
        bool isModifiable = map_->at(va).require(MemoryMap::WRITABLE).exists();
        bool isInitialized = map_->at(va).require(MemoryMap::INITIALIZED).exists();
        if (!isModifiable || isInitialized) {
            uint8_t byte;
            if (1 == map_->at(va).limit(1).read(&byte).size()) {
                SymbolicExpression::Ptr expr = SymbolicExpression::makeIntegerConstant(8, byte);
                if (isModifiable) {
                    SymbolicExpression::Ptr indet = SymbolicExpression::makeIntegerVariable(8);
                    expr = SymbolicExpression::makeSet(expr, indet, valOps->solver());
                }
                SymbolicSemantics::SValuePtr val = SymbolicSemantics::SValue::promote(valOps->undefined_(8));
                val->set_expression(expr);
                return val;
            }
        }
    }

    if (withSideEffects) {
        return Super::readMemory(addr, dflt, addrOps, valOps);
    } else {
        return Super::peekMemory(addr, dflt, addrOps, valOps);
    }
}

template<class Super>
void
MemoryState<Super>::writeMemory(const InstructionSemantics::BaseSemantics::SValuePtr &addr,
                                const InstructionSemantics::BaseSemantics::SValuePtr &value,
                                InstructionSemantics::BaseSemantics::RiscOperators *addrOps,
                                InstructionSemantics::BaseSemantics::RiscOperators *valOps) {
    if (!enabled_)
        return;
    Super::writeMemory(addr, value, addrOps, valOps);
}

template<class Super>
void
MemoryState<Super>::print(std::ostream &out, InstructionSemantics::BaseSemantics::Formatter &fmt) const {
    if (map_) {
        map_->dump(out, fmt.get_line_prefix());
    } else {
        out <<fmt.get_line_prefix() <<"no memory map\n";
    }

    Super::print(out, fmt);
}

} // namespace
} // namespace
} // namespace
} // namespace

#ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
BOOST_CLASS_EXPORT_KEY(Rose::BinaryAnalysis::Partitioner2::Semantics::MemoryListState);
BOOST_CLASS_EXPORT_KEY(Rose::BinaryAnalysis::Partitioner2::Semantics::MemoryMapState);
BOOST_CLASS_EXPORT_KEY(Rose::BinaryAnalysis::Partitioner2::Semantics::RiscOperators);
#endif

#endif
#endif