Rose/BinaryAnalysis/InstructionSemantics/BaseSemantics/BasicTypes.h

#ifndef ROSE_BinaryAnalysis_InstructionSemantics_BaseSemantics_BasicTypes_H
#define ROSE_BinaryAnalysis_InstructionSemantics_BaseSemantics_BasicTypes_H
#include <featureTests.h>
#ifdef ROSE_ENABLE_BINARY_ANALYSIS
#include <RoseFirst.h>
 
// Basic types needed by almost all other instruction semantics layers
 
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
#include <boost/serialization/shared_ptr.hpp>
#endif
 
#include <boost/shared_ptr.hpp>
#include <Sawyer/SharedPointer.h>
#include <Sawyer/Set.h>
 
namespace Rose {
namespace BinaryAnalysis {
namespace InstructionSemantics {
 
namespace BaseSemantics {
 
// Forward declarations
 
// Documented where they're defined.
class AddressSpace;
class AddressSpaceAddress;
class Dispatcher;
class FrameState;
class Formatter;
class MemoryCell;
class MemoryState;
class Merger;
class RegisterState;
class RegisterStateGeneric;
class RiscOperators;
class State;
class SValue;
 
// Shared-ownership pointers
 
using AddressSpacePtr = boost::shared_ptr<AddressSpace>;
 
typedef Sawyer::SharedPointer<Merger> MergerPtr;
 
typedef Sawyer::SharedPointer<SValue> SValuePtr;
 
typedef boost::shared_ptr<RegisterState> RegisterStatePtr;
 
typedef boost::shared_ptr<class RegisterStateGeneric> RegisterStateGenericPtr;
 
typedef boost::shared_ptr<MemoryState> MemoryStatePtr;
 
typedef boost::shared_ptr<MemoryCell> MemoryCellPtr;
 
typedef boost::shared_ptr<State> StatePtr;
 
typedef boost::shared_ptr<class MemoryCellState> MemoryCellStatePtr;
 
typedef boost::shared_ptr<FrameState> FrameStatePtr;
 
typedef boost::shared_ptr<RiscOperators> RiscOperatorsPtr;
 
typedef boost::shared_ptr<Dispatcher> DispatcherPtr;
 
// Enums
 
enum class AddressSpacePurpose {
    REGISTERS,                                          
    MEMORY,                                             
    INTERRUPTS,                                         
    FRAMES,                                             
    USER,                                               
    UNSPECIFIED                                         
};
 
enum InputOutputProperty {
    IO_READ,                                            
    IO_WRITE,                                           
    IO_INIT,                                            
    IO_READ_BEFORE_WRITE,                               
    IO_READ_AFTER_WRITE,                                
    IO_READ_UNINITIALIZED,                              
};
 
typedef Sawyer::Container::Set<InputOutputProperty> InputOutputPropertySet;
 
 
} // namespace
} // namespace
} // namespace
} // namespace
 
#endif
#endif