SharedMemory.h

#ifndef ROSE_BinaryAnalysis_Concolic_SharedMemory_H
#define ROSE_BinaryAnalysis_Concolic_SharedMemory_H
#include <featureTests.h>
#ifdef ROSE_ENABLE_CONCOLIC_TESTING

#include <Rose/BinaryAnalysis/Concolic/BasicTypes.h>
#include <Rose/BinaryAnalysis/InstructionSemantics/BaseSemantics/BasicTypes.h>
#include <Rose/BinaryAnalysis/SymbolicExpression.h>
#include <Rose/Yaml.h>

#include <Sawyer/Optional.h>
#include <Sawyer/SharedObject.h>

namespace Rose {
namespace BinaryAnalysis {
namespace Concolic {

// Shared memory context for callbacks

class SharedMemoryContext {
public:
    SharedMemoryContext() = delete;

    SharedMemoryContext(const ArchitecturePtr&, const ExecutionEventPtr &sharedMemoryEvent);

    SharedMemoryContext(const ArchitecturePtr&, const Emulation::RiscOperatorsPtr&,
                        const ExecutionEventPtr &sharedMemoryEvent);

    SharedMemoryContext(const ArchitecturePtr&, const Emulation::RiscOperatorsPtr&, rose_addr_t accessingInstructionVa,
                        rose_addr_t accessedVa, const SymbolicExpression::Ptr &value);

    virtual ~SharedMemoryContext();

    /*------------------------------------------------------------------------------------------------------------
     * Inputs to the callback
     *------------------------------------------------------------------------------------------------------------*/

    ConcolicPhase phase = ConcolicPhase::EMULATION;

    ArchitecturePtr architecture;

    Emulation::RiscOperatorsPtr ops;

    rose_addr_t ip = 0;

    AddressInterval accessedVas;

    IoDirection direction = IoDirection::READ;

    ExecutionEventPtr sharedMemoryEvent;

    SymbolicExpression::Ptr valueRead;

    SymbolicExpression::Ptr valueWritten;
};

// Callbacks to handle shared memory operations.

class SharedMemoryCallback: public Sawyer::SharedObject {
public:
    using Ptr = SharedMemoryCallbackPtr;

private:
    AddressInterval registrationVas_;                   // where in memory this callback was initially registered
    std::string name_;                                  // name of the callback in registrations and debugging

public:
    virtual ~SharedMemoryCallback();
protected:
    SharedMemoryCallback(const std::string &name);      // for factories
    SharedMemoryCallback(const AddressInterval&, const std::string &name);

public:
    static void registerFactory(const Ptr &factory);

    static bool deregisterFactory(const Ptr &factory);

    static std::vector<Ptr> registeredFactories();

    static Ptr forge(const AddressInterval &where, const Yaml::Node &config);

    virtual bool matchFactory(const Yaml::Node &config) const;

    virtual Ptr instanceFromFactory(const AddressInterval &where, const Yaml::Node &config) const;

    bool isFactory() const;

public:
    const std::string& name() const;
    void name(const std::string&);
    const AddressInterval& registrationVas() const;
    void registrationVas(const AddressInterval&);
    void hello(const SharedMemoryContext&) const;

    virtual void playback(SharedMemoryContext&) = 0;

    virtual void handlePreSharedMemory(SharedMemoryContext&) = 0;
    virtual void handlePostSharedMemory(const SharedMemoryContext&) {}
    void normalRead(SharedMemoryContext&) const;

    void notAnInput(SharedMemoryContext&) const;

    void returns(SharedMemoryContext&, const SymbolicExpression::Ptr&) const;
    void returns(SharedMemoryContext&, const InstructionSemantics::BaseSemantics::SValuePtr&) const;
    SymbolicExpressionPtr inputVariable(const SharedMemoryContext&) const;


    virtual bool operator()(bool handled, SharedMemoryContext&) final;
};

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

#endif
#endif