Architecture.h

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

#include <Rose/BinaryAnalysis/ByteOrder.h>
#include <Rose/BinaryAnalysis/Concolic/BasicTypes.h>
#include <Rose/BinaryAnalysis/Concolic/ExecutionLocation.h>
#include <Rose/BinaryAnalysis/Debugger/BasicTypes.h>
#include <Rose/BinaryAnalysis/InstructionSemantics/BaseSemantics/BasicTypes.h>
#include <Rose/BinaryAnalysis/Partitioner2/BasicTypes.h>
#include <Rose/BinaryAnalysis/Partitioner2/Engine.h>
#include <Rose/BinaryAnalysis/RegisterDescriptor.h>
#include <Rose/BinaryAnalysis/SmtSolver.h>
#include <Rose/Yaml.h>

#include <Sawyer/BitVector.h>

#include <boost/filesystem.hpp>

namespace Rose {
namespace BinaryAnalysis {
namespace Concolic {

class Architecture: public Sawyer::SharedObject, public Sawyer::SharedFromThis<Architecture> {
public:
    using Ptr = ArchitecturePtr;

    using SystemCallMap = Sawyer::Container::Map<int /*syscall*/, SyscallCallbacks>;

    using SharedMemoryMap = Sawyer::Container::IntervalMap<AddressInterval, SharedMemoryCallbacks>;

private:
    std::string name_;                                  // architecture name for factory matching
    DatabasePtr db_;
    TestCaseId testCaseId_;
    TestCasePtr testCase_;
    Partitioner2::PartitionerConstPtr partitioner_;
    Debugger::BasePtr debugger_;
    ExecutionLocation currentLocation_;                 // incremented when the instruction begins execution
    SystemCallMap systemCalls_;                         // callbacks for syscalls
    SharedMemoryMap sharedMemory_;                      // callbacks for shared memory
    InputVariablesPtr inputVariables_;                  // info about variables for events and inputs
    Sawyer::Optional<rose_addr_t> scratchVa_;           // scratch page for internal use in subordinate address space

protected:
    // See "instance" methods in subclasses
    explicit Architecture(const std::string&);          // for factories
    Architecture(const DatabasePtr&, TestCaseId);       // for non-factories
public:
    virtual ~Architecture();

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

    static bool deregisterFactory(const Ptr &factory);

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

    static Ptr forge(const DatabasePtr&, TestCaseId, const Yaml::Node &config);
    static Ptr forge(const DatabasePtr&, const TestCasePtr&, const Yaml::Node &config);
    virtual bool matchFactory(const Yaml::Node &config) const = 0;

    virtual Ptr instanceFromFactory(const DatabasePtr&, TestCaseId, const Yaml::Node &config) const = 0;

    bool isFactory() const;

    // Properties
public:
    const std::string& name() const;
    void name(const std::string&);
    DatabasePtr database() const;

    TestCaseId testCaseId() const;

    TestCasePtr testCase() const;

    Partitioner2::PartitionerConstPtr partitioner() const;
    void partitioner(const Partitioner2::PartitionerConstPtr&);

    Debugger::BasePtr debugger() const;
    void debugger(const Debugger::BasePtr&);
    Sawyer::Optional<rose_addr_t> scratchVa() const;
    void scratchVa(const Sawyer::Optional<rose_addr_t>&);
    ExecutionLocation currentLocation() const;
    void currentLocation(const ExecutionLocation&);
    const SystemCallMap& systemCalls() const;

    const SharedMemoryMap& sharedMemory() const;

    InputVariablesPtr inputVariables() const;
    void inputVariables(const InputVariablesPtr&);
    // Functions that can be called before execution starts.
public:
    virtual Partitioner2::PartitionerPtr partition(const Partitioner2::EnginePtr&, const std::string &specimenName) = 0;

    virtual void configureSystemCalls() = 0;

    virtual void configureSharedMemory(const Yaml::Node &config);

    void sharedMemory(const SharedMemoryCallbackPtr&);
    void sharedMemory(const SharedMemoryCallbackPtr&, const AddressInterval&);
    void systemCalls(size_t syscallId, const SyscallCallbackPtr&);

    virtual void load(const boost::filesystem::path &tempDirectory) = 0;

    virtual bool isTerminated();

    virtual InstructionSemantics::BaseSemantics::DispatcherPtr
    makeDispatcher(const InstructionSemantics::BaseSemantics::RiscOperatorsPtr&) = 0;

