CallingConvention.h

#ifndef ROSE_BinaryAnalysis_CallingConvention_H
#define ROSE_BinaryAnalysis_CallingConvention_H
#include <featureTests.h>
#ifdef ROSE_ENABLE_BINARY_ANALYSIS

#include <Rose/BinaryAnalysis/BasicTypes.h>
#include <Rose/BinaryAnalysis/ConcreteLocation.h>
#include <Rose/BinaryAnalysis/Disassembler/BasicTypes.h>
#include <Rose/BinaryAnalysis/InstructionSemantics/BaseSemantics.h>
#include <Rose/BinaryAnalysis/Partitioner2/BasicTypes.h>
#include <Rose/BinaryAnalysis/RegisterParts.h>
#include <Rose/BinaryAnalysis/Variables.h>

#include <boost/serialization/access.hpp>
#include <boost/serialization/set.hpp>
#include <boost/serialization/string.hpp>
#include <boost/serialization/vector.hpp>
#include <boost/serialization/version.hpp>
#include <Sawyer/SharedObject.h>
#include <Sawyer/SharedPointer.h>

// Clean up global namespace pollution
#undef ABSOLUTE

namespace Rose {
namespace BinaryAnalysis {

// Forwards
namespace Disassembler {
class Base;
} // namespace

namespace CallingConvention {

void initDiagnostics();

extern Sawyer::Message::Facility mlog;

//                                      Miscellaneous small types

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,                                        
};

//                                      Definition

class Definition: public Sawyer::SharedObject {
public:
    using Ptr = DefinitionPtr;

private:
    std::string name_;                                  // Official short name of the convention, like "stdcall".
    std::string comment_;                               // Long name, like "Windows Borland x86-32 fastcall"
    size_t wordWidth_ = 0;                              // Natural width word size in bits
    RegisterDictionaryPtr regDict_;                     // Register dictionary used when this definition was created
    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_;           // Base pointer for implied stack parameters
    size_t nonParameterStackSize_ = 0;                  // Size in bytes of non-parameter stack area
    size_t stackAlignment_ = 0;                         // Stack alignment in bytes (zero means unknown)
    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?

#ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
private:
    friend class boost::serialization::access;

    template<class S>
    void serialize(S &s, const unsigned version) {
        s & BOOST_SERIALIZATION_NVP(name_);
        s & BOOST_SERIALIZATION_NVP(comment_);
        s & BOOST_SERIALIZATION_NVP(wordWidth_);
        s & BOOST_SERIALIZATION_NVP(regDict_);
        s & BOOST_SERIALIZATION_NVP(inputParameters_);
        s & BOOST_SERIALIZATION_NVP(outputParameters_);
        s & BOOST_SERIALIZATION_NVP(stackParameterOrder_);
        s & BOOST_SERIALIZATION_NVP(stackPointerRegister_);
        s & BOOST_SERIALIZATION_NVP(nonParameterStackSize_);
        s & BOOST_SERIALIZATION_NVP(stackAlignment_);
        s & BOOST_SERIALIZATION_NVP(stackDirection_);
        s & BOOST_SERIALIZATION_NVP(stackCleanup_);
        s & BOOST_SERIALIZATION_NVP(thisParameter_);
        s & BOOST_SERIALIZATION_NVP(calleeSavedRegisters_);
        s & BOOST_SERIALIZATION_NVP(scratchRegisters_);
        if (version >= 1) {
            s & BOOST_SERIALIZATION_NVP(returnAddressLocation_);
            s & BOOST_SERIALIZATION_NVP(instructionPointerRegister_);
        }
    }
#endif
    
protected:
    Definition();

