Rose/BinaryAnalysis/CallingConvention/BasicTypes.h

#ifndef ROSE_BinaryAnalysis_CallingConvention_BasicTypes_H
#define ROSE_BinaryAnalysis_CallingConvention_BasicTypes_H
#include <featureTests.h>
#ifdef ROSE_ENABLE_BINARY_ANALYSIS
 
#include <Rose/BinaryAnalysis/InstructionSemantics/BaseSemantics/BasicTypes.h>
 
#include <Sawyer/Message.h>
 
#include <vector>
 
namespace Rose {
namespace BinaryAnalysis {
namespace CallingConvention {
 
void initDiagnostics();
 
extern Sawyer::Message::Facility mlog;
 
enum class StackParameterOrder {
    LEFT_TO_RIGHT,                                      
    RIGHT_TO_LEFT,                                      
    UNSPECIFIED,                                        
};
 
enum class StackDirection {
    GROWS_UP,                                           
    GROWS_DOWN,                                         
};
 
enum class StackCleanup {
    BY_CALLER,                                          
    BY_CALLEE,                                          
    UNSPECIFIED,                                        
};
 
class Allocator;
 
using AllocatorPtr = std::shared_ptr<Allocator>;
using AllocatorConstPtr = std::shared_ptr<const Allocator>;
class Analysis;
 
using AnalysisPtr = Sawyer::SharedPointer<Analysis>;
 
class Declaration;
 
using DeclarationPtr = Sawyer::SharedPointer<Declaration>;
 
class Definition;
 
using DefinitionPtr = Sawyer::SharedPointer<Definition>;
 
using Dictionary = std::vector<DefinitionPtr>;
 
class StoragePoolBase;
 
using StoragePoolBasePtr = std::shared_ptr<StoragePoolBase>;
using StoragePoolBaseConstPtr = std::shared_ptr<const StoragePoolBase>;
class StoragePoolEnumerated;
 
using StoragePoolEnumeratedPtr = std::shared_ptr<StoragePoolEnumerated>;
using StoragePoolEnumeratedConstPtr = std::shared_ptr<const StoragePoolEnumerated>;
class StoragePoolStack;
 
using StoragePoolStackPtr = std::shared_ptr<StoragePoolStack>;
using StoragePoolStackConstPtr = std::shared_ptr<const StoragePoolStack>;
class TypePredicate;
 
using TypePredicatePtr = std::shared_ptr<TypePredicate>;
using TypePredicateConstPtr = std::shared_ptr<const TypePredicate>;
//                                      Free functions
 
InstructionSemantics::BaseSemantics::SValuePtr
readArgument(const InstructionSemantics::BaseSemantics::RiscOperatorsPtr&, const DefinitionPtr&, size_t argNumber);
 
void writeArgument(const InstructionSemantics::BaseSemantics::RiscOperatorsPtr&, const DefinitionPtr&,
                   size_t argNumber, const InstructionSemantics::BaseSemantics::SValuePtr &value);
 
InstructionSemantics::BaseSemantics::SValuePtr
readReturnValue(const InstructionSemantics::BaseSemantics::RiscOperatorsPtr&, const DefinitionPtr&);
 
void writeReturnValue(const InstructionSemantics::BaseSemantics::RiscOperatorsPtr&, const DefinitionPtr&,
                      const InstructionSemantics::BaseSemantics::SValuePtr &returnValue);
 
void simulateFunctionReturn(const InstructionSemantics::BaseSemantics::RiscOperatorsPtr&, const DefinitionPtr&);
 
std::ostream& operator<<(std::ostream&, const Definition&);
 
std::ostream& operator<<(std::ostream&, const Analysis&);
 
} // namespace
} // namespace
} // namespace
 
#endif
#endif