Rose/BinaryAnalysis/Concolic/BasicTypes.h

#ifndef ROSE_BinaryAnalysis_Concolic_BasicTypes_H
#define ROSE_BinaryAnalysis_Concolic_BasicTypes_H
#include <featureTests.h>
#ifdef ROSE_ENABLE_CONCOLIC_TESTING
 
// Subdirectory/subnamespace #include's are at the *end* of this file.
#include <Rose/BinaryAnalysis/BasicTypes.h>
#include <Rose/StringUtility/Escape.h>
 
#include <Rose/Exception.h>
#include <rose_strtoull.h>
 
#include <Sawyer/Callbacks.h>
#include <Sawyer/Message.h>
#include <Sawyer/SharedPointer.h>
 
#include <boost/shared_ptr.hpp>
#include <memory>
 
namespace Rose {
namespace BinaryAnalysis {
namespace Concolic {
 
// Flags and enums
 
enum class Update { NO, YES };
 
enum class ShowEvents {
    NONE,                                               
    INPUT,                                              
    ALL                                                 
};
 
enum class ShowAssertions { NO, YES };
 
enum class InputType {
    NONE,                                               
    ARGC,                                               
    ARGV,                                               
    ENVP,                                               
    SYSCALL_RET,                                        
    SHMEM_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 () {}
};
 
bool isRunningInContainer();
 
std::string toString(const SymbolicExpressionPtr&, SymbolicExpression::Formatter&);
std::string toString(const SymbolicExpressionPtr&);
std::string toString(uint64_t value, size_t nBits);
// Forward references
 
class Architecture;
using ArchitecturePtr = Sawyer::SharedPointer<Architecture>;
 
class ConcolicExecutor;
using ConcolicExecutorPtr = Sawyer::SharedPointer<ConcolicExecutor>;
 
class ConcolicExecutorSettings;
 
class ConcreteExecutor;
using ConcreteExecutorPtr = Sawyer::SharedPointer<ConcreteExecutor>;
 
class ConcreteResult;
using ConcreteResultPtr = Sawyer::SharedPointer<ConcreteResult>;
 
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;
using InputVariablesPtr = Sawyer::SharedPointer<InputVariables>;
 
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>;
 
// 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
 
// #include's for subdirectories
#include <Rose/BinaryAnalysis/Concolic/Callback/BasicTypes.h>
#include <Rose/BinaryAnalysis/Concolic/I386Linux/BasicTypes.h>
#include <Rose/BinaryAnalysis/Concolic/M68kSystem/BasicTypes.h>
 
#endif