Concolic/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>
 
#include <string>
#include <vector>
 
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<Address> 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<Address> scratchVa() const;
    void scratchVa(const Sawyer::Optional<Address>&);
    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 MemoryMapPtr&, Address 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(Address va, size_t nBytes);
 
    virtual std::string readCString(Address va, size_t maxBytes = UNLIMITED);
 
    // Low-level functions controlling concrete execution.
public:
    virtual ByteOrder::Endianness memoryByteOrder() = 0;
 
    virtual Address ip();
    virtual void ip(Address);
    virtual void mapMemory(const AddressInterval &where, unsigned permissions);
 
    virtual void unmapMemory(const AddressInterval &where);
 
    virtual size_t writeMemory(Address startVa, const std::vector<uint8_t> &bytes);
 
    virtual std::vector<uint8_t> readMemory(Address 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&,
                     Address memVa, size_t nBytes);
    virtual bool
    sharedMemoryWrite(const SharedMemoryCallbacks&, const Partitioner2::PartitionerConstPtr&, const Emulation::RiscOperatorsPtr&,
                      Address 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