mono/jit/jit.h

   1 /*
   2  * Author:
   3  *   Dietmar Maurer (dietmar@ximian.com)
   4  *
   5  * (C) 2001 Ximian, Inc.
   6  */
   7
   8 #ifndef _MONO_JIT_JIT_H_
   9 #define _MONO_JIT_JIT_H_
  10
  11 #include <config.h>
  12 /*
  13  * io-layer.h must be _BEFORE_ win32-exception.h to avoid problems when
  14  * compiling with version 1.2 of mingw and w32api.
  15  */
  16 #include <mono/io-layer/io-layer.h>
  17
  18 #ifdef PLATFORM_WIN32
  19 #include "win32-exception.h"
  20 #else
  21 #include <signal.h>
  22 #endif
  23
  24 #include <mono/metadata/loader.h>
  25 #include <mono/metadata/object.h>
  26 #include <mono/metadata/exception.h>
  27 #include <mono/metadata/mempool.h>
  28 #include <mono/metadata/reflection.h>
  29 #include <mono/metadata/opcodes.h>
  30
  31 #include "regset.h"
  32
  33 #define ISSTRUCT(t) (!t->byref && t->type == MONO_TYPE_VALUETYPE && !t->data.klass->enumtype)
  34
  35 #define VARINFO(cfg,num) (g_array_index (cfg->varinfo, MonoVarInfo, num))
  36
  37 typedef struct _MBTree MBTree;
  38
  39 typedef enum {
  40         VAL_UNKNOWN,
  41         VAL_I32,
  42         VAL_I64,
  43         VAL_POINTER,
  44         VAL_DOUBLE, /* must be the last - do not reorder */
  45 } MonoValueType;
  46
  47 typedef enum {
  48         MONO_ARGVAR,
  49         MONO_LOCALVAR,
  50         MONO_TEMPVAR,
  51 } MonoValueKind;
  52
  53 typedef struct {
  54         gpointer    previous_lmf;
  55         gpointer    lmf_addr;
  56         MonoMethod *method;
  57         guint32     ebp;
  58         guint32     esi;
  59         guint32     edi;
  60         guint32     ebx;
  61         guint32     eip;
  62 } MonoLMF;
  63
  64 typedef union {
  65         struct {
  66                 guint16 tid; /* tree number */
  67                 guint16 bid; /* block number */
  68         } pos ;
  69         guint32 abs_pos;
  70 } MonoPosition;
  71
  72 typedef struct {
  73         MonoPosition first_use, last_use;
  74 } MonoLiveRange;
  75
  76 typedef struct {
  77         MonoValueType type;
  78         MonoValueKind kind;
  79         int offset;
  80         int size;
  81         MonoLiveRange range;
  82         unsigned isvolatile:1;
  83         int reg;
  84         int varnum; /* only for debugging */
  85 } MonoVarInfo;
  86
  87 typedef struct {
  88         unsigned block_id:15;
  89         unsigned is_block_start:1;
  90 } MonoBytecodeInfo;
  91
  92 typedef guint32 * MonoBitSet;
  93
  94 typedef struct {
  95         unsigned reached:1;
  96         unsigned finished:1;
  97
  98         gint32        cli_addr;  /* start instruction */
  99         gint32        length;    /* length of stream */
 100         GPtrArray    *forest;
 101         MBTree      **instack;
 102         gint32        indepth;
 103         MBTree      **outstack;
 104         gint32        outdepth;
 105         gint32        addr;
 106         guint16       num;
 107
 108         MonoBitSet    gen_set;
 109         MonoBitSet    kill_set;
 110         MonoBitSet    live_in_set;
 111         MonoBitSet    live_out_set;
 112
 113         GList        *succ;
 114 } MonoBBlock;
 115
 116 typedef enum {
 117         MONO_JUMP_INFO_BB,
 118         MONO_JUMP_INFO_ABS,
 119         MONO_JUMP_INFO_EPILOG,
 120         MONO_JUMP_INFO_IP,
 121 } MonoJumpInfoType;
 122
 123 typedef struct _MonoJumpInfo MonoJumpInfo;
 124 struct _MonoJumpInfo {
 125         MonoJumpInfo *next;
 126         gpointer      ip;
 127         MonoJumpInfoType type;
 128         union {
 129                 gpointer      target;
 130                 MonoBBlock   *bb;
 131         } data;
 132 };
 133
 134 typedef struct {
 135         MonoDomain       *domain;
 136         unsigned          has_vtarg:1;
 137         unsigned          share_code:1;
 138         MonoMethod       *method;
 139         MonoBytecodeInfo *bcinfo;
 140         MonoBBlock       *bblocks;
 141         int               block_count;
 142         GArray           *varinfo;
 143         gint32            locals_size;
 144         gint32            args_size;
 145         guint16          *intvars;
 146         guint16           excvar;
 147
 148         MonoMemPool      *mp;
 149         guint8           *start;
 150         guint8           *code;
 151         gint32            code_size;
 152         gint32            prologue_end;
 153         gint32            epilogue_end;
 154         MonoRegSet       *rs;
 155         guint32           epilog;
 156         guint32           args_start_index;
 157         guint32           locals_start_index;
 158         gint              invalid;
 159         gint             *spillvars;
 160         gint              spillcount;
 161         MonoJumpInfo     *jump_info;
 162 } MonoFlowGraph;
 163
 164 typedef struct {
 165         MonoMethod *m;
 166         gint16 args_size;
 167         gint16 vtype_num;
 168 } MonoJitCallInfo;
 169
 170 typedef struct {
 171         MonoClass *klass;
 172         MonoClassField *field;
 173 } MonoJitFieldInfo;
 174
 175 typedef struct {
 176         MonoBBlock *target;
 177         guint32 cond;
 178 } MonoJitBranchInfo;
 179
 180 typedef struct {
 181         gulong methods_compiled;
 182         gulong methods_lookups;
 183         gulong method_trampolines;
 184         gulong allocate_var;
 185         gulong analyze_stack_repeat;
 186         gulong cil_code_size;
 187         gulong native_code_size;
 188         gulong code_reallocs;
 189         gulong max_code_size_ratio;
 190         gulong biggest_method_size;
 191         gulong allocated_code_size;
 192         gulong inlineable_methods;
 193         gulong inlined_methods;
 194         MonoMethod *max_ratio_method;
 195         MonoMethod *biggest_method;
 196         gboolean enabled;
 197 } MonoJitStats;
 198
 199 extern MonoJitStats mono_jit_stats;
 200 extern gboolean mono_jit_dump_asm;
 201 extern gboolean mono_jit_dump_forest;
 202 extern gboolean mono_jit_trace_calls;
 203 extern gboolean mono_jit_profile;
 204 extern gboolean mono_jit_share_code;
 205 extern gboolean mono_jit_inline_code;
 206 extern gboolean mono_use_linear_scan;
 207
 208 extern gpointer mono_end_of_stack;
 209 extern int      mono_worker_threads;
 210 extern guint32  lmf_thread_id;
 211 extern guint32  exc_cleanup_id;
 212 extern guint32  async_result_id;
 213
 214 extern CRITICAL_SECTION *metadata_section;
 215
 216 void
 217 arch_handle_exception      (struct sigcontext *ctx, gpointer obj);
 218
 219 gpointer
 220 arch_get_throw_exception   (void);
 221
 222 gpointer
 223 arch_get_throw_exception_by_name (void);
 224
 225 MonoFlowGraph *
 226 mono_cfg_new               (MonoMethod *method, MonoMemPool *mp);
 227
 228 void
 229 mono_cfg_free              (MonoFlowGraph *cfg);
 230
 231 MBTree *
 232 mono_ctree_new             (MonoMemPool *mp, int op, MBTree *left,
 233                             MBTree *right);
 234 MBTree *
 235 mono_ctree_new_leaf        (MonoMemPool *mp, int op);
 236
 237 void
 238 mono_analyze_flow          (MonoFlowGraph *cfg);
 239
 240 void
 241 mono_analyze_stack         (MonoFlowGraph *cfg);
 242
 243 void
 244 mono_add_jump_info         (MonoFlowGraph *cfg, gpointer ip,
 245                             MonoJumpInfoType type, gpointer target);
 246
 247 void
 248 mono_disassemble_code      (guint8 *code, int size, char *id);
 249
 250 gpointer
 251 arch_compile_method        (MonoMethod *method);
 252
 253 gpointer
 254 arch_create_jit_trampoline (MonoMethod *method);
 255
 256 gpointer
 257 arch_create_remoting_trampoline (MonoMethod *method);
 258
 259 MonoObject*
 260 arch_runtime_invoke        (MonoMethod *method, void *obj, void **params);
 261
 262 gpointer
 263 arch_create_native_wrapper (MonoMethod *method);
 264
 265 int
 266 arch_allocate_var          (MonoFlowGraph *cfg, int size, int align,
 267                             MonoValueKind kind, MonoValueType type);
 268
 269 void
 270 mono_linear_scan           (MonoFlowGraph *cfg, guint32 *used_mask);
 271
 272 /* delegate support functions */
 273
 274 void
 275 mono_delegate_init         (void);
 276
 277 void
 278 mono_delegate_cleanup      (void);
 279
 280 void
 281 mono_delegate_ctor         (MonoDelegate *this, MonoObject *target, gpointer addr);
 282
 283 gpointer
 284 arch_begin_invoke          (MonoMethod *method, gpointer ret_ip, MonoObject *delegate);
 285
 286 void
 287 arch_end_invoke            (MonoMethod *method, gpointer first_arg, ...);
 288
 289 gpointer
 290 arch_get_delegate_invoke   (MonoMethod *method, int *size);
 291
 292 gpointer
 293 mono_load_remote_field     (MonoObject *this, MonoClass *klass, MonoClassField *field, gpointer *res);
 294
 295 void
 296 mono_store_remote_field    (MonoObject *this, MonoClass *klass, MonoClassField *field, gpointer val);
 297
 298 void
 299 mono_cpu_detect            (void);
 300
 301 MonoDomain *
 302 mono_jit_init              (char *file);
 303
 304 int
 305 mono_jit_exec              (MonoDomain *domain, MonoAssembly *assembly,
 306                             int argc, char *argv[]);
 307
 308 void
 309 mono_jit_cleanup           (MonoDomain *domain);
 310
 311 MonoMethodMessage *
 312 arch_method_call_message_new (MonoMethod *method, gpointer stack, MonoMethod *invoke,
 313                               MonoDelegate **cb, MonoObject **state);
 314
 315 void
 316 arch_return_value           (MonoType *return_type, MonoObject *result, gpointer stack);
 317
 318 void
 319 arch_method_return_message_restore (MonoMethod *method, gpointer stack,
 320                                     MonoObject *result, MonoArray *out_args);
 321
 322
 323 /* some handy debugging functions */
 324
 325 void
 326 mono_print_ctree           (MonoFlowGraph *cfg, MBTree *tree);
 327
 328 void
 329 mono_print_forest          (MonoFlowGraph *cfg, GPtrArray *forest);
 330
 331 #endif