/*

 * Copyright (C) 2007, 2008  Campanoni Simone, Anelli Stefano

 *

 * iljit - This is a Just-in-time for the CIL language specified with the ECMA-335

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 2 of the License, or

 * (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 */

 

#ifndef IRSPECIALIZER_H

#define IRSPECIALIZER_H

 

/* Generic include */

#include <xanlib.h>

#include <pthread.h>

 

/* iljit include */

#include <jitsystem.h>

#include <ir_method.h>

 

// My include

#include <irprofiler.h>

// End

 

/* ----------------------------------------- Constant Common Values -----------------------------------------*/

#undef SPECIALIZE_EVERY_METHOD  /* Define this if you want to specialize each method */

#define SPECIALIZE_EVERY_METHOD 

 

#undef FULLMODE_PRINTDEBUG

//#define FULLMODE_PRINTDEBUG

 

#ifdef FULLMODE_PRINTDEBUG

#       define FMODEPRINT(fmt, args...) fprintf(stderr, fmt, ## args)

#else

#       define FMODEPRINT(fmt, args...)

#endif

 

/* ----------------------------------------- Constant Common Values -----------------------------------------*/

#ifdef SPECIALIZE_EVERY_METHOD

        #define SPECIALIZER_EVERY_METHOD_FACTOR                         specializer_fullspecialization_counter

        #define SPECIALIZER_ZERO_PROFILER_MEMORY_SIZE                   (SPECIALIZER_EVERY_METHOD_FACTOR * sizeof(JITUINT32))

        #define SEPCIALIZER_ZERO_PROFILER_THRESHOLD                     0.3

        #define SEPCIALIZER_ZERO_DISPATCHER_REMOVE_THRESHOLD            SPECIALIZER_EVERY_METHOD_FACTOR

        #define SPECIALIZER_FIRST_PROFILER_THRESHOLD                    2

        #define SPECIALIZER_SECOND_PROFILER_MEMORY_SIZE                 (SPECIALIZER_EVERY_METHOD_FACTOR*sizeof(JITFLOAT64))

        #define SPECIALIZER_SECOND_PROFILER_STATIC_THRESHOLD            0.3

        #define SPECIALIZER_DISPATCHER_REMOVE_THRESHOLD                 SPECIALIZER_EVERY_METHOD_FACTOR

#else

        #define SPECIALIZER_ZERO_PROFILER_MEMORY_SIZE                   (100 * sizeof(JITUINT32) - 1)

        #define SEPCIALIZER_ZERO_PROFILER_THRESHOLD                     0.3

        #define SEPCIALIZER_ZERO_DISPATCHER_REMOVE_THRESHOLD            50

        #define SPECIALIZER_FIRST_PROFILER_THRESHOLD                    100

        #define SPECIALIZER_SECOND_PROFILER_MEMORY_SIZE                 1024

        #define SPECIALIZER_SECOND_PROFILER_STATIC_THRESHOLD            0.3

        #define SPECIALIZER_DISPATCHER_REMOVE_THRESHOLD                 50

#endif

 

/**

 * Possible actions for a given expression

 */

#define SPECIALIZER_ACTION_STATIC                               0

#define SPECIALIZER_ACTION_STATIC_STR                           "STATIC"

#define SPECIALIZER_ACTION_STATIC_LENGTH                        1

#define SPECIALIZER_ACTION_STATIC_LENGTH_STR                    "LENGTH"

#define SPECIALIZER_ACTION_STATIC_EQ                            2

#define SPECIALIZER_ACTION_STATIC_EQ_STR                        "EQ"

#define SPECIALIZER_ACTION_STATIC_EQF                           3

#define SPECIALIZER_ACTION_STATIC_EQF_STR                       "EQF"

#define SPECIALIZER_ACTION_STATIC_LESS                          4

#define SPECIALIZER_ACTION_STATIC_LESS_STR                      "LESS"

#define SPECIALIZER_ACTION_STATIC_LESSF                         5

#define SPECIALIZER_ACTION_STATIC_LESSF_STR                     "LESSF"

#define SPECIALIZER_ACTION_STATIC_GREAT                         6

#define SPECIALIZER_ACTION_STATIC_GREAT_STR                     "GREAT"

#define SPECIALIZER_ACTION_STATIC_GREATF                        7

