Emulation.h

#ifndef ROSE_BinaryAnalysis_Concolic_Emulation_H
#define ROSE_BinaryAnalysis_Concolic_Emulation_H
#include <featureTests.h>
#ifdef ROSE_ENABLE_CONCOLIC_TESTING
#include <Rose/BinaryAnalysis/Concolic/BasicTypes.h>

#include <Rose/BinaryAnalysis/BasicTypes.h>
#include <Rose/BinaryAnalysis/InstructionSemantics/BaseSemantics/BasicTypes.h>
#include <Rose/BinaryAnalysis/InstructionSemantics/SymbolicSemantics.h>
#include <Sawyer/FileSystem.h>

namespace Rose {
namespace BinaryAnalysis {
namespace Concolic {

namespace Emulation {

typedef InstructionSemantics::SymbolicSemantics::Formatter SValueFormatter; 
typedef InstructionSemantics::SymbolicSemantics::SValuePtr SValuePtr; 
typedef InstructionSemantics::SymbolicSemantics::SValue SValue; 
typedef InstructionSemantics::SymbolicSemantics::RegisterStatePtr RegisterStatePtr; 
typedef InstructionSemantics::SymbolicSemantics::RegisterState RegisterState; 
typedef InstructionSemantics::SymbolicSemantics::MemoryStatePtr MemoryStatePtr; 
typedef InstructionSemantics::SymbolicSemantics::MemoryState MemoryState; 
typedef InstructionSemantics::SymbolicSemantics::StatePtr StatePtr; 
typedef InstructionSemantics::SymbolicSemantics::State State; 
class Exit: public Exception {
    uint64_t status_;

public:
    explicit Exit(uint64_t status)
        : Exception("subordinate exit"), status_(status) {}

    ~Exit() throw () {}

    uint64_t status() const {
        return status_;
    }
};

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

    typedef InstructionSemantics::SymbolicSemantics::RiscOperators Super;

    const RegisterDescriptor REG_PATH;

    struct Settings {
    };

private:
    Settings settings_;                                 // emulation settings
    DatabasePtr db_;                                    // concolic database connection
    TestCasePtr testCase_;                              // test case whose instructions are being processed
    Partitioner2::PartitionerConstPtr partitioner_;     // ROSE disassembly info about the specimen
    ArchitecturePtr process_;                           // subordinate process, concrete state
    bool hadSystemCall_ = false;                        // true if we need to call process_->systemCall, cleared each insn
    ExecutionEventPtr hadSharedMemoryAccess_;           // set when shared memory is read, cleared each instruction
    bool isRecursive_ = false;                          // if set, avoid calling user-defined functions

protected:
    RiscOperators(const Settings&, const DatabasePtr&, const TestCasePtr&, const Partitioner2::PartitionerConstPtr&,
                  const ArchitecturePtr&, const InstructionSemantics::BaseSemantics::StatePtr&, const SmtSolverPtr&);
public:
    ~RiscOperators();

public:
    static RiscOperatorsPtr instance(const Settings &settings, const DatabasePtr&, const TestCasePtr&,
                                     const Partitioner2::PartitionerConstPtr&, const ArchitecturePtr &process,
                                     const InstructionSemantics::BaseSemantics::SValuePtr &protoval,
                                     const SmtSolverPtr &solver = SmtSolverPtr());

    static RiscOperatorsPtr promote(const InstructionSemantics::BaseSemantics::RiscOperatorsPtr&);

    // Overrides documented in base class
    virtual InstructionSemantics::BaseSemantics::RiscOperatorsPtr
    create(const InstructionSemantics::BaseSemantics::SValuePtr &/*protoval*/,
           const SmtSolverPtr& = SmtSolverPtr()) const override;
    virtual InstructionSemantics::BaseSemantics::RiscOperatorsPtr
    create(const InstructionSemantics::BaseSemantics::StatePtr &/*state*/,
           const SmtSolverPtr& = SmtSolverPtr()) const override;

public:
    const Settings& settings() const;

