Definition.h

#ifndef ROSE_BinaryAnalysis_CallingConvention_Definition_H
#define ROSE_BinaryAnalysis_CallingConvention_Definition_H
#include <featureTests.h>
#ifdef ROSE_ENABLE_BINARY_ANALYSIS
#include <Rose/BinaryAnalysis/CallingConvention/BasicTypes.h>
 
#include <Rose/BinaryAnalysis/Architecture/BasicTypes.h>
#include <Rose/BinaryAnalysis/Alignment.h>
#include <Rose/BinaryAnalysis/ByteOrder.h>
#include <Rose/BinaryAnalysis/ConcreteLocation.h>
#include <Rose/BinaryAnalysis/RegisterDescriptor.h>
 
#include <Sawyer/Optional.h>
 
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
#include <boost/serialization/access.hpp>
#endif
 
#include <set>
#include <string>
#include <vector>
 
namespace Rose {
namespace BinaryAnalysis {
namespace CallingConvention {
 
class Definition: public Sawyer::SharedObject {
public:
    using Ptr = DefinitionPtr;
 
private:
    // General information
    std::string name_;                                  // Official short name of the convention, like "stdcall".
    std::string comment_;                               // Long name, like "Windows Borland x86-32 fastcall"
    Sawyer::Optional<size_t> bitsPerWord_;              // Optionally override the word width from the architecture
 
    // The architecture with which this calling convention definition is associated. It is referenced via weak pointer because the
    // architecture typically contains a list of calling convention definitions, so if we had referred here to the architecture with
    // a shared pointer we'd have a cycle. Architecture objects are typically not deleted since they're registered with the library.
    std::weak_ptr<const Architecture::Base> architecture_;
 
    // Used mostly during analysis
    std::vector<ConcreteLocation> nonParameterInputs_;  // Inputs that are not considered normal function parameters
    std::vector<ConcreteLocation> inputParameters_;     // Input (inc. in-out) parameters; additional stack-based are implied
    std::vector<ConcreteLocation> outputParameters_;    // Return values and output parameters.
    StackParameterOrder stackParameterOrder_ = StackParameterOrder::UNSPECIFIED; // Order of arguments on the stack
    RegisterDescriptor stackPointerRegister_;           // Optionally override the stack pointer register from the architecture
    size_t nonParameterStackSize_ = 0;                  // Size in bytes of non-parameter stack area
    Alignment stackAlignment_;                          // Stack alignment in bytes
    StackDirection stackDirection_ = StackDirection::GROWS_DOWN; // Direction that stack grows from a PUSH operation
    StackCleanup stackCleanup_ = StackCleanup::UNSPECIFIED;      // Who cleans up stack parameters?
    ConcreteLocation thisParameter_;                    // Object pointer for calling conventions that are object methods
    std::set<RegisterDescriptor> calleeSavedRegisters_; // Register that the callee must restore before returning
    std::set<RegisterDescriptor> scratchRegisters_;     // Caller-saved registers
    ConcreteLocation returnAddressLocation_;            // Where is the function return address stored at function entry?
    RegisterDescriptor instructionPointerRegister_;     // Where is the next instruction address stored?
 
    // These are used to figure out where function arguments and return values are stored given a function declaration. For
    // instance, the first two arguments that are 32 bits wide get stored in register 1 and register 2, and other arguments are
    // stored on the stack.
    AllocatorPtr returnValueAllocator_;
    AllocatorPtr argumentValueAllocator_;
 
protected:
#ifdef ROSE_ENABLE_BOOST_SERIALIZATION
    friend class boost::serialization::access;
    template<class S> void serialize(S&, unsigned);
#endif
 
    Definition();
 
    Definition(const std::string &name, const std::string &comment, const Architecture::BaseConstPtr&);
 
public:
    ~Definition();
 
public:
    static Ptr instance(const std::string &name, const std::string &comment, const Architecture::BaseConstPtr&);
 
public:
    Architecture::BaseConstPtr architecture() const;
 
    RegisterDictionaryPtr registerDictionary() const;
 
    const std::string& name() const { return name_; }
    void name(const std::string &s) { name_ = s; }
    const std::string& comment() const { return comment_; }
    void comment(const std::string &s) { comment_ = s; }
    size_t bitsPerWord() const;
    void bitsPerWord(const Sawyer::Optional<size_t>&);
    const std::vector<ConcreteLocation>& nonParameterInputs() const { return nonParameterInputs_; }
    std::vector<ConcreteLocation>& nonParameterInputs() { return nonParameterInputs_; }
    void clearParameters() {
        nonParameterInputs_.clear();
        clearInputParameters();
        clearOutputParameters();
        thisParameter_ = ConcreteLocation();
    }
 