#define SPECIALIZER_ACTION_STATIC_GREATF_STR                    "GREATF"

#define SPECIALIZER_ACTION_STATIC_LESSEQ                        8

#define SPECIALIZER_ACTION_STATIC_LESSEQ_STR                    "LE"

#define SPECIALIZER_ACTION_STATIC_LESSEQF                       9

#define SPECIALIZER_ACTION_STATIC_LESSEQF_STR                   "LEF"

#define SPECIALIZER_ACTION_STATIC_GREATEQ                       10

#define SPECIALIZER_ACTION_STATIC_GREATEQ_STR                   "GE"

#define SPECIALIZER_ACTION_STATIC_GREATEQF                      11

#define SPECIALIZER_ACTION_STATIC_GREATEQF_STR                  "GEF"

 

/*

 * These are all the possible states for a call site

 */

#define SPECIALIZER_CALLSITE_STATUS_CLEAN                               0               /*< Call site is clean and there a request for first profile injection */

#define SPECIALIZER_CALLSITE_STATUS_FIRST_PROFILER_INJECTED             1               /*< First Profiler Injected */

#define SPECIALIZER_CALLSITE_STATUS_SECOND_PROFILER_REQUEST             2               /*< Request for second profiler injection */

#define SPECIALIZER_CALLSITE_STATUS_SECOND_PROFILER_INJECTED            3               /*< Second Profiler Injected  */

#define SPECIALIZER_CALLSITE_STATUS_DISPATCHER_REQUEST                  4               /*< Request for dispatcher Injection */

#define SPECIALIZER_CALLSITE_STATUS_DISPATCHER_INJECTED                 5               /*< Dispatcher Injected */

#define SPECIALIZER_CALLSITE_STATUS_DISPATCHER_REMOVE                   6               /*< Request for dispatcher removal */

#define SPECIALIZER_CALLSITE_STATUS_DISPATCHER_UNSPECIALIZABLE          7               /*< The call site cannot be specialized at all */

#define SPECIALIZER_CALLSITE_STATUS_TYPE_DISPATCHER_REQUEST             8               /*< Perform a request for the type dispatcher */

#define SPECIALIZER_CALLSITE_STATUS_TYPE_DISPATCHER_INJECTED            9               /*< The type dispatcher for this IRVCALL has been injected */

#define SPECIALIZER_CALLSITE_STATUS_TYPE_DISPATCHER_REMOVE              10              /*< The type dispatcher must be removed */

 

/***************************************** VARIABLES */

#ifdef SPECIALIZE_EVERY_METHOD

static int specializer_fullspecialization_counter = -1;

#endif

 

/* ----------------------------------------- Structure for specialization hints -----------------------------------------*/

/**

 * @brief This structure describe a single expression hint

 */

typedef struct specializer_expression_hint_t{

        JITUINT32               position;       /*< Position of the parameter */

        JITUINT32               action;         /*< One of the possible action */

        union{

                JITINT64        ivalue;         /*< Integer value for comparison for STATIC_EQ action */

                JITFLOAT64      fvalue;         /*< Float value for comparison for STATIC_EQF action */

        }                               value;          /*< Comparison value*/

        JITUINT32               depth;          /*< Depth of this expression */

        struct specializer_expression_hint_t    * next; /*< Next expression chained in AND or NULL if it's the last */

        struct specializer_expression_hint_t    * prev; /*< Previous expression chained in AND or NULL if it's the first */

 

        void    (*init)                 (struct specializer_expression_hint_t* expression, JITUINT32 position, JITUINT32 action, JITINT64 ivalue, JITFLOAT64 fvalue,  struct specializer_expression_hint_t* prev, struct specializer_expression_hint_t* next);

        void    (*printSingle)  (struct specializer_expression_hint_t* expression, FILE *out);

        void    (*printChain)   (struct specializer_expression_hint_t* expression, FILE *out);

        void    (*clean)                (struct specializer_expression_hint_t* expression, ir_specializer_t* specializer);

} specializer_expression_hint_t;

/**

 * Create a new expression hint

 */

specializer_expression_hint_t* newSpecializerExpressionHint(ir_specializer_t* specializer);

 

/**

 * @brief This structure describe for a single method a list of possible specialization expression

 */

