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&, Address accessingInstructionVa,
                        Address accessedVa, const SymbolicExpression::Ptr &value);
 
    virtual ~SharedMemoryContext();
 
    /*------------------------------------------------------------------------------------------------------------
     * Inputs to the callback
     *------------------------------------------------------------------------------------------------------------*/
 
    ConcolicPhase phase = ConcolicPhase::EMULATION;
 
    ArchitecturePtr architecture;
 
    Emulation::RiscOperatorsPtr ops;
 
    Address 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