Semantics.h

#ifndef ROSE_BinaryAnalysis_Partitioner2_Semantics_H
#define ROSE_BinaryAnalysis_Partitioner2_Semantics_H
#include <featureTests.h>
#ifdef ROSE_ENABLE_BINARY_ANALYSIS
 
#include <Rose/As.h>
#include <Rose/BinaryAnalysis/MemoryMap.h>
#include <Rose/BinaryAnalysis/Partitioner2/BasicTypes.h>
#include <Rose/BinaryAnalysis/InstructionSemantics/SymbolicSemantics.h>
#include <Rose/BinaryAnalysis/SymbolicExpression.h>
 
#ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
#include <boost/serialization/access.hpp>
#endif
 
namespace Rose {
namespace BinaryAnalysis {
namespace Partitioner2 {
 
namespace Semantics {
 
using SValue = InstructionSemantics::SymbolicSemantics::SValue;
 
using SValuePtr = InstructionSemantics::SymbolicSemantics::SValuePtr;
 
using RegisterState = InstructionSemantics::BaseSemantics::RegisterStateGeneric;
 
using RegisterStatePtr = InstructionSemantics::BaseSemantics::RegisterStateGenericPtr;
 
using State = InstructionSemantics::BaseSemantics::State;
 
using StatePtr = InstructionSemantics::BaseSemantics::StatePtr;
 
//                                      Memory State
 
template<class Super = InstructionSemantics::SymbolicSemantics::MemoryListState> // or MemoryMapState
class MemoryState: public Super {
public:
    using Ptr = boost::shared_ptr<MemoryState>;
 
private:
    MemoryMapPtr 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&, unsigned version);
#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::AddressSpacePtr
    clone() const override {
        return Ptr(new MemoryState(*this));
    }
 
public:
    static Ptr
    promote(const InstructionSemantics::BaseSemantics::MemoryStatePtr &x) {
        Ptr retval = as<MemoryState>(x);
        assert(x!=NULL);
        return retval;
    }
 
public:
    bool enabled() const { return enabled_; }
    void enabled(bool b) { enabled_ = b; }
    MemoryMapPtr memoryMap() const { return map_; }
    void memoryMap(const MemoryMapPtr &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;
};
 
using MemoryListState = MemoryState<InstructionSemantics::SymbolicSemantics::MemoryListState>;
 
using MemoryMapState = MemoryState<InstructionSemantics::SymbolicSemantics::MemoryMapState>;
 
using MemoryListStatePtr = boost::shared_ptr<MemoryListState>;
 
using MemoryMapStatePtr = boost::shared_ptr<MemoryMapState>;
 
//                                      RISC Operators
 
using RiscOperatorsPtr = boost::shared_ptr<class RiscOperators>;
 
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&, unsigned version);
#endif
 
    // Real constructors
protected:
    RiscOperators();                                    // for serialization
 
    RiscOperators(const InstructionSemantics::BaseSemantics::SValuePtr &protoval, const SmtSolverPtr &solver);
 
    RiscOperators(const InstructionSemantics::BaseSemantics::StatePtr &state, const SmtSolverPtr &solver);
 
public:
    ~RiscOperators();
 
    // Static allocating constructors
public:
    static RiscOperatorsPtr instance(const RegisterDictionaryPtr&);
    static RiscOperatorsPtr instance(const RegisterDictionaryPtr&, const SmtSolverPtr&,
                                     SemanticMemoryParadigm memoryParadigm = LIST_BASED_MEMORY);
    static RiscOperatorsPtr instance(const InstructionSemantics::BaseSemantics::SValuePtr &protoval);
    static RiscOperatorsPtr instance(const InstructionSemantics::BaseSemantics::SValuePtr &protoval, const SmtSolverPtr&);
    static RiscOperatorsPtr instance(const InstructionSemantics::BaseSemantics::StatePtr&);
    static RiscOperatorsPtr instance(const InstructionSemantics::BaseSemantics::StatePtr&, const SmtSolverPtr&);
    // Virtual constructors
public:
    virtual InstructionSemantics::BaseSemantics::RiscOperatorsPtr
    create(const InstructionSemantics::BaseSemantics::SValuePtr &protoval,
           const SmtSolverPtr &solver = SmtSolverPtr()) const override;
 
    virtual InstructionSemantics::BaseSemantics::RiscOperatorsPtr
    create(const InstructionSemantics::BaseSemantics::StatePtr &state,
           const SmtSolverPtr &solver = SmtSolverPtr()) const override;
 
    // Dynamic pointer casts
public:
    static RiscOperatorsPtr promote(const InstructionSemantics::BaseSemantics::RiscOperatorsPtr&);
 
    // 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
 
#endif
#endif