typedef struct specializer_hintsForMethod_t{

        char            *methodCompleteName;                            /*< Full name of the method, for example System.Int32 */

        char            *methodSignature;                                       /*< Signature of the method, for example Void or System.Int32 */

        JITFLOAT32      zeroProfilerTypeThreshold;                      /*< Threshold of frequency to consider a layout (i.e.) a type sttaic */

        JITUINT32       zeroProfilerMemorySize;                         /*< Number of bytes that can be used to store information for the type (a.k.a. zero) profiler */

        JITUINT32       zeroDispatcherRemoveThreshold;          /*< Threshold for type dispatcher removal */

        JITUINT32       firstProfilerThreshold;                         /*< Threshold for the first profiler */

        JITUINT32       secondProfilerMemorySize;                       /*< Number of bytes that can be used to store information for the second profiler */

        JITFLOAT32      secondProfilerStaticThreshold;          /*< Threshold that a value (or an expression) should cross to be considered static */

        JITUINT32       dispatcherRemoveThreshold;                      /*< Threshold for dispatcher removal */

        XanList         *expressions;                                           /*< List of expression for specialization (List of type specializer_expression_hint_t)*/

 

        void            (*init)                                 (struct specializer_hintsForMethod_t *hints,

                                                                                        char* methodCompleteName, char* methodSignature,

                                                                                        JITFLOAT32 zeroProfilerTypeThreshold, JITUINT32 zeroProfilerMemorySize,

                                                                                        JITUINT32 zeroDispatcherRemoveThreshold, JITUINT32 firstProfilerThreshold,

                                                                                        JITUINT32 secondProfilerMemorySize, JITFLOAT32 secondProfilerStaticThreshold,

                                                                                        JITUINT32 dispatcherRemoveThreshold, ir_specializer_t* specializer);

        void            (*print)                                (struct specializer_hintsForMethod_t *hints, FILE* out);

        void            (*clean)                                (struct specializer_hintsForMethod_t *hints, ir_specializer_t* specializer);

 

        JITBOOLEAN      (*equals)                               (struct specializer_hintsForMethod_t *hints, char *methodCompleteName, char *methodSignature);

 

        void            (*addExpression)                (struct specializer_hintsForMethod_t *hints, specializer_expression_hint_t* expression);

        specializer_expression_hint_t*          (*getExpression)                (struct specializer_hintsForMethod_t *hints, JITUINT32 index);

        JITUINT32       (*getExpressionsNumber) (struct specializer_hintsForMethod_t *hints);

} specializer_hintsForMethod_t;

/**

 * Create a new hints for method

 */

specializer_hintsForMethod_t* newSpecializerHintsForMethod(ir_specializer_t* specializer);

 

/* ----------------------------------------- Wrapper for the IL Method -----------------------------------------*/

/**

 * @brief This structure is a wrapper for the ILMethod

 */

typedef struct specializer_method_wrapper_t{

        void            *ilMethod;                              /*< The IL Method pointer*/

        JITUINT32       recompileStateValue;    /*< The value of the state for recompile */

 

        /* Some functions for this IL Method */

        ir_method_t*(*_getIRMethod)(void* ilMethod);

        void            (*_setState)(void* ilMethod, JITUINT32 state);

        JITUINT32       (*_getState)(void* ilMethod);

        void            (*_setJITFunction) (void *ilMethod, void* jitFunction);

        void*           (*_getJITFunction) (void *ilMethod);

        JITBOOLEAN      (*_isCctor)(void* ilMethod);

 

        /* Useful methods for this wrapper */

        void (*init) (struct specializer_method_wrapper_t* methodWrapper,

                        void* ilMethod, JITUINT32 recompileStateValue,

                        ir_method_t* (*getIRMethod)(void* ilMethod),

                        void (*setState)(void* ilMethod, JITUINT32 state), JITUINT32 (*getState)(void* ilMethod),

                        void (*setJITFunction) (void *ilMethod, void* jitFunction), void* (*getJITFunction)(void *ilMethod),

                        JITBOOLEAN (*isCctor)(void* ilMethod));

        void (*print) (ir_specializer_t *specializer, struct specializer_method_wrapper_t* methodWrapper, FILE* out);

        void (*clean) (struct specializer_method_wrapper_t* methodWrapper, ir_specializer_t* specializer);

 

        ir_method_t* (*getIRMethod)(struct specializer_method_wrapper_t* methodWrapper);

        void (*setState)(struct specializer_method_wrapper_t* methodWrapper, JITUINT32 state);

        JITUINT32 (*getState)(struct specializer_method_wrapper_t* methodWrapper);

        void (*setToRecompileState) (struct specializer_method_wrapper_t* methodWrapper);

        void (*setJITFunction) (struct specializer_method_wrapper_t* methodWrapper, void* jitFunction);

        void* (*getJITFunction) (struct specializer_method_wrapper_t* methodWrapper);

        JITBOOLEAN (*isCctor)(struct specializer_method_wrapper_t* methodWrapper);

}specializer_method_wrapper_t;