    const std::vector<ConcreteLocation>& inputParameters() const { return inputParameters_; }
 
    RegisterParts inputRegisterParts() const;
 
    void clearInputParameters() { inputParameters_.clear(); }
 
    void appendInputParameter(const ConcreteLocation&);
    void appendInputParameter(RegisterDescriptor reg) {
        appendInputParameter(ConcreteLocation(reg));
    }
    void appendInputParameter(RegisterDescriptor reg, int64_t offset) {
        appendInputParameter(ConcreteLocation(reg, offset));
    }
    void appendInputParameter(Address va) {
        appendInputParameter(ConcreteLocation(va));
    }
    const std::vector<ConcreteLocation>& outputParameters() const { return outputParameters_; }
 
    RegisterParts outputRegisterParts() const;
 
    void clearOutputParameters() { outputParameters_.clear(); }
 
    void appendOutputParameter(const ConcreteLocation&);
    void appendOutputParameter(RegisterDescriptor reg) {
        appendOutputParameter(ConcreteLocation(reg));
    }
    void appendOutputParameter(RegisterDescriptor reg, int64_t offset) {
        appendOutputParameter(ConcreteLocation(reg, offset));
    }
    void appendOutputParameter(Address va) {
        appendOutputParameter(ConcreteLocation(va));
    }
    StackParameterOrder stackParameterOrder() const { return stackParameterOrder_; }
    void stackParameterOrder(StackParameterOrder x) { stackParameterOrder_ = x; }
    RegisterDescriptor stackPointerRegister() const;
    void stackPointerRegister(RegisterDescriptor);
    size_t nonParameterStackSize() const {
        return nonParameterStackSize_;
    }
    void nonParameterStackSize(size_t nBytes) {
        nonParameterStackSize_ = nBytes;
    }
    StackDirection stackDirection() const { return stackDirection_; }
    void stackDirection(StackDirection x) { stackDirection_ = x; }
    ByteOrder::Endianness byteOrder() const;
 
    StackCleanup stackCleanup() const { return stackCleanup_; }
    void stackCleanup(StackCleanup x) { stackCleanup_ = x; }
    const Alignment& stackAlignment() const;
    void stackAlignment(const Alignment&);
    const ConcreteLocation& thisParameter() const { return thisParameter_; }
    void thisParameter(const ConcreteLocation &x) { thisParameter_ = x; }
    void thisParameter(RegisterDescriptor reg) {
        thisParameter(ConcreteLocation(reg));
    }
    void thisParameter(RegisterDescriptor reg, int64_t offset) {
        thisParameter(ConcreteLocation(reg, offset));
    }
    void thisParameter(Address va) {
        thisParameter(ConcreteLocation(va));
    }
    const ConcreteLocation& returnAddressLocation() const { return returnAddressLocation_; }
    void returnAddressLocation(const ConcreteLocation &x) { returnAddressLocation_ = x; }
    RegisterDescriptor instructionPointerRegister() const { return instructionPointerRegister_; }
    void instructionPointerRegister(RegisterDescriptor x) { instructionPointerRegister_ = x; }
    const std::set<RegisterDescriptor>& calleeSavedRegisters() const { return calleeSavedRegisters_; }
    std::set<RegisterDescriptor>& calleeSavedRegisters() { return calleeSavedRegisters_; }
    RegisterParts calleeSavedRegisterParts() const;
 
    const std::set<RegisterDescriptor>& scratchRegisters() const { return scratchRegisters_; }
    std::set<RegisterDescriptor>& scratchRegisters() { return scratchRegisters_; }
    RegisterParts scratchRegisterParts() const;
 
    RegisterParts getUsedRegisterParts() const;
 
    AllocatorPtr returnValueAllocator() const;
    void returnValueAllocator(const AllocatorPtr&);
    AllocatorPtr argumentValueAllocator() const;
    void argumentValueAllocator(const AllocatorPtr&);
    void print(std::ostream&) const;
    void print(std::ostream&, const RegisterDictionaryPtr &regDict) const;
};
 
} // namespace
} // namespace
} // namespace
 
#endif
#endif