    // Functions that create execution events. These query the concrete state but do not modify it.
public:
    virtual std::vector<ExecutionEventPtr> createMemoryRestoreEvents() = 0;
    std::vector<ExecutionEventPtr> createMemoryRestoreEvents(const MemoryMapPtr&);

    virtual std::vector<ExecutionEventPtr> createMemoryHashEvents() = 0;

    virtual std::vector<ExecutionEventPtr> createMemoryAdjustEvents(const MemoryMap::Ptr&, rose_addr_t insnVa) = 0;

    virtual std::vector<ExecutionEventPtr> createRegisterRestoreEvents();

    void saveEvents(const std::vector<ExecutionEventPtr>&, When);

    // High-level functions controlling concrete execution.
public:
    size_t playAllEvents(const Partitioner2::PartitionerConstPtr&);

    virtual bool playEvent(const ExecutionEventPtr&);

    virtual void runToEvent(const ExecutionEventPtr&, const Partitioner2::PartitionerConstPtr&);

    uint64_t readMemoryUnsigned(rose_addr_t va, size_t nBytes);

    virtual std::string readCString(rose_addr_t va, size_t maxBytes = UNLIMITED);

    // Low-level functions controlling concrete execution.
public:
    virtual ByteOrder::Endianness memoryByteOrder() = 0;

    virtual rose_addr_t ip();
    virtual void ip(rose_addr_t);
    virtual void mapMemory(const AddressInterval &where, unsigned permissions);

    virtual void unmapMemory(const AddressInterval &where);

    virtual size_t writeMemory(rose_addr_t startVa, const std::vector<uint8_t> &bytes);

    virtual std::vector<uint8_t> readMemory(rose_addr_t startVa, size_t nBytes);

    virtual void writeRegister(RegisterDescriptor, uint64_t value);
    virtual void writeRegister(RegisterDescriptor, const Sawyer::Container::BitVector&);
    virtual Sawyer::Container::BitVector readRegister(RegisterDescriptor);

    virtual void checkInstruction(SgAsmInstruction*);

    virtual void advanceExecution(const InstructionSemantics::BaseSemantics::RiscOperatorsPtr&);

    virtual void executeInstruction(const Partitioner2::PartitionerConstPtr&);
    virtual void executeInstruction(const InstructionSemantics::BaseSemantics::RiscOperatorsPtr&, SgAsmInstruction*);
    const ExecutionLocation& nextInstructionLocation();

    const ExecutionLocation& nextEventLocation(When);
    std::vector<ExecutionEventPtr> getRelatedEvents(const ExecutionEventPtr&) const;

    // Functions related to symbolic states.
public:
    virtual void createInputVariables(const Partitioner2::PartitionerConstPtr&, const Emulation::RiscOperatorsPtr&,
                                      const SmtSolver::Ptr&) = 0;

    virtual void restoreInputVariables(const Partitioner2::PartitionerConstPtr&, const Emulation::RiscOperatorsPtr&,
                                       const SmtSolver::Ptr&);

    // Functions related to operating system emulation
public:
    virtual void systemCall(const Partitioner2::PartitionerConstPtr&,
                            const InstructionSemantics::BaseSemantics::RiscOperatorsPtr&) {}

    virtual std::pair<ExecutionEventPtr, SymbolicExpressionPtr>
    sharedMemoryRead(const SharedMemoryCallbacks&, const Partitioner2::PartitionerConstPtr&, const Emulation::RiscOperatorsPtr&,
                       rose_addr_t memVa, size_t nBytes);
    virtual bool
    sharedMemoryWrite(const SharedMemoryCallbacks&, const Partitioner2::PartitionerConstPtr&, const Emulation::RiscOperatorsPtr&,
                      rose_addr_t memVa, const InstructionSemantics::BaseSemantics::SValuePtr&);
    virtual void runSharedMemoryPostCallbacks(const ExecutionEventPtr &sharedMemoryEvent, const Emulation::RiscOperatorsPtr&);

    void fixupSharedMemoryEvents(const ExecutionEventPtr &sharedMemoryEvent, const Emulation::RiscOperatorsPtr&);

    void printSharedMemoryEvents(const ExecutionEventPtr &sharedMemoryEvent, const Emulation::RiscOperatorsPtr&);

    virtual void sharedMemoryAccessPost(const Partitioner2::PartitionerConstPtr&, const Emulation::RiscOperatorsPtr&);
};

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

#endif
#endif