/**

 * Create a new specializer Method

 */

specializer_method_wrapper_t* newSpecializerMethodWrapper(ir_specializer_t* specializer);

 

/* ----------------------------------------- Structure used by the second profiler -----------------------------------------*/

/**

 * This structure is used to wrap parameter information to use inside the second profiler,

 * adding informations about the offset inside the paramAcquired vector and the position

 * inside the method.

 */

typedef struct specializer_callSite_secondProfiler_param_t {

        ir_item_t       item;

        JITUINT32       position;

        JITUINT32       offset;

        JITBOOLEAN      _isVector;

 

        void (*init)    (struct specializer_callSite_secondProfiler_param_t* secondProfilerParam, ir_item_t* item, JITUINT32 offset, JITUINT32 position, JITBOOLEAN isVector);

        void (*print)   (struct specializer_callSite_secondProfiler_param_t* secspecializeram, FILE* out);

        void (*clean)   (struct specializer_callSite_secondProfiler_param_t* secondProfilerParam, ir_specializer_t* specializer);

 

        JITUINT32       (*getParamType)                 (struct specializer_callSite_secondProfiler_param_t* secondProfilerParam);

        JITUINT32       (*getParamInternalType) (struct specializer_callSite_secondProfiler_param_t* secondProfilerParam);

        size_t          (*getParameterSize)             (struct specializer_callSite_secondProfiler_param_t* secondProfilerParam);

 

        JITBOOLEAN      (*isVariable)                   (struct specializer_callSite_secondProfiler_param_t* secondProfilerParam);

        JITBOOLEAN      (*isConstant)                   (struct specializer_callSite_secondProfiler_param_t* secondProfilerParam);

        JITBOOLEAN      (*isVector)                             (struct specializer_callSite_secondProfiler_param_t* secondProfilerParam);

 

        IR_ITEM_VALUE   (*getValue)                     (struct specializer_callSite_secondProfiler_param_t* secondProfilerParam);

        IR_ITEM_FVALUE  (*getFValue)            (struct specializer_callSite_secondProfiler_param_t* secondProfilerParam);

 

        JITUINT32       (*getType)      (struct specializer_callSite_secondProfiler_param_t* secondProfilerParam);

} specializer_callSite_secondProfiler_param_t;

/**

 * Create a new second profiler parameter

 */

specializer_callSite_secondProfiler_param_t* newSpecializerSecondProfileParameter(ir_specializer_t* specializer);

 

/**

 * @Structure useful to store different kind of values with their type

 */

typedef struct specializer_multiValueContainer{

        union{

                JITNUINT        nuint;

                JITUINT8        uint8;

                JITUINT16       uint16;

                JITUINT32       uint32;

                JITUINT64       uint64;

                JITNINT         nint;

                JITINT8         int8;

                JITINT16        int16;

                JITINT32        int32;

                JITINT64        int64;

                JITNFLOAT       nfloat;

                JITFLOAT32      float32;

                JITFLOAT64      float64;

        } value;        /*< The value */

 

        JITUINT32 type; /*< The type of the value */

}specializer_multiValueContainer;

 

/**

 * @brief Describe the frequency for a given parameter

 */

typedef struct specializer_valueWithFrequency_t{

        specializer_multiValueContainer valueContainer;         /*< The value stored */

        JITFLOAT32                      frequency;                      /*< The frequency of the value */

 

        void    (*init)         (struct specializer_valueWithFrequency_t* valueWithFrequency, specializer_multiValueContainer valueContainer, JITFLOAT32 frequency);

        void    (*print)        (struct specializer_valueWithFrequency_t* valueWithFrequency, FILE* out);

        void    (*clean)        (struct specializer_valueWithFrequency_t* valueWithFrequency, ir_specializer_t* specializer);

} specializer_valueWithFrequency_t;

 

