BinaryCallingConvention.h

Go to the documentation of this file.

#ifndef ROSE_BINARY_CALLCONV_H
#define ROSE_BINARY_CALLCONV_H

#include <cassert>
#include <vector>

class BinaryCallingConvention {


    /**************************************************************************************************************************
     *                                  Calling convention
     **************************************************************************************************************************/
public:

    class Convention {
    public:
        Convention(size_t wordsize, const std::string &name)
            : wordsize(wordsize), name(name),
              param_order(ORDER_UNKNOWN), this_location(THIS_UNKNOWN), retval_location(RETVAL_UNKNOWN), stack_alignment(0) {
            assert(wordsize>0);
            assert(!name.empty());
        }

    public:
        size_t get_wordsize() const { return wordsize; }
        void set_wordsize(size_t wordsize) { this->wordsize = wordsize; }
    private:
        size_t wordsize;

    public:
        const std::string& get_name() const { return name; }
        void set_name(const std::string &name) { this->name = name; }
    private:
        std::string name;

    public:
        const std::string &get_comment() const { return comment; }
        void set_comment(const std::string &comment) { this->comment = comment; }
    private:
        std::string comment;

    public:
        const std::vector<const RegisterDescriptor*>& get_reg_params() const { return reg_params; }
        void add_reg_param(const RegisterDescriptor *reg);
    private:
        std::vector<const RegisterDescriptor*> reg_params;

    public:
        enum ParameterOrder {
            ORDER_LTR,                      
            ORDER_RTL,                      
            ORDER_UNKNOWN,                  
        };
        ParameterOrder get_param_order() const { return param_order; }
        void set_param_order(ParameterOrder order) { param_order = order; }
    private:
        ParameterOrder param_order;

    public:
        enum ThisPointerLocation {
            THIS_FIRST_PARAM,               
            THIS_REGISTER,                  
            THIS_NOT_APPLICABLE,            
            THIS_UNKNOWN,                   
        };
        ThisPointerLocation get_this_location() const { return this_location; }
        void set_this_location(ThisPointerLocation loc) { this_location = loc; }
    private:
        ThisPointerLocation this_location;

    public:
        const RegisterDescriptor* get_this_register() const { return THIS_REGISTER==this_location ? this_reg : NULL; }
        void set_this_register(const RegisterDescriptor *reg) {
            this_location = THIS_REGISTER;
            this_reg = reg;
        }
    private:
        const RegisterDescriptor *this_reg;

    public:
        enum ReturnValueLocation {
            RETVAL_STACK,                      
            RETVAL_REGISTER,                   
            RETVAL_NOT_APPLICABLE,             
            RETVAL_UNKNOWN,                    
        };
        ReturnValueLocation get_retval_location() const { return retval_location; }
        void set_retval_location(ReturnValueLocation loc) { retval_location = loc; }
    private:
        ReturnValueLocation retval_location;


    public:
        const RegisterDescriptor* get_retval_register() const { return RETVAL_REGISTER==retval_location ? retval_reg : NULL; }
        void set_retval_register(const RegisterDescriptor *reg) {
            retval_location = RETVAL_REGISTER;
            retval_reg = reg;
        }
    private:
        const RegisterDescriptor *retval_reg;

    public:
        enum StackCleanup {
            CLEANUP_CALLER,                 
            CLEANUP_CALLEE,                 
            CLEANUP_NOT_APPLICABLE,         
            CLEANUP_UNKNOWN,                
        };
        StackCleanup get_stack_cleanup() const { return stack_cleanup; }
        void set_stack_cleanup(StackCleanup cleanup) { stack_cleanup = cleanup; }
    private:
        StackCleanup stack_cleanup;

    public:
        size_t get_stack_alignment() const { return stack_alignment; }
        void set_stack_alignment(size_t alignment) { stack_alignment = alignment; }
    private:
        size_t stack_alignment;
    };

    /**************************************************************************************************************************
     *                                  Dictionary of Calling Conventions
     **************************************************************************************************************************/
private:
    std::vector<const Convention*> cconvs;

public:
    void append(const Convention *cconv) { cconvs.push_back(cconv); }

    const Convention *find(size_t wordsize, const std::string &name, size_t *start_at=NULL);

    void erase(const Convention *conv);
    void erase(size_t index);
    void clear() { cconvs.clear(); }

    size_t size() { return cconvs.size(); }

    /**************************************************************************************************************************
     *                                  Analysis
     **************************************************************************************************************************/
public:
    BinaryCallingConvention::Convention *analyze_callee(SgAsmFunction*);

};

    
    
#endif


    

---