mono/jit/jit.h

   1 #ifndef _MONO_JIT_JIT_H_
   2 #define _MONO_JIT_JIT_H_
   3
   4 #include <signal.h>
   5
   6 #include <mono/metadata/loader.h>
   7 #include <mono/metadata/object.h>
   8 #include <mono/metadata/exception.h>
   9 #include <mono/metadata/mempool.h>
  10
  11 #include "regset.h"
  12
  13 #define ISSTRUCT(t) (!t->byref && t->type == MONO_TYPE_VALUETYPE && !t->data.klass->enumtype)
  14
  15 typedef struct _MBTree MBTree;
  16
  17 typedef enum {
  18         VAL_UNKNOWN,
  19         VAL_I32,
  20         VAL_I64,
  21         VAL_POINTER,
  22         VAL_DOUBLE, // must be the last - do not reorder
  23 } MonoValueType;
  24
  25 typedef enum {
  26         MONO_ARGVAR,
  27         MONO_LOCALVAR,
  28         MONO_TEMPVAR,
  29 } MonoValueKind;
  30
  31 typedef struct {
  32         gpointer    previous_lmf;
  33         gpointer    lmf_addr;
  34         MonoMethod *method;
  35         guint32     eip;
  36         guint32     ebp;
  37         guint32     esi;
  38         guint32     edi;
  39         guint32     ebx;
  40
  41 } MonoLMF;
  42
  43 typedef struct {
  44         MonoValueType type;
  45         MonoValueKind kind;
  46         int offset;
  47         int size;
  48 } MonoVarInfo;
  49
  50 typedef struct {
  51         unsigned block_id:15;
  52         unsigned is_block_start:1;
  53 } MonoBytecodeInfo;
  54
  55 typedef struct {
  56         unsigned reached:1;
  57         unsigned finished:1;
  58
  59         gint32        cli_addr;  /* start instruction */
  60         gint32        length;    /* length of stream */
  61         GPtrArray    *forest;
  62         MBTree      **instack;
  63         gint32        indepth;
  64         MBTree      **outstack;
  65         gint32        outdepth;
  66         gint32        addr;
  67 } MonoBBlock;
  68
  69 typedef struct {
  70         MonoDomain       *domain;
  71         unsigned          has_vtarg:1;
  72         unsigned          share_code:1;
  73         MonoMethod       *method;
  74         MonoBytecodeInfo *bcinfo;
  75         MonoBBlock       *bblocks;
  76         int               block_count;
  77         GArray           *varinfo;
  78         gint32            locals_size;
  79         gint32            args_size;
  80         guint16          *intvars;
  81         guint16           excvar;
  82
  83         MonoMemPool      *mp;
  84         guint8           *start;
  85         guint8           *code;
  86         gint32            code_size;
  87         MonoRegSet       *rs;
  88         guint32           epilog;
  89         guint32           args_start_index;
  90         guint32           locals_start_index;
  91         gint              invalid;
  92 } MonoFlowGraph;
  93
  94 typedef struct {
  95         MonoMethod *m;
  96         int args_size;
  97         int vtype_num;
  98 } MethodCallInfo;
  99
 100 typedef struct {
 101         guint32  flags;
 102         gpointer try_start;
 103         gpointer try_end;
 104         gpointer handler_start;
 105         guint32  token_or_filter;
 106 } MonoJitExceptionInfo;
 107
 108 typedef struct {
 109         MonoMethod *method;
 110         gpointer code_start;
 111         int      code_size;
 112         guint32  used_regs;
 113         unsigned num_clauses;
 114         MonoJitExceptionInfo *clauses;
 115 } MonoJitInfo;
 116
 117 typedef GArray MonoJitInfoTable;
 118
 119 extern gboolean mono_jit_dump_asm;
 120 extern gboolean mono_jit_dump_forest;
 121 extern gboolean mono_jit_trace_calls;
 122 extern gboolean mono_jit_share_code;
 123 extern MonoJitInfoTable *mono_jit_info_table;
 124 extern gpointer mono_end_of_stack;
 125
 126 extern guint32  lmf_thread_id;
 127
 128 MonoJitInfoTable *
 129 mono_jit_info_table_new    (void);
 130
 131 int
 132 mono_jit_info_table_index  (MonoJitInfoTable *table, gpointer addr);
 133
 134 void
 135 mono_jit_info_table_add    (MonoJitInfoTable *table, MonoJitInfo *ji);
 136
 137 MonoJitInfo *
 138 mono_jit_info_table_find   (MonoJitInfoTable *table, gpointer addr);
 139
 140 void
 141 arch_handle_exception      (struct sigcontext *ctx, gpointer obj);
 142
 143 gpointer
 144 arch_get_throw_exception   (void);
 145
 146 gpointer
 147 arch_get_throw_exception_by_name (void);
 148
 149 void
 150 mono_jit_abort             (MonoObject *obj);
 151
 152 MonoFlowGraph *
 153 mono_cfg_new               (MonoMethod *method, MonoMemPool *mp);
 154
 155 void
 156 mono_cfg_free              (MonoFlowGraph *cfg);
 157
 158 MBTree *
 159 mono_ctree_new             (MonoMemPool *mp, int op, MBTree *left,
 160                             MBTree *right);
 161 MBTree *
 162 mono_ctree_new_leaf        (MonoMemPool *mp, int op);
 163
 164 void
 165 mono_analyze_flow          (MonoFlowGraph *cfg);
 166
 167 void
 168 mono_analyze_stack         (MonoFlowGraph *cfg);
 169
 170 void
 171 mono_disassemble_code      (guint8 *code, int size, char *id);
 172
 173 gpointer
 174 arch_compile_method        (MonoMethod *method);
 175
 176 gpointer
 177 arch_create_jit_trampoline (MonoMethod *method);
 178
 179 /* some handy debugging functions */
 180
 181 void
 182 mono_print_ctree           (MBTree *tree);
 183
 184 void
 185 mono_print_forest          (GPtrArray *forest);
 186
 187 #endif