/**

 * Create a new value with frequency

 */

specializer_valueWithFrequency_t* newSpecializerValueWithFrequency(ir_specializer_t* specializer);

 

/**

 * @brief Describe all possible values a variable at a given position can assume

 */

typedef struct specializer_callSite_secondProfiler_param_values_t{

        JITUINT32 position;             /*< The variable position */

        XanList* values;                /*< The values the variable can assume */

 

        void    (*init)         (struct specializer_callSite_secondProfiler_param_values_t* valuesForPosition, JITUINT32 position, ir_specializer_t* specializer);

        void    (*print)        (struct specializer_callSite_secondProfiler_param_values_t* valuesForPosition, FILE* out);

        void    (*clean)        (struct specializer_callSite_secondProfiler_param_values_t* valuesForPosition, ir_specializer_t* specializer);

 

        void            (*addValue)     (struct specializer_callSite_secondProfiler_param_values_t* valuesForPosition, specializer_valueWithFrequency_t* valueWithFrequency);

        specializer_valueWithFrequency_t*       (*getValue)     (struct specializer_callSite_secondProfiler_param_values_t* valuesForPosition, JITUINT32 index);

        JITUINT32       (*getValuesNumber)      (struct specializer_callSite_secondProfiler_param_values_t* valuesForPosition);

}specializer_callSite_secondProfiler_param_values_t;

 

/**

 * Create a new value with frequency

 */

specializer_callSite_secondProfiler_param_values_t* newSpecializerValuesForParamPosition(ir_specializer_t* specializer);

 

/**

 * @brief This structure describe a static expression, i.e. and expression with associated actual values

 */

typedef struct specializer_staticExpression_hint_t{

        specializer_expression_hint_t   *expression;    /*< The static expression */

        specializer_multiValueContainer *values;                /*< The vector of values */

 

        void    (*init)         (struct specializer_staticExpression_hint_t* staticExpression, specializer_expression_hint_t *expression, specializer_multiValueContainer *values);

        void    (*print)        (struct specializer_staticExpression_hint_t* staticExpression, FILE* out);

        void    (*clean)        (struct specializer_staticExpression_hint_t* staticExpression, ir_specializer_t* specializer);

 

        JITBOOLEAN      (*equals)       (struct specializer_staticExpression_hint_t* staticExpression, struct specializer_staticExpression_hint_t* otherExpression);

}specializer_staticExpression_hint_t;

 

/**

 * Create a new static expression

 */

specializer_staticExpression_hint_t* newSpecializerStaticExpression(ir_specializer_t* specializer);

 

/* ----------------------------------------- Specialized method -----------------------------------------*/

/**

 * @brief Describe a new specialized method wrapper

 */

typedef struct specializer_specialized_method_wrapper_t{

        specializer_staticExpression_hint_t     *staticExpression;                      /*< The static expression associated to this method */

        specializer_method_wrapper_t            *originalMethodWrapper;         /*< The original method wrapper */

        specializer_method_wrapper_t            *specializedMethodWrapper;      /*< The specialized method wrapper */

 

        void    (*init)         (struct specializer_specialized_method_wrapper_t* specializedMethod,

                                                        specializer_staticExpression_hint_t *staticExpression,

                                                        specializer_method_wrapper_t *originalMethodWrapper,

                                                        specializer_method_wrapper_t *specializedMethodWrapper);

        void    (*print)        (struct specializer_specialized_method_wrapper_t* specializedMethod, FILE* out, ir_specializer_t *specializer);

        void    (*clean)        (struct specializer_specialized_method_wrapper_t* specializedMethod, ir_specializer_t* specializer);

 

        JITBOOLEAN      (*equals)       (struct specializer_specialized_method_wrapper_t* specializedMethod,

                                                                specializer_method_wrapper_t *originalMethodWrapper,

                                                                specializer_staticExpression_hint_t *staticExpression);

 

} specializer_specialized_method_wrapper_t;

 

/**

 * Create a new specialized method wrapper

 */