    Partitioner2::PartitionerConstPtr partitioner() const;

    TestCasePtr testCase() const;

    DatabasePtr database() const;

    ArchitecturePtr process() const;

    InputVariablesPtr inputVariables() const;
    bool hadSystemCall() const;
    void hadSystemCall(bool);
    ExecutionEventPtr hadSharedMemoryAccess() const;
    void hadSharedMemoryAccess(const ExecutionEventPtr&);
    bool isRecursive() const;
    void isRecursive(bool);
    size_t wordSizeBits() const;

    RegisterDictionaryPtr registerDictionary() const;

    void createInputVariables(const SmtSolver::Ptr&);

    void restoreInputVariables(const SmtSolver::Ptr&);

    void printInputVariables(std::ostream&) const;

    void printAssertions(std::ostream&) const;

public:
    // Base class overrides -- the acutal RISC operations

    virtual void startInstruction(SgAsmInstruction*) override;

    virtual void interrupt(int majr, int minr) override;

    virtual InstructionSemantics::BaseSemantics::SValuePtr
    readRegister(RegisterDescriptor reg, const InstructionSemantics::BaseSemantics::SValuePtr &dflt) override;

    virtual InstructionSemantics::BaseSemantics::SValuePtr
    readRegister(RegisterDescriptor reg) override;

    virtual InstructionSemantics::BaseSemantics::SValuePtr
    peekRegister(RegisterDescriptor reg, const InstructionSemantics::BaseSemantics::SValuePtr &dflt) override;

    virtual void
    writeRegister(RegisterDescriptor, const InstructionSemantics::BaseSemantics::SValuePtr&) override;

    virtual InstructionSemantics::BaseSemantics::SValuePtr
    readMemory(RegisterDescriptor segreg, const InstructionSemantics::BaseSemantics::SValuePtr &addr,
               const InstructionSemantics::BaseSemantics::SValuePtr &dflt,
               const InstructionSemantics::BaseSemantics::SValuePtr &cond) override;

    virtual InstructionSemantics::BaseSemantics::SValuePtr
    peekMemory(RegisterDescriptor segreg, const InstructionSemantics::BaseSemantics::SValuePtr &addr,
               const InstructionSemantics::BaseSemantics::SValuePtr &dflt) override;

    virtual void
    writeMemory(RegisterDescriptor segreg, const InstructionSemantics::BaseSemantics::SValuePtr &addr,
                const InstructionSemantics::BaseSemantics::SValuePtr &value,
                const InstructionSemantics::BaseSemantics::SValuePtr &cond) override;

    // Call this when the concrete simulation exits.
    void doExit(uint64_t);
};

using DispatcherPtr = Sawyer::SharedPointer<class Dispatcher>;

class Dispatcher: public Sawyer::SharedObject {
public:
    using Ptr = DispatcherPtr;

private:
    InstructionSemantics::BaseSemantics::DispatcherPtr inner_;

protected:
    explicit Dispatcher(const InstructionSemantics::BaseSemantics::RiscOperatorsPtr&, const ArchitecturePtr&);
public:
    ~Dispatcher();

public:
    static Ptr instance(const InstructionSemantics::BaseSemantics::RiscOperatorsPtr&, const ArchitecturePtr&);

public:
    // These functions are similar to InstructionSemantics::BaseSemantics::Dispatcher
    InstructionSemantics::BaseSemantics::RiscOperators::Ptr operators() const;

public:
    rose_addr_t concreteInstructionPointer() const;

    bool isTerminated() const;

    RiscOperatorsPtr emulationOperators() const;

    static RiscOperatorsPtr unwrapEmulationOperators(const InstructionSemantics::BaseSemantics::RiscOperatorsPtr&);

    virtual void processInstruction(SgAsmInstruction*);

    void processConcreteInstruction(SgAsmInstruction*);

    RegisterDictionaryPtr registerDictionary() const;
};

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

#endif
#endif