mono/mini/interp/interp-internals.h

   1 #ifndef __MONO_MINI_INTERPRETER_INTERNALS_H__
   2 #define __MONO_MINI_INTERPRETER_INTERNALS_H__
   3
   4 #include <setjmp.h>
   5 #include <glib.h>
   6 #include <mono/metadata/loader.h>
   7 #include <mono/metadata/object.h>
   8 #include <mono/metadata/domain-internals.h>
   9 #include <mono/metadata/class-internals.h>
  10 #include <mono/metadata/debug-internals.h>
  11 #include "config.h"
  12
  13 enum {
  14         VAL_I32     = 0,
  15         VAL_DOUBLE  = 1,
  16         VAL_I64     = 2,
  17         VAL_VALUET  = 3,
  18         VAL_POINTER = 4,
  19         VAL_NATI    = 0 + VAL_POINTER,
  20         VAL_MP      = 1 + VAL_POINTER,
  21         VAL_TP      = 2 + VAL_POINTER,
  22         VAL_OBJ     = 3 + VAL_POINTER
  23 };
  24
  25 #if SIZEOF_VOID_P == 4
  26 typedef guint32 mono_u;
  27 typedef gint32  mono_i;
  28 #elif SIZEOF_VOID_P == 8
  29 typedef guint64 mono_u;
  30 typedef gint64  mono_i;
  31 #endif
  32
  33 /*
  34  * Value types are represented on the eval stack as pointers to the
  35  * actual storage. The size field tells how much storage is allocated.
  36  * A value type can't be larger than 16 MB.
  37  */
  38 typedef struct {
  39         union {
  40                 gint32 i;
  41                 gint64 l;
  42                 struct {
  43                         gint32 lo;
  44                         gint32 hi;
  45                 } pair;
  46                 double f;
  47                 /* native size integer and pointer types */
  48                 gpointer p;
  49                 mono_u nati;
  50                 gpointer vt;
  51         } data;
  52 #if defined(__ppc__) || defined(__powerpc__)
  53         int pad;
  54 #endif
  55 } stackval;
  56
  57 typedef struct _MonoInvocation MonoInvocation;
  58
  59 typedef void (*MonoFuncV) (void);
  60 typedef void (*MonoPIFunc) (MonoFuncV callme, void *margs);
  61
  62 /*
  63  * Structure representing a method transformed for the interpreter
  64  * This is domain specific
  65  */
  66 typedef struct _RuntimeMethod
  67 {
  68         /* NOTE: These first two elements (method and
  69            next_jit_code_hash) must be in the same order and at the
  70            same offset as in MonoJitInfo, because of the jit_code_hash
  71            internal hash table in MonoDomain. */
  72         MonoMethod *method;
  73         struct _RuntimeMethod *next_jit_code_hash;
  74         guint32 locals_size;
  75         guint32 args_size;
  76         guint32 stack_size;
  77         guint32 vt_stack_size;
  78         guint32 alloca_size;
  79         unsigned short *code;
  80         unsigned short *new_body_start; /* after all STINARG instrs */
  81         MonoPIFunc func;
  82         int num_clauses;
  83         MonoExceptionClause *clauses;
  84         void **data_items;
  85         int transformed;
  86         guint32 *arg_offsets;
  87         guint32 *local_offsets;
  88         unsigned int param_count;
  89         unsigned int hasthis;
  90         gpointer jit_wrapper;
  91         gpointer jit_addr;
  92         MonoMethodSignature *jit_sig;
  93         gpointer jit_entry;
  94         MonoType *rtype;
  95         MonoType **param_types;
  96         MonoJitInfo *jinfo;
  97         MonoDomain *domain;
  98 } RuntimeMethod;
  99
 100 struct _MonoInvocation {
 101         MonoInvocation *parent; /* parent */
 102         RuntimeMethod  *runtime_method; /* parent */
 103         MonoMethod     *method; /* parent */
 104         stackval       *retval; /* parent */
 105         char           *args;
 106         stackval       *stack_args; /* parent */
 107         stackval       *stack;
 108         stackval       *sp; /* For GC stack marking */
 109         unsigned char  *locals;
 110         /* exception info */
 111         unsigned char  invoke_trap;
 112         const unsigned short  *ip;
 113         MonoException     *ex;
 114         MonoExceptionClause *ex_handler;
 115 };
 116
 117 typedef struct {
 118         MonoDomain *original_domain;
 119         MonoInvocation *base_frame;
 120         MonoInvocation *current_frame;
 121         MonoInvocation *env_frame;
 122         jmp_buf *current_env;
 123         unsigned char search_for_handler;
 124         unsigned char managed_code;
 125
 126         /* Resume state for resuming execution in mixed mode */
 127         gboolean       has_resume_state;
 128         /* Frame to resume execution at */
 129         MonoInvocation *handler_frame;
 130         /* IP to resume execution at */
 131         gpointer handler_ip;
 132 } ThreadContext;
 133
 134 extern int mono_interp_traceopt;
 135 extern GSList *jit_classes;
 136
 137 MonoException *
 138 mono_interp_transform_method (RuntimeMethod *runtime_method, ThreadContext *context);
 139
 140 void
 141 mono_interp_transform_init (void);
 142
 143 RuntimeMethod *
 144 mono_interp_get_runtime_method (MonoDomain *domain, MonoMethod *method, MonoError *error);
 145
 146 #endif /* __MONO_MINI_INTERPRETER_INTERNALS_H__ */