specializer_specialized_method_wrapper_t* getSpecializerSpecializedMethodWrapper(ir_specializer_t* specializer);

 

/* ----------------------------------------- Profilers and Dispatcher  -----------------------------------------*/

/**

 * @brief This structure describe the second profiler

 */

typedef struct specializer_method_callSite_firstProfiler_t{

        JITUINT32       counter;                        /*< Counter used to detect how many times this threshold has been reached */

        JITUINT32       thresholdReached;       /*< Keep track if the threshold has been reached */

        JITUINT32*      memory;                         /*< Memory where store informations about the type profiler */

        void*           callSiteContext;        /*< Pointer to the current call site context that owns this profiler */

 

        void (*init)    (struct specializer_method_callSite_firstProfiler_t* profiler, void* callSiteContext, ir_specializer_t* specializer);

        void (*print)   (struct specializer_method_callSite_firstProfiler_t* profiler, FILE* out);

        void (*clean)   (struct specializer_method_callSite_firstProfiler_t* profiler, ir_specializer_t* specializer);

 

        JITUINT32 *     (*getCounterPointer)                    (struct specializer_method_callSite_firstProfiler_t* profiler);

        JITUINT32       (*getCounterValue)                              (struct specializer_method_callSite_firstProfiler_t* profiler);

        JITUINT32 *     (*getThresholdReachedPointer)   (struct specializer_method_callSite_firstProfiler_t* profiler);

        JITUINT32       (*isThresholdReached)                   (struct specializer_method_callSite_firstProfiler_t* profiler);

 

        void (*inject)  (struct specializer_method_callSite_firstProfiler_t* profiler, specializer_method_wrapper_t* callerWrapper, ir_specializer_t* specializer);

        void (*remove)  (struct specializer_method_callSite_firstProfiler_t* profiler, specializer_method_wrapper_t* callerWrapper);

 

}specializer_method_callSite_firstProfiler_t;

 

/**

 * Create a new first profiler method

 */

specializer_method_callSite_firstProfiler_t* newSpecializerFirstProfiler(ir_specializer_t* specializer);

 

/**

 * @brief This structure describe the second profiler

 */

typedef struct specializer_method_callSite_secondProfiler_t{

        void            *callSiteContext;       /*< Pointer to the the call site that owns this profiler */

 

        void            *memory;                        /*< Memory used by the profiler to store the value */

        JITUINT32       threshold;                      /*< Threshold after which the memory has been full filled */

        JITUINT32       thresholdReached;       /*< Detect if the threshold has been reached */

        JITUINT32       counter;                        /*< The counter for threshold */

 

        JITUINT32       blockSize;                      /*< Size of a single block of parameters */

 

        XanList         *parameters;            /*< List of parameters to check for specialization (Type : specializer_callSite_secondProfiler_param_t) */

 

        void            (*init)         (struct specializer_method_callSite_secondProfiler_t* profiler, void *callSiteContext, ir_specializer_t* specializer);

        void            (*print)        (struct specializer_method_callSite_secondProfiler_t* profiler, FILE* out);

        void            (*clean)        (struct specializer_method_callSite_secondProfiler_t* profiler, ir_specializer_t* specializer);

 

        void    (*inject)       (struct specializer_method_callSite_secondProfiler_t* profiler, specializer_method_wrapper_t* callerWrapper, ir_specializer_t* specializer);

        void    (*remove)       (struct specializer_method_callSite_secondProfiler_t* profiler, specializer_method_wrapper_t* callerWrapper);

 

        JITUINT32*      (*getCounterPointer)                    (struct specializer_method_callSite_secondProfiler_t* profiler);

        JITUINT32       (*getCounterValue)                              (struct specializer_method_callSite_secondProfiler_t* profiler);

        JITUINT32*      (*getThresholdReachedPointer)   (struct specializer_method_callSite_secondProfiler_t* profiler);

        JITUINT32       (*isThresholdReached)                   (struct specializer_method_callSite_secondProfiler_t* profiler);

        JITUINT32       (*getThreshold)                                 (struct specializer_method_callSite_secondProfiler_t* profiler);

        JITUINT32       (*getBlockSize)                                 (struct specializer_method_callSite_secondProfiler_t* profiler);

 

        /**

         * Returns a list of parameters that are active because their frequency is over the required threshold frequency

         */

        XanList*        (*getStaticExpressions)         (struct specializer_method_callSite_secondProfiler_t* profiler, ir_specializer_t* specializer);

}specializer_method_callSite_secondProfiler_t;

 

