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 /*
  12  * io-layer.h must be _BEFORE_ win32-exception.h to avoid problems when
  13  * compiling with version 1.2 of mingw and w32api.
  14  */
  15 #include <mono/io-layer/io-layer.h>
  16
  17 #ifdef __WIN32__
  18 #include "win32-exception.h"
  19 #else
  20 #include <signal.h>
  21 #endif
  22
  23 #include <setjmp.h>
  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/appdomain.h>
  30 #include <mono/metadata/opcodes.h>
  31 #include <mono/utils/monobitset.h>
  32
  33 #include "regset.h"
  34
  35 /* fixme: configure should set that */
  36 #define ARCH_X86
  37
  38 #ifdef ARCH_X86
  39 #define MB_TERM_LDIND_REF MB_TERM_LDIND_I4
  40 #define MB_TERM_LDIND_U4 MB_TERM_LDIND_I4
  41 #define MB_TERM_STIND_REF MB_TERM_STIND_I4
  42 #define MB_TERM_REMOTE_STIND_REF MB_TERM_REMOTE_STIND_I4
  43 #endif
  44
  45 #define VARINFO(cfg,num) (g_array_index (cfg->varinfo, MonoVarInfo, num))
  46
  47 #define SET_VARINFO(vi,t,k,o,s) do { vi.type=t; vi.vartype=k; vi.offset=o; vi.size=s; } while (0)
  48
  49 extern int mono_exc_esp_offset;
  50
  51 extern void (*mono_thread_attach_aborted_cb ) (MonoObject *obj);
  52
  53 typedef struct _MBTree MBTree;
  54
  55 typedef enum {
  56         VAL_UNKNOWN,
  57         VAL_I32,
  58         VAL_I64,
  59         VAL_POINTER,
  60         VAL_DOUBLE, /* must be the last - do not reorder */
  61 } MonoValueType;
  62
  63 typedef enum {
  64         MONO_ARGVAR,
  65         MONO_LOCALVAR,
  66         MONO_TEMPVAR,
  67 } MonoVarType;
  68
  69 typedef struct {
  70         gpointer    previous_lmf;
  71         gpointer    lmf_addr;
  72         MonoMethod *method;
  73         guint32     ebp;
  74         guint32     esi;
  75         guint32     edi;
  76         guint32     ebx;
  77         guint32     eip;
  78 } MonoLMF;
  79
  80 typedef union {
  81         struct {
  82                 guint16 tid; /* tree number */
  83                 guint16 bid; /* block number */
  84         } pos ;
  85         guint32 abs_pos;
  86 } MonoPosition;
  87
  88 typedef struct {
  89         MonoPosition first_use, last_use;
  90 } MonoLiveRange;
  91
  92 typedef struct {
  93         MonoValueType type:4;
  94         MonoVarType vartype:4;
  95         unsigned isvolatile:1;
  96         int offset;
  97         int size;
  98         MonoLiveRange range;
  99         int reg;
 100         int varnum; /* only for debugging */
 101 } MonoVarInfo;
 102
 103 typedef struct {
 104         unsigned block_id:15;
 105         unsigned is_block_start:1;
 106 } MonoBytecodeInfo;
 107
 108 typedef struct {
 109         unsigned reached:1;
 110         unsigned finished:1;
 111
 112         gint32        cli_addr;  /* start instruction */
 113         gint32        length;    /* length of stream */
 114         GPtrArray    *forest;
 115         MBTree      **instack;
 116         gint32        indepth;
 117         MBTree      **outstack;
 118         gint32        outdepth;
 119         gint32        addr;
 120         guint16       num;
 121
 122         MonoBitSet   *gen_set;
 123         MonoBitSet   *kill_set;
 124         MonoBitSet   *live_in_set;
 125         MonoBitSet   *live_out_set;
 126
 127         GList        *succ;
 128 } MonoBBlock;
 129
 130 typedef enum {
 131         MONO_JUMP_INFO_BB,
 132         MONO_JUMP_INFO_ABS,
 133         MONO_JUMP_INFO_EPILOG,
 134         MONO_JUMP_INFO_IP,
 135 } MonoJumpInfoType;
 136
 137 typedef struct _MonoJumpInfo MonoJumpInfo;
 138 struct _MonoJumpInfo {
 139         MonoJumpInfo *next;
 140         gpointer      ip;
 141         MonoJumpInfoType type;
 142         union {
 143                 gpointer      target;
 144                 MonoBBlock   *bb;
 145         } data;
 146 };
 147
 148 typedef struct {
 149         MonoDomain       *domain;
 150         unsigned          has_vtarg:1;
 151         unsigned          share_code:1;
 152         MonoMethod       *method;
 153         MonoBytecodeInfo *bcinfo;
 154         MonoBBlock       *bblocks;
 155         int               block_count;
 156
 157         GArray           *varinfo;
 158         gint32            locals_size;
 159         guint16          *intvars;
 160         guint16           excvar;
 161
 162         MonoMemPool      *mp;
 163         guint8           *start;
 164         guint8           *code;
 165         gint32            code_size;
 166         gint32            prologue_end;
 167         gint32            epilogue_end;
 168         gint32            lmfip_offset;
 169         MonoRegSet       *rs;
 170         guint32           epilog;
 171         guint32           args_start_index;
 172         guint32           locals_start_index;
 173         gint             *spillvars;
 174         gint              spillcount;
 175         MonoJumpInfo     *jump_info;
 176 } MonoFlowGraph;
 177
 178 typedef struct {
 179         gpointer p;
 180         MonoMethod *method;
 181 } MonoJitNonVirtualCallInfo;
 182
 183 typedef struct {
 184         MonoClass *klass;
 185         MonoClassField *field;
 186 } MonoJitFieldInfo;
 187
 188 typedef struct {
 189         MonoBBlock *target;
 190         guint32 cond;
 191 } MonoJitBranchInfo;
 192
 193 typedef struct {
 194         guint16 size;
 195         guint16 offset;
 196         guint8  pad;
 197 } MonoJitArgumentInfo;
 198
 199 typedef struct {
 200         guint16 vtype_num;
 201         guint16 frame_size;
 202         guint8  pad;
 203 } MonoJitCallInfo;
 204
 205 typedef struct {
 206         gulong methods_compiled;
 207         gulong methods_lookups;
 208         gulong method_trampolines;
 209         gulong allocate_var;
 210         gulong analyze_stack_repeat;
 211         gulong cil_code_size;
 212         gulong native_code_size;
 213         gulong code_reallocs;
 214         gulong max_code_size_ratio;
 215         gulong biggest_method_size;
 216         gulong allocated_code_size;
 217         gulong inlineable_methods;
 218         gulong inlined_methods;
 219         gulong basic_blocks;
 220         gulong max_basic_blocks;
 221         MonoMethod *max_ratio_method;
 222         MonoMethod *biggest_method;
 223         gboolean enabled;
 224 } MonoJitStats;
 225
 226 typedef struct {
 227         gpointer          end_of_stack;
 228         MonoLMF          *lmf;
 229         void            (*abort_func) (MonoObject *object);
 230 } MonoJitTlsData;
 231
 232 extern MonoJitStats mono_jit_stats;
 233 extern gboolean mono_jit_dump_asm;
 234 extern gboolean mono_jit_dump_forest;
 235 extern gboolean mono_jit_trace_calls;
 236 extern gboolean mono_jit_profile;
 237 extern gboolean mono_jit_share_code;
 238 extern gboolean mono_jit_inline_code;
 239 extern gboolean mono_use_linear_scan;
 240 extern gboolean mono_use_fast_iconv;
 241 extern gboolean mono_break_on_exc;
 242 extern gboolean mono_inline_memcpy;
 243 extern guint32  mono_jit_tls_id;
 244 extern gboolean mono_jit_boundcheck;
 245
 246 extern CRITICAL_SECTION *metadata_section;
 247
 248 /* architecture independent functions */
 249
 250 MonoDomain *
 251 mono_jit_init              (const char *file);
 252
 253 int
 254 mono_jit_exec              (MonoDomain *domain, MonoAssembly *assembly,
 255                             int argc, char *argv[]);
 256 void
 257 mono_jit_cleanup           (MonoDomain *domain);
 258
 259 void
 260 mono_jit_compile_image     (MonoImage *image, int verbose);
 261
 262 void
 263 mono_jit_compile_class     (MonoAssembly *assembly, char *compile_class,
 264                             int compile_times, int verbose);
 265
 266 gpointer
 267 mono_jit_create_remoting_trampoline (MonoMethod *method);
 268
 269 void
 270 mono_add_jump_info         (MonoFlowGraph *cfg, gpointer ip,
 271                             MonoJumpInfoType type, gpointer target);
 272
 273 gpointer
 274 mono_get_lmf_addr          (void);
 275
 276 void
 277 mono_cpu_detect            (void);
 278
 279 /* architecture dependent functions */
 280
 281 void
 282 mono_jit_walk_stack        (MonoStackWalk func, gpointer user_data);
 283
 284 int
 285 arch_get_argument_info     (MonoMethodSignature *csig, int param_count,
 286                             MonoJitArgumentInfo *arg_info);
 287
 288 MonoBoolean
 289 ves_icall_get_frame_info   (gint32 skip, MonoBoolean need_file_info,
 290                             MonoReflectionMethod **method,
 291                             gint32 *iloffset, gint32 *native_offset,
 292                             MonoString **file, gint32 *line, gint32 *column);
 293
 294 MonoArray *
 295 ves_icall_get_trace        (MonoException *exc, gint32 skip,
 296                             MonoBoolean need_file_info);
 297
 298 gboolean
 299 arch_handle_exception      (struct sigcontext *ctx, gpointer obj, gboolean test_only);
 300
 301 gpointer
 302 arch_get_throw_exception   (void);
 303
 304 gpointer
 305 arch_get_throw_exception_by_name (void);
 306
 307 MonoJitInfo *
 308 arch_jit_compile_cfg       (MonoDomain *target_domain, MonoFlowGraph *cfg);
 309
 310 gpointer
 311 arch_create_jit_trampoline (MonoMethod *method);
 312
 313 int
 314 arch_allocate_arg          (MonoFlowGraph *cfg, MonoJitArgumentInfo *info, MonoValueType type);
 315
 316 int
 317 arch_allocate_var          (MonoFlowGraph *cfg, int size, int align,
 318                             MonoVarType vartype, MonoValueType type);
 319
 320 void
 321 mono_linear_scan           (MonoFlowGraph *cfg, guint32 *used_mask);
 322
 323 const char *
 324 arch_get_reg_name          (int regnum);
 325
 326 int
 327 arch_activation_frame_size (MonoMethodSignature *sig);
 328
 329 gboolean
 330 mono_has_unwind_info       (MonoMethod *method);
 331
 332 gboolean
 333 mono_method_blittable      (MonoMethod *method);
 334
 335 #endif