BasicTypes.h

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

#include <rose_strtoull.h>
#include <memory>

namespace Rose {
namespace BinaryAnalysis {
namespace Concolic {

// Flags and enums

enum class Update { NO, YES };

enum class ShowEvents { NO, YES };

enum class ShowAssertions { NO, YES };

enum class InputType {
    NONE,                                               
    PROGRAM_ARGUMENT_COUNT,                             
    PROGRAM_ARGUMENT,                                   
    ENVIRONMENT,                                        
    SYSTEM_CALL_RETVAL,                                 
    SHARED_MEMORY_READ                                  
};

enum class IoDirection {
    READ,                                               
    WRITE                                               
};

enum class When {
    PRE,                                                
    POST                                                
};

enum class ConcolicPhase {
    REPLAY,                                             
    EMULATION,                                          
    POST_EMULATION                                      
};

// Exceptions, errors, etc.

extern Sawyer::Message::Facility mlog;

// Internal: called by Rose::Diagnostics::initialize
void initDiagnostics();

class Exception: public Rose::Exception {
public:
    explicit Exception(const std::string &mesg): Rose::Exception(mesg) {}
    ~Exception() throw () {}
};

// Forward references

class Architecture;
using ArchitecturePtr = Sawyer::SharedPointer<Architecture>;

class ConcolicExecutor;
using ConcolicExecutorPtr = Sawyer::SharedPointer<ConcolicExecutor>;

class ConcreteExecutor;
using ConcreteExecutorPtr = Sawyer::SharedPointer<ConcreteExecutor>;
class ConcreteExecutorResult;

class Database;
using DatabasePtr = Sawyer::SharedPointer<Database>;

namespace Emulation {
    class RiscOperators;
    using RiscOperatorsPtr = boost::shared_ptr<class RiscOperators>;
}

class ExecutionEvent;
using ExecutionEventPtr = Sawyer::SharedPointer<ExecutionEvent>;

class ExecutionLocation;

class ExecutionManager;
using ExecutionManagerPtr = Sawyer::SharedPointer<ExecutionManager>;

class InputVariables;

class LinuxExecutor;
using LinuxExecutorPtr = Sawyer::SharedPointer<LinuxExecutor>;

class LinuxI386;
using LinuxI386Ptr = Sawyer::SharedPointer<LinuxI386>;

class SharedMemoryCallback;
using SharedMemoryCallbackPtr = Sawyer::SharedPointer<SharedMemoryCallback>;

using SharedMemoryCallbacks = Sawyer::Callbacks<SharedMemoryCallbackPtr>;

class SharedMemoryContext;

class Specimen;
using SpecimenPtr = Sawyer::SharedPointer<Specimen>;

class SyscallCallback;
using SyscallCallbackPtr = std::shared_ptr<SyscallCallback>;

using SyscallCallbacks = Sawyer::Callbacks<SyscallCallbackPtr>;

class SyscallContext;

class TestCase;
using TestCasePtr = Sawyer::SharedPointer<TestCase>;

class TestSuite;
using TestSuitePtr = Sawyer::SharedPointer<TestSuite>;

class LinuxExitStatus;
using LinuxExitStatusPtr = Sawyer::SharedPointer<LinuxExitStatus>;

// Database

template <class Tag>
class ObjectId: public Sawyer::Optional<size_t> {
public:
    using Value = size_t;                               
    using Super = Sawyer::Optional<Value>;              
    using Object = Tag;                                 
    using Pointer = Sawyer::SharedPointer<Tag>;         
    ObjectId() {}

    explicit
    ObjectId(const Value& v)
        : Super(v) {}

    ObjectId(const ObjectId& rhs)
        : Super(rhs) {}

    explicit ObjectId(const Sawyer::Optional<size_t> &id)
        : Super(id) {}

    explicit ObjectId(const std::string &s) {
        char *rest = NULL;
        uint64_t id = rose_strtoull(s.c_str(), &rest, 0);
        while (*rest && isspace(*rest)) ++rest;
        if (*rest)
            throw Exception("invalid syntax for object ID: \"" + StringUtility::cEscape(s) + "\"");
        try {
            *this = boost::numeric_cast<Value>(id);
        } catch (const boost::bad_numeric_cast&) {
            throw Exception("parsed object ID out of range: \"" + StringUtility::cEscape(s) + "\"");
        }
    }

    ObjectId<Tag>& operator=(const ObjectId<Tag>& lhs) {
        this->Super::operator=(lhs);
        return *this;
    }

    ObjectId<Tag>& operator=(const Value& v) {
        this->Super::operator=(v);
        return *this;
    }

    explicit operator bool() const {                    // because it's not explicit in the super class due to C++03 support
        return isEqual(Sawyer::Nothing()) ? false : true;
    }

    template<class _Tag>
    friend
    bool operator<(const ObjectId<_Tag>& lhs, const ObjectId<_Tag>& rhs);

    // Useful for database operations
    const Super& optional() const {
        return *this;
    }
};

template<class Tag>
inline
bool operator<(const ObjectId<Tag>& lhs, const ObjectId<Tag>& rhs)
{
    if (!rhs) return false;
    if (!lhs) return true;

    return lhs.get() < rhs.get();
}

using TestSuiteId = ObjectId<TestSuite>;                
using SpecimenId = ObjectId<Specimen>;                  
using TestCaseId = ObjectId<TestCase>;                  
using ExecutionEventId = ObjectId<ExecutionEvent>;      
template<class T>
struct ObjectTraits {
    using Id = void;
};

template<>
struct ObjectTraits<TestSuite> {
    using Id = TestSuiteId;
};

template<>
struct ObjectTraits<Specimen> {
    using Id = SpecimenId;
};

template<>
struct ObjectTraits<TestCase> {
    using Id = TestCaseId;
};

template<>
struct ObjectTraits<ExecutionEvent> {
    using Id = ExecutionEventId;
};

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

#endif
#endif