/**

 * Create a new second profiler

 */

specializer_method_callSite_secondProfiler_t* newSpecializerSecondProfiler(ir_specializer_t* specializer);

 

/**

 * @brief The dispatcher for a single call site

 */

typedef struct specializer_method_callSite_dispatcher_t{

        void            *callSiteContext;       /*< The call site that own this dispatcher */

        JITINT32        counter;                        /*< Dispatcher counter */

        JITUINT32       thresholdReached;       /*< The threshold reached flag */

 

        void    (*init)         (struct specializer_method_callSite_dispatcher_t* dispatcher, void *callSiteContext);

        void    (*print)        (struct specializer_method_callSite_dispatcher_t* dispatcher, FILE* out);

        void    (*clean)        (struct specializer_method_callSite_dispatcher_t* dispatcher, ir_specializer_t* specializer);

 

        void            (*inject)       (struct specializer_method_callSite_dispatcher_t* dispatcher, specializer_method_wrapper_t* callerWrapper, XanList* staticExpressions, ir_specializer_t* specializer);

        void            (*remove)       (struct specializer_method_callSite_dispatcher_t* dispatcher, specializer_method_wrapper_t* callerWrapper);

 

        JITINT32*       (*getCounterPointer)                    (struct specializer_method_callSite_dispatcher_t* dispatcher);

        JITINT32        (*getCounterValue)                              (struct specializer_method_callSite_dispatcher_t* dispatcher);

 

}specializer_method_callSite_dispatcher_t;

 

/**

 * Create a new dispatcher

 */

specializer_method_callSite_dispatcher_t* newSpecializerDispatcher(ir_specializer_t* specializer);

 

/**

 * @brief The dispatcher for a single IRVCALL call site

 */

typedef struct specializer_method_callSite_type_dispatcher_t{

        void            *callSiteContext;       /*< The call site that own this dispatcher */

        JITINT32        counter;                        /*< Dispatcher counter */

        JITUINT32       thresholdReached;       /*< The threshold reached flag */

 

        void    (*init)         (struct specializer_method_callSite_type_dispatcher_t* dispatcher, void *callSiteContext);

        void    (*print)        (struct specializer_method_callSite_type_dispatcher_t* dispatcher, FILE* out);

        void    (*clean)        (struct specializer_method_callSite_type_dispatcher_t* dispatcher, ir_specializer_t* specializer);

 

        JITBOOLEAN      (*inject)       (struct specializer_method_callSite_type_dispatcher_t* dispatcher, specializer_method_wrapper_t* callerWrapper, JITUINT32* firstProfilerMemory, JITUINT32 firstProfilerCounter, ir_specializer_t* specializer);

        void            (*remove)       (struct specializer_method_callSite_type_dispatcher_t* dispatcher, specializer_method_wrapper_t* callerWrapper);

 

        JITINT32*       (*getCounterPointer)                    (struct specializer_method_callSite_type_dispatcher_t* dispatcher);

        JITINT32        (*getCounterValue)                              (struct specializer_method_callSite_type_dispatcher_t* dispatcher);

 

}specializer_method_callSite_type_dispatcher_t;

 

/**

 * Create a new dispatcher

 */

specializer_method_callSite_type_dispatcher_t* newSpecializerTypeDispatcher(ir_specializer_t* specializer);

 

/* ----------------------------------------- Structure for call site informations -----------------------------------------*/

 

/**

 * @biref This structure describe a single call site that can be specialized/to specialize

 * A call site

 */