    Definition(size_t wordWidth, const std::string &name, const std::string &comment, const RegisterDictionaryPtr&);

public:
    ~Definition();

public:
    static Ptr instance(size_t wordWidth, const std::string &name, const std::string &comment, const RegisterDictionaryPtr &regs) {
        return Ptr(new Definition(wordWidth, name, comment, regs));
    }

public:
    static Ptr x86_32bit_cdecl();
    static Ptr x86_64bit_cdecl();
    static Ptr x86_32bit_stdcall();
    static Ptr x86_64bit_stdcall();
    static Ptr x86_32bit_fastcall();
    static Ptr x86_64bit_sysv();
    static Ptr ppc_32bit_ibm();
    static Ptr x86_cdecl(const RegisterDictionaryPtr&);
    static Ptr x86_stdcall(const RegisterDictionaryPtr&);
    static Ptr x86_fastcall(const RegisterDictionaryPtr&);
    static Ptr ppc_ibm(const RegisterDictionaryPtr&);
    RegisterDictionaryPtr registerDictionary() const;
    void registerDictionary(const RegisterDictionaryPtr &d);
    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 wordWidth() const { return wordWidth_; }
    void wordWidth(size_t nBits) {
        ASSERT_require2(nBits > 0 && 0 == (nBits & 7), "word size must be a positive multiple of eight");
        wordWidth_ = nBits;
    }
    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(rose_addr_t 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(rose_addr_t va) {
        appendOutputParameter(ConcreteLocation(va));
    }
    StackParameterOrder stackParameterOrder() const { return stackParameterOrder_; }
    void stackParameterOrder(StackParameterOrder x) { stackParameterOrder_ = x; }
    const RegisterDescriptor stackPointerRegister() const { return stackPointerRegister_; }
    void stackPointerRegister(RegisterDescriptor r) { stackPointerRegister_ = r; }
    size_t nonParameterStackSize() const {
        return nonParameterStackSize_;
    }
    void nonParameterStackSize(size_t nBytes) {
        nonParameterStackSize_ = nBytes;
    }    
    StackDirection stackDirection() const { return stackDirection_; }
    void stackDirection(StackDirection x) { stackDirection_ = x; }
    StackCleanup stackCleanup() const { return stackCleanup_; }
    void stackCleanup(StackCleanup x) { stackCleanup_ = x; }
    size_t stackAlignment() const { return stackAlignment_; }
    void stackAlignment(size_t nBytes) { stackAlignment_ = nBytes; }
    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(rose_addr_t 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;

    void print(std::ostream&) const;
    void print(std::ostream&, const RegisterDictionaryPtr &regDict) const;
};


//                                      Dictionary

typedef std::vector<Definition::Ptr> Dictionary;

const Dictionary& dictionaryAmd64();

const Dictionary& dictionaryAarch32();

const Dictionary& dictionaryAarch64();

const Dictionary& dictionaryM68k();

const Dictionary& dictionaryMips();

const Dictionary& dictionaryPowerpc32();

const Dictionary& dictionaryPowerpc64();

const Dictionary& dictionaryX86();


//                                      Analysis

class Analysis {
private:
    InstructionSemantics::BaseSemantics::DispatcherPtr cpu_;
    RegisterDictionaryPtr regDict_;                     // Names for the register parts
    Definition::Ptr defaultCc_;                         // Default calling convention for called functions

    bool hasResults_;                                   // Are the following data members initialized?
    bool didConverge_;                                  // Are the following data members valid (else only approximations)?
    RegisterParts restoredRegisters_;                   // Registers accessed but restored
    RegisterParts inputRegisters_;                      // Registers that serve as possible input parameters
    RegisterParts outputRegisters_;                     // Registers that hold possible return values
    Variables::StackVariables inputStackParameters_;    // Stack variables serving as function inputs
    Variables::StackVariables outputStackParameters_;   // Stack variables serving as possible return values
    Sawyer::Optional<int64_t> stackDelta_;              // Change in stack across entire function
    // Don't forget to update clearResults() and serialize() if you add more.

#ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
private:
    friend class boost::serialization::access;

    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        s & BOOST_SERIALIZATION_NVP(cpu_);
        s & BOOST_SERIALIZATION_NVP(regDict_);
        s & BOOST_SERIALIZATION_NVP(defaultCc_);
        s & BOOST_SERIALIZATION_NVP(hasResults_);
        s & BOOST_SERIALIZATION_NVP(didConverge_);
        s & BOOST_SERIALIZATION_NVP(restoredRegisters_);
        s & BOOST_SERIALIZATION_NVP(inputRegisters_);
        s & BOOST_SERIALIZATION_NVP(outputRegisters_);
        s & BOOST_SERIALIZATION_NVP(inputStackParameters_);
        s & BOOST_SERIALIZATION_NVP(outputStackParameters_);
        s & BOOST_SERIALIZATION_NVP(stackDelta_);
    }
#endif

public:
    Analysis();
    ~Analysis();

    explicit Analysis(const Disassembler::BasePtr&);

    explicit Analysis(const InstructionSemantics::BaseSemantics::DispatcherPtr&);

    Definition::Ptr defaultCallingConvention() const { return defaultCc_; }
    void defaultCallingConvention(const Definition::Ptr &x) { defaultCc_ = x; }
    void analyzeFunction(const Partitioner2::PartitionerConstPtr&, const Sawyer::SharedPointer<Partitioner2::Function>&);

    bool hasResults() const { return hasResults_; }

    bool didConverge() const { return didConverge_; }

    void clearResults();

    void clearNonResults();

    RegisterDictionaryPtr registerDictionary() const;
    void registerDictionary(const RegisterDictionaryPtr &d);
    const RegisterParts& calleeSavedRegisters() const { return restoredRegisters_; }

    const RegisterParts& inputRegisters() const { return inputRegisters_; }

    const RegisterParts& outputRegisters() const { return outputRegisters_; }

    const Variables::StackVariables& inputStackParameters() const { return inputStackParameters_; }

    const Variables::StackVariables& outputStackParameters() const { return outputStackParameters_; }

    Sawyer::Optional<int64_t> stackDelta() const { return stackDelta_; }

    bool match(const Definition::Ptr&) const;

    Dictionary match(const Dictionary&) const;

    void print(std::ostream&, bool multiLine=false) const;

private:
    // Finish constructing
    void init(const Disassembler::BasePtr&);

    // Recompute the restoredRegisters_ data member.
    void updateRestoredRegisters(const InstructionSemantics::BaseSemantics::StatePtr &initialState,
                                 const InstructionSemantics::BaseSemantics::StatePtr &finalState);

    // Recompute the inputRegisters_ data member after updateRestoredRegisters is computed.
    void updateInputRegisters(const InstructionSemantics::BaseSemantics::StatePtr &state);

    // Recompute the outputRegisters_ data member after updateRestoredRegisters is computed.
    void updateOutputRegisters(const InstructionSemantics::BaseSemantics::StatePtr &state);

    // Recompute the input and output stack variables
    void updateStackParameters(const Partitioner2::FunctionPtr &function,
                               const InstructionSemantics::BaseSemantics::StatePtr &initialState,
                               const InstructionSemantics::BaseSemantics::StatePtr &finalState);

    // Recomputes the stack delta
    void updateStackDelta(const InstructionSemantics::BaseSemantics::StatePtr &initialState,
                          const InstructionSemantics::BaseSemantics::StatePtr &finalState);
};

//                                      Free functions

InstructionSemantics::BaseSemantics::SValuePtr
readArgument(const InstructionSemantics::BaseSemantics::RiscOperatorsPtr&, const Definition::Ptr&, size_t argNumber);

void writeArgument(const InstructionSemantics::BaseSemantics::RiscOperatorsPtr&, const Definition::Ptr&,
                   size_t argNumber, const InstructionSemantics::BaseSemantics::SValuePtr &value);

InstructionSemantics::BaseSemantics::SValuePtr
readReturnValue(const InstructionSemantics::BaseSemantics::RiscOperatorsPtr&, const Definition::Ptr&);

void writeReturnValue(const InstructionSemantics::BaseSemantics::RiscOperatorsPtr&, const Definition::Ptr&,
                      const InstructionSemantics::BaseSemantics::SValuePtr &returnValue);

void simulateFunctionReturn(const InstructionSemantics::BaseSemantics::RiscOperatorsPtr&, const Definition::Ptr&);

std::ostream& operator<<(std::ostream&, const Definition&);

std::ostream& operator<<(std::ostream&, const Analysis&);

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

// Class versions must be at global scope
BOOST_CLASS_VERSION(Rose::BinaryAnalysis::CallingConvention::Definition, 1);

#endif
#endif