ExecutionEvent.h

#ifndef ROSE_BinaryAnalysis_Concolic_ExecutionEvent_H
#define ROSE_BinaryAnalysis_Concolic_ExecutionEvent_H
#include <featureTests.h>
#ifdef ROSE_ENABLE_CONCOLIC_TESTING
 
#include <Rose/BinaryAnalysis/Concolic/BasicTypes.h>
#include <Rose/BinaryAnalysis/Concolic/Database.h>
#include <Rose/BinaryAnalysis/Concolic/ExecutionLocation.h>
#include <Rose/BinaryAnalysis/SymbolicExpression.h>
#include <Combinatorics.h>                              // rose
 
namespace Rose {
namespace BinaryAnalysis {
namespace Concolic {
 
class ExecutionEvent: public Sawyer::SharedObject, public Sawyer::SharedFromThis<ExecutionEvent> {
public:
    using Ptr = ExecutionEventPtr;
 
    enum class Action {
        NONE,
 
        BULK_MEMORY_MAP,
 
        BULK_MEMORY_UNMAP,
 
        BULK_MEMORY_WRITE,
 
        BULK_MEMORY_HASH,
 
        MEMORY_WRITE,
 
        BULK_REGISTER_WRITE,
 
        REGISTER_WRITE,
 
        OS_SYSCALL,
 
        OS_SHARED_MEMORY
    };
 
private:
    // These are the data members that get read/written to the database.  The API properties defined for the various event
    // types are not necessarily a 1:1 mapping to these data members.
 
    // Event identification data members
    std::string timestamp_;                             // time of creation, needed by the database
    TestCasePtr testCase_;                              // each event belongs to a particular test case
    std::string name_;                                  // optional name for debugging
    ExecutionLocation location_;                        // location event occurs
    Address ip_ = 0;                                    // address of instruction associated with event
 
    // These data members map to properties, but not necessarily 1:1. It's done this way for efficiency in the database.
    Action action_ = Action::NONE;                      // type of action
    AddressInterval memoryVas_;                         // affected memory
    unsigned u_ = 0;                                    // permission bits, register, or syscall function number
    std::vector<uint8_t> bytes_;                        // byte data, hash digest, or syscall arguments
    SymbolicExpressionPtr variable_, value_, expression_; // for computing concrete result from input
    InputType inputType_ = InputType::NONE;             // what kind of input is variable_?
    size_t idx1_ = INVALID_INDEX;                       // indices for the input type, such as argv[i][j]
    size_t idx2_ = INVALID_INDEX;
 
protected:
    ExecutionEvent();
public:
    ~ExecutionEvent();
 
public:
    // Event constructors. These have camelCase names identical to the action.
 
    Ptr copy() const;
 
    static Ptr instance();
 
    static Ptr noAction(const TestCasePtr&, const ExecutionLocation&, Address ip);
 
 
    static Ptr bulkMemoryMap(const TestCasePtr&, const ExecutionLocation&, Address ip,
                             const AddressInterval &where, unsigned permissions);
 
    static Ptr bulkMemoryUnmap(const TestCasePtr&, const ExecutionLocation&, Address ip,
                               const AddressInterval &where);
 
    static Ptr bulkMemoryWrite(const TestCasePtr&, const ExecutionLocation&, Address ip,
                               const AddressInterval &where, const std::vector<uint8_t> &bytes);
 
    static Ptr bulkMemoryHash(const TestCasePtr&, const ExecutionLocation&, Address ip,
                              const AddressInterval &where, const Combinatorics::Hasher::Digest&);
 
    static Ptr memoryWrite(const TestCasePtr&, const ExecutionLocation&, Address ip,
                           const AddressInterval &where, const SymbolicExpressionPtr &variable,
                           const SymbolicExpressionPtr &value, const SymbolicExpressionPtr &expression);
 
    static Ptr bulkRegisterWrite(const TestCasePtr&, const ExecutionLocation&, Address ip,
                                 const Sawyer::Container::BitVector&);
 
    static Ptr registerWrite(const TestCasePtr&, const ExecutionLocation&, Address ip,
                             RegisterDescriptor where, const SymbolicExpressionPtr &variable,
                             const SymbolicExpressionPtr &value, const SymbolicExpressionPtr &expression);
 
    static Ptr osSyscall(const TestCasePtr&, const ExecutionLocation&, Address ip,
                         unsigned function, const std::vector<uint64_t> &arguments);
 
    static Ptr osSharedMemory(const TestCasePtr&, const ExecutionLocation&, Address ip,
                              const AddressInterval &where, const SymbolicExpressionPtr &variable,
                              const SymbolicExpressionPtr &value, const SymbolicExpressionPtr &expression);
 
    // Properties that are used by all event types.
 
    TestCasePtr testCase() const;
    void testCase(const TestCasePtr&);
    const std::string& timestamp() const;
    void timestamp(const std::string&);
    std::string name() const;
    void name(const std::string&);
    ExecutionLocation location() const;
    void location(const ExecutionLocation&);
    Address instructionPointer() const;
    void instructionPointer(Address);
    Action action() const;
    void action(Action);
    // Properties specific to certain types of events.
 
    AddressInterval memoryLocation() const;
    void memoryLocation(const AddressInterval&);
    RegisterDescriptor registerDescriptor() const;
    void registerDescriptor(RegisterDescriptor);
    unsigned permissions() const;
    void permissions(unsigned);
    const std::vector<uint8_t>& bytes() const;
    void bytes(const std::vector<uint8_t>&);
    Sawyer::Container::BitVector registerValues() const;
    void registerValues(const Sawyer::Container::BitVector&);
    const Combinatorics::Hasher::Digest& hash() const;
    void hash(const Combinatorics::Hasher::Digest&);
    SymbolicExpressionPtr variable() const;
    void variable(const SymbolicExpressionPtr&);
    SymbolicExpressionPtr value() const;
    void value(const SymbolicExpressionPtr&);
    SymbolicExpressionPtr expression() const;
    void expression(const SymbolicExpressionPtr&);
    unsigned syscallFunction() const;
    void syscallFunction(unsigned);
    std::vector<uint64_t> syscallArguments() const;
    void syscallArguments(const std::vector<uint64_t>&);
    // Properties related to test case input variables.
 
    InputType inputType() const;
    void inputType(InputType, size_t idx1, size_t idx2);
    std::pair<size_t, size_t> inputIndices() const;
    // Actions valid for all events
 
    SymbolicExpressionPtr inputVariable() const;
 
    // Actions defined for some event types.
 
 
    SymbolicExpressionPtr calculateResult(const SymbolicExpression::ExprExprHashMap &bindings) const;
 
    std::string printableName(const DatabasePtr &db = DatabasePtr());
 
    void toYaml(std::ostream&, const DatabasePtr&, std::string prefix);
 
    // Database operations
private:
    friend class DatabaseAccess;
 
    // Recreate the table for storing execution events. Is only called from the database layer.
    static void recreateTable(Sawyer::Database::Connection);
 
    // Save this object to the database. Is only called from the database layer.
    void toDatabase(const DatabasePtr&, ExecutionEventId);
 
    // Restore this object from the database. Is only called from the database layer.
    void fromDatabase(const DatabasePtr&, ExecutionEventId);
};
 
} // namespace
} // namespace
} // namespace
 
#endif
#endif