typedef struct specializer_method_callSite_t{

        specializer_method_wrapper_t            *methodWrapper;                 /*< Callee wrapper */

        t_ir_instruction                        *call;                          /*< Pointer to call instruction */

        JITUINT32                               status;                         /*< Status of this call site */

        specializer_hintsForMethod_t            *hints;                         /*< Hints for the method called at call site */

        XanList                                 *addedInstructions;             /*< Instructions added to this call site */

 

        specializer_method_callSite_firstProfiler_t     *firstProfiler;         /*< The first profiler */

        specializer_method_callSite_secondProfiler_t    *secondProfiler;        /*< The second profiler */

        specializer_method_callSite_dispatcher_t        *dispatcher;            /*< The dispatcher */

        specializer_method_callSite_type_dispatcher_t   *typeDispatcher;        /*< The type dispatcher */

 

        void            (*init)                                 (struct specializer_method_callSite_t* callSite, specializer_method_wrapper_t *methodWrapper, t_ir_instruction* call, specializer_hintsForMethod_t *hints, ir_specializer_t* specializer);

        void            (*print)                                (struct specializer_method_callSite_t* callSite, FILE* out, ir_specializer_t *specializer);

        void            (*clean)                                (struct specializer_method_callSite_t* callSite, ir_specializer_t* specializer);

        void            (*addInstruction)                       (struct specializer_method_callSite_t* callSite, t_ir_instruction* instruction);

        void            (*removeInstructionsFromMethod)         (struct specializer_method_callSite_t* callSite, ir_method_t* irMethod);

        void            (*performAction)                        (struct specializer_method_callSite_t* callSite, specializer_method_wrapper_t* callerWrapper, ir_specializer_t* specializer);

        JITINT32        (*hasVariableParameters)                (struct specializer_method_callSite_t* callSite);

} specializer_method_callSite_t;

 

/**

 * Create a new method call site

 */

specializer_method_callSite_t* newSpecializerCallSite(ir_specializer_t* specializer);

 

/**

 * @brief This structure describe a list of call sites that could be specialized (or are actually specialized) for a given method.

 * The method is known by his pointer to his ilMethod structure.

 */

typedef struct specializer_callSitesForMethod_t{

        specializer_method_wrapper_t    *methodWrapper; /* Method that have some specializable call sites */

        XanList                                                 *callSites;             /* List of call sites specialized/to specialize */

 

        void    (*init)         (struct specializer_callSitesForMethod_t* callSitesForMethod, specializer_method_wrapper_t* wrapper, ir_specializer_t* specializer);

        void    (*print)        (struct specializer_callSitesForMethod_t* callSitesForMethod, FILE* out, ir_specializer_t *specializer);

        void    (*clean)        (struct specializer_callSitesForMethod_t* callSitesForMethod, ir_specializer_t* specializer);

 

        /**

         * Return the call site at given instruction... if the call site do not exists create a new one

         */

        specializer_method_callSite_t*  (*getCallSiteForInstruction)    (struct specializer_callSitesForMethod_t* callSitesForMethod, specializer_method_wrapper_t *calleeWrapper, t_ir_instruction* call, specializer_hintsForMethod_t *hints, ir_specializer_t* specializer);

 

        JITBOOLEAN      (*isInjectedInstruction)(struct specializer_callSitesForMethod_t* callSitesForMethod, t_ir_instruction* instruction);

 

} specializer_callSitesForMethod_t;

 

/**

 * Create a new call sites for specializer method

 */

specializer_callSitesForMethod_t* newSpecializerCallSitesForMethod(ir_specializer_t* specializer);

 

/* ----------------------------------------- Specializer common methods -----------------------------------------*/

specializer_callSitesForMethod_t* ir_specializer_getCallSitesFormMethod(ir_specializer_t* specializer,

                specializer_method_wrapper_t* wrapper);

 

specializer_method_wrapper_t* ir_specializer_getSpecializedMethod(ir_specializer_t *specializer,

                specializer_method_wrapper_t* originalMethodWrapper,

                specializer_staticExpression_hint_t* staticExpression);

 

specializer_hintsForMethod_t* ir_specializer_getHintsForMethodForMethod(ir_specializer_t *specializer,

                specializer_method_wrapper_t* wrapper);

 

specializer_method_wrapper_t* ir_specializer_getMethodWrapper(ir_specializer_t* specializer,

                void* ilMethod, JITUINT32 recompileStateValue,

                ir_method_t* (*getIRMethod)(void* ilMethod),

                void (*setState)(void* ilMethod, JITUINT32 state), JITUINT32 (*getState)(void* ilMethod),

                void (*setJITFunction) (void *ilMethod, void* jitFunction), void* (*getJITFunction)(void *ilMethod),

                JITBOOLEAN (*isCctor)(void*ilMethod));

 

#endif