mono/mini/tramp-x86.c

   1 /*
   2  * tramp-x86.c: JIT trampoline code for x86
   3  *
   4  * Authors:
   5  *   Dietmar Maurer (dietmar@ximian.com)
   6  *
   7  * (C) 2001 Ximian, Inc.
   8  */
   9
  10 #include <config.h>
  11 #include <glib.h>
  12
  13 #include <mono/metadata/appdomain.h>
  14 #include <mono/metadata/metadata-internals.h>
  15 #include <mono/metadata/marshal.h>
  16 #include <mono/metadata/tabledefs.h>
  17 #include <mono/metadata/mono-debug.h>
  18 #include <mono/metadata/mono-debug-debugger.h>
  19 #include <mono/metadata/monitor.h>
  20 #include <mono/arch/x86/x86-codegen.h>
  21
  22 #include <mono/utils/memcheck.h>
  23
  24 #include "mini.h"
  25 #include "mini-x86.h"
  26
  27 static guint8* nullified_class_init_trampoline;
  28
  29 /*
  30  * mono_arch_get_unbox_trampoline:
  31  * @gsctx: the generic sharing context
  32  * @m: method pointer
  33  * @addr: pointer to native code for @m
  34  *
  35  * when value type methods are called through the vtable we need to unbox the
  36  * this argument. This method returns a pointer to a trampoline which does
  37  * unboxing before calling the method
  38  */
  39 gpointer
  40 mono_arch_get_unbox_trampoline (MonoGenericSharingContext *gsctx, MonoMethod *m, gpointer addr)
  41 {
  42         guint8 *code, *start;
  43         int this_pos = 4;
  44         MonoDomain *domain = mono_domain_get ();
  45
  46         start = code = mono_domain_code_reserve (domain, 16);
  47
  48         x86_alu_membase_imm (code, X86_ADD, X86_ESP, this_pos, sizeof (MonoObject));
  49         x86_jump_code (code, addr);
  50         g_assert ((code - start) < 16);
  51
  52         return start;
  53 }
  54
  55 gpointer
  56 mono_arch_get_static_rgctx_trampoline (MonoMethod *m, MonoMethodRuntimeGenericContext *mrgctx, gpointer addr)
  57 {
  58         guint8 *code, *start;
  59         int buf_len;
  60
  61         MonoDomain *domain = mono_domain_get ();
  62
  63         buf_len = 10;
  64
  65         start = code = mono_domain_code_reserve (domain, buf_len);
  66
  67         x86_mov_reg_imm (code, MONO_ARCH_RGCTX_REG, mrgctx);
  68         x86_jump_code (code, addr);
  69         g_assert ((code - start) <= buf_len);
  70
  71         mono_arch_flush_icache (start, code - start);
  72
  73         return start;
  74 }
  75
  76 gpointer
  77 mono_arch_get_llvm_imt_trampoline (MonoDomain *domain, MonoMethod *m, int vt_offset)
  78 {
  79         guint8 *code, *start;
  80         int buf_len;
  81         int this_offset;
  82
  83         buf_len = 32;
  84
  85         start = code = mono_domain_code_reserve (domain, buf_len);
  86
  87         this_offset = mono_x86_get_this_arg_offset (NULL, mono_method_signature (m));
  88
  89         /* Set imt arg */
  90         x86_mov_reg_imm (code, MONO_ARCH_IMT_REG, m);
  91         /* Load this */
  92         x86_mov_reg_membase (code, X86_EAX, X86_ESP, this_offset + 4, 4);
  93         /* Load vtable address */
  94         x86_mov_reg_membase (code, X86_EAX, X86_EAX, 0, 4);
  95         x86_jump_membase (code, X86_EAX, vt_offset);
  96
  97         g_assert ((code - start) < buf_len);
  98
  99         mono_arch_flush_icache (start, code - start);
 100
 101         return start;
 102 }
 103
 104 void
 105 mono_arch_patch_callsite (guint8 *method_start, guint8 *orig_code, guint8 *addr)
 106 {
 107         guint8 *code;
 108         guint8 buf [8];
 109         gboolean can_write = mono_breakpoint_clean_code (method_start, orig_code, 8, buf, sizeof (buf));
 110
 111         code = buf + 8;
 112
 113         /* go to the start of the call instruction
 114          *
 115          * address_byte = (m << 6) | (o << 3) | reg
 116          * call opcode: 0xff address_byte displacement
 117          * 0xff m=1,o=2 imm8
 118          * 0xff m=2,o=2 imm32
 119          */
 120         code -= 6;
 121         orig_code -= 6;
 122         if ((code [1] == 0xe8)) {
 123                 if (can_write) {
 124                         InterlockedExchange ((gint32*)(orig_code + 2), (guint)addr - ((guint)orig_code + 1) - 5);
 125
 126                         /* Tell valgrind to recompile the patched code */
 127                         VALGRIND_DISCARD_TRANSLATIONS (orig_code + 2, 4);
 128                 }
 129         } else if (code [1] == 0xe9) {
 130                 /* A PLT entry: jmp <DISP> */
 131                 if (can_write)
 132                         InterlockedExchange ((gint32*)(orig_code + 2), (guint)addr - ((guint)orig_code + 1) - 5);
 133         } else {
 134                 printf ("Invalid trampoline sequence: %x %x %x %x %x %x %x\n", code [0], code [1], code [2], code [3],
 135                                 code [4], code [5], code [6]);
 136                 g_assert_not_reached ();
 137         }
 138 }
 139
 140 void
 141 mono_arch_patch_plt_entry (guint8 *code, gpointer *got, mgreg_t *regs, guint8 *addr)
 142 {
 143         guint32 offset;
 144
 145         /* Patch the jump table entry used by the plt entry */
 146
 147 #if defined(__native_client_codegen__) || defined(__native_client__)
 148         /* for both compiler and runtime      */
 149         /* A PLT entry:                       */
 150         /*        mov <DISP>(%ebx), %ecx      */
 151         /*        and 0xffffffe0, %ecx        */
 152         /*        jmp *%ecx                   */
 153         g_assert (code [0] == 0x8b);
 154         g_assert (code [1] == 0x8b);
 155
 156         offset = *(guint32*)(code + 2);
 157 #else
 158         /* A PLT entry: jmp *<DISP>(%ebx) */
 159         g_assert (code [0] == 0xff);
 160         g_assert (code [1] == 0xa3);
 161
 162         offset = *(guint32*)(code + 2);
 163 #endif  /* __native_client_codegen__ */
 164         if (!got)
 165                 got = (gpointer*)(gsize) regs [MONO_ARCH_GOT_REG];
 166         *(guint8**)((guint8*)got + offset) = addr;
 167 }
 168
 169 static gpointer
 170 get_vcall_slot (guint8 *code, mgreg_t *regs, int *displacement)
 171 {
 172         const int kBufSize = NACL_SIZE (8, 16);
 173         guint8 buf [64];
 174         guint8 reg = 0;
 175         gint32 disp = 0;
 176
 177         mono_breakpoint_clean_code (NULL, code, kBufSize, buf, sizeof (buf));
 178         code = buf + 8;
 179
 180         *displacement = 0;
 181
 182         if ((code [0] == 0xff) && ((code [1] & 0x18) == 0x10) && ((code [1] >> 6) == 2)) {
 183                 reg = code [1] & 0x07;
 184                 disp = *((gint32*)(code + 2));
 185 #if defined(__native_client_codegen__) || defined(__native_client__)
 186         } else if ((code[1] == 0x83) && (code[2] == 0xe1) && (code[4] == 0xff) &&
 187                            (code[5] == 0xd1) && (code[-5] == 0x8b)) {
 188                 disp = *((gint32*)(code - 3));
 189                 reg = code[-4] & 0x07;
 190         } else if ((code[-2] == 0x8b) && (code[1] == 0x83) && (code[4] == 0xff)) {
 191                 reg = code[-1] & 0x07;
 192                 disp = (signed char)code[0];
 193 #endif
 194         } else {
 195                 g_assert_not_reached ();
 196                 return NULL;
 197         }
 198
 199         *displacement = disp;
 200         return (gpointer)regs [reg];
 201 }
 202
 203 static gpointer*
 204 get_vcall_slot_addr (guint8* code, mgreg_t *regs)
 205 {
 206         gpointer vt;
 207         int displacement;
 208         vt = get_vcall_slot (code, regs, &displacement);
 209         if (!vt)
 210                 return NULL;
 211         return (gpointer*)((char*)vt + displacement);
 212 }
 213
 214 void
 215 mono_arch_nullify_class_init_trampoline (guint8 *code, mgreg_t *regs)
 216 {
 217         guint8 buf [16];
 218         gboolean can_write = mono_breakpoint_clean_code (NULL, code, 6, buf, sizeof (buf));
 219
 220         if (!can_write)
 221                 return;
 222
 223         code -= 5;
 224         if (code [0] == 0xe8) {
 225                 if (!mono_running_on_valgrind ()) {
 226                         guint32 ops;
 227                         /*
 228                          * Thread safe code patching using the algorithm from the paper
 229                          * 'Practicing JUDO: Java Under Dynamic Optimizations'
 230                          */
 231                         /*
 232                          * First atomically change the the first 2 bytes of the call to a
 233                          * spinning jump.
 234                          */
 235                         ops = 0xfeeb;
 236                         InterlockedExchange ((gint32*)code, ops);
 237
 238                         /* Then change the other bytes to a nop */
 239                         code [2] = 0x90;
 240                         code [3] = 0x90;
 241                         code [4] = 0x90;
 242
 243                         /* Then atomically change the first 4 bytes to a nop as well */
 244                         ops = 0x90909090;
 245                         InterlockedExchange ((gint32*)code, ops);
 246                         /* FIXME: the calltree skin trips on the self modifying code above */
 247
 248                         /* Tell valgrind to recompile the patched code */
 249                         //VALGRIND_DISCARD_TRANSLATIONS (code, 8);
 250                 }
 251         } else if (code [0] == 0x90 || code [0] == 0xeb) {
 252                 /* Already changed by another thread */
 253                 ;
 254         } else if ((code [-1] == 0xff) && (x86_modrm_reg (code [0]) == 0x2)) {
 255                 /* call *<OFFSET>(<REG>) -> Call made from AOT code */
 256                 gpointer *vtable_slot;
 257
 258                 vtable_slot = get_vcall_slot_addr (code + 5, regs);
 259                 g_assert (vtable_slot);
 260
 261                 *vtable_slot = nullified_class_init_trampoline;
 262         } else {
 263                         printf ("Invalid trampoline sequence: %x %x %x %x %x %x %x\n", code [0], code [1], code [2], code [3],
 264                                 code [4], code [5], code [6]);
 265                         g_assert_not_reached ();
 266                 }
 267 }
 268
 269 void
 270 mono_arch_nullify_plt_entry (guint8 *code, mgreg_t *regs)
 271 {
 272         if (mono_aot_only && !nullified_class_init_trampoline)
 273                 nullified_class_init_trampoline = mono_aot_get_trampoline ("nullified_class_init_trampoline");
 274
 275         mono_arch_patch_plt_entry (code, NULL, regs, nullified_class_init_trampoline);
 276 }
 277
 278 guchar*
 279 mono_arch_create_generic_trampoline (MonoTrampolineType tramp_type, MonoTrampInfo **info, gboolean aot)
 280 {
 281         guint8 *buf, *code, *tramp;
 282         int pushed_args, pushed_args_caller_saved;
 283         GSList *unwind_ops = NULL;
 284         MonoJumpInfo *ji = NULL;
 285
 286         unwind_ops = mono_arch_get_cie_program ();
 287
 288         code = buf = mono_global_codeman_reserve (256);
 289
 290         /* Note that there is a single argument to the trampoline
 291          * and it is stored at: esp + pushed_args * sizeof (gpointer)
 292          * the ret address is at: esp + (pushed_args + 1) * sizeof (gpointer)
 293          */
 294
 295         /* Put all registers into an array on the stack
 296          * If this code is changed, make sure to update the offset value in
 297          * mono_arch_get_this_arg_from_call () in mini-x86.c.
 298          */
 299         x86_push_reg (code, X86_EDI);
 300         x86_push_reg (code, X86_ESI);
 301         x86_push_reg (code, X86_EBP);
 302         x86_push_reg (code, X86_ESP);
 303         x86_push_reg (code, X86_EBX);
 304         x86_push_reg (code, X86_EDX);
 305         x86_push_reg (code, X86_ECX);
 306         x86_push_reg (code, X86_EAX);
 307
 308         pushed_args_caller_saved = pushed_args = 8;
 309
 310         /* Align stack on apple */
 311         x86_alu_reg_imm (code, X86_SUB, X86_ESP, 4);
 312
 313         pushed_args ++;
 314
 315         /* save LMF begin */
 316
 317         /* save the IP (caller ip) */
 318         if (tramp_type == MONO_TRAMPOLINE_JUMP)
 319                 x86_push_imm (code, 0);
 320         else
 321                 x86_push_membase (code, X86_ESP, (pushed_args + 1) * sizeof (gpointer));
 322
 323         pushed_args++;
 324
 325         x86_push_reg (code, X86_EBP);
 326         x86_push_reg (code, X86_ESI);
 327         x86_push_reg (code, X86_EDI);
 328         x86_push_reg (code, X86_EBX);
 329
 330         pushed_args += 4;
 331
 332         /* save ESP */
 333         x86_push_reg (code, X86_ESP);
 334         /* Adjust ESP so it points to the previous frame */
 335         x86_alu_membase_imm (code, X86_ADD, X86_ESP, 0, (pushed_args + 2) * 4);
 336
 337         pushed_args ++;
 338
 339         /* save method info */
 340         if ((tramp_type == MONO_TRAMPOLINE_JIT) || (tramp_type == MONO_TRAMPOLINE_JUMP))
 341                 x86_push_membase (code, X86_ESP, pushed_args * sizeof (gpointer));
 342         else
 343                 x86_push_imm (code, 0);
 344
 345         pushed_args++;
 346
 347         /* On apple, the stack is correctly aligned to 16 bytes because pushed_args is
 348          * 16 and there is the extra trampoline arg + the return ip pushed by call
 349          * FIXME: Note that if an exception happens while some args are pushed
 350          * on the stack, the stack will be misaligned.
 351          */
 352         g_assert (pushed_args == 16);
 353
 354         /* get the address of lmf for the current thread */
 355         if (aot) {
 356                 code = mono_arch_emit_load_aotconst (buf, code, &ji, MONO_PATCH_INFO_JIT_ICALL_ADDR, "mono_get_lmf_addr");
 357                 x86_call_reg (code, X86_EAX);
 358         } else {
 359                 x86_call_code (code, mono_get_lmf_addr);
 360         }
 361         /* push lmf */
 362         x86_push_reg (code, X86_EAX);
 363         /* push *lfm (previous_lmf) */
 364         x86_push_membase (code, X86_EAX, 0);
 365         /* Signal to mono_arch_find_jit_info () that this is a trampoline frame */
 366         x86_alu_membase_imm (code, X86_ADD, X86_ESP, 0, 1);
 367         /* *(lmf) = ESP */
 368         x86_mov_membase_reg (code, X86_EAX, 0, X86_ESP, 4);
 369         /* save LFM end */
 370
 371         pushed_args += 2;
 372
 373         /* starting the call sequence */
 374
 375         /* FIXME: Push the trampoline address */
 376         x86_push_imm (code, 0);
 377
 378         pushed_args++;
 379
 380         /* push the method info */
 381         x86_push_membase (code, X86_ESP, pushed_args * sizeof (gpointer));
 382
 383         pushed_args++;
 384
 385         /* push the return address onto the stack */
 386         if (tramp_type == MONO_TRAMPOLINE_JUMP)
 387                 x86_push_imm (code, 0);
 388         else
 389                 x86_push_membase (code, X86_ESP, (pushed_args + 1) * sizeof (gpointer));
 390         pushed_args++;
 391         /* push the address of the register array */
 392         x86_lea_membase (code, X86_EAX, X86_ESP, (pushed_args - 8) * sizeof (gpointer));
 393         x86_push_reg (code, X86_EAX);
 394
 395         pushed_args++;
 396
 397 #ifdef __APPLE__
 398         /* check the stack is aligned after the ret ip is pushed */
 399         /*x86_mov_reg_reg (buf, X86_EDX, X86_ESP, 4);
 400         x86_alu_reg_imm (buf, X86_AND, X86_EDX, 15);
 401         x86_alu_reg_imm (buf, X86_CMP, X86_EDX, 0);
 402         x86_branch_disp (buf, X86_CC_Z, 3, FALSE);
 403         x86_breakpoint (buf);*/
 404 #endif
 405
 406         mono_add_unwind_op_def_cfa (unwind_ops, code, buf, X86_ESP, ((pushed_args + 2) * 4));
 407
 408         if (aot) {
 409                 char *icall_name = g_strdup_printf ("trampoline_func_%d", tramp_type);
 410                 code = mono_arch_emit_load_aotconst (buf, code, &ji, MONO_PATCH_INFO_JIT_ICALL_ADDR, icall_name);
 411                 x86_call_reg (code, X86_EAX);
 412         } else {
 413                 tramp = (guint8*)mono_get_trampoline_func (tramp_type);
 414                 x86_call_code (code, tramp);
 415         }
 416
 417         x86_alu_reg_imm (code, X86_ADD, X86_ESP, 4*4);
 418
 419         pushed_args -= 4;
 420
 421         /* Check for thread interruption */
 422         /* This is not perf critical code so no need to check the interrupt flag */
 423         /* Align the stack on osx */
 424         x86_alu_reg_imm (code, X86_SUB, X86_ESP, 3 * 4);
 425         x86_push_reg (code, X86_EAX);
 426         if (aot) {
 427                 code = mono_arch_emit_load_aotconst (buf, code, &ji, MONO_PATCH_INFO_JIT_ICALL_ADDR, "mono_thread_force_interruption_checkpoint");
 428                 x86_call_reg (code, X86_EAX);
 429         } else {
 430                 x86_call_code (code, (guint8*)mono_thread_force_interruption_checkpoint);
 431         }
 432         x86_pop_reg (code, X86_EAX);
 433         x86_alu_reg_imm (code, X86_ADD, X86_ESP, 3 * 4);
 434
 435         /* Restore LMF */
 436
 437         /* ebx = previous_lmf */
 438         x86_pop_reg (code, X86_EBX);
 439         pushed_args--;
 440         x86_alu_reg_imm (code, X86_SUB, X86_EBX, 1);
 441
 442         /* edi = lmf */
 443         x86_pop_reg (code, X86_EDI);
 444         pushed_args--;
 445
 446         /* *(lmf) = previous_lmf */
 447         x86_mov_membase_reg (code, X86_EDI, 0, X86_EBX, 4);
 448
 449         /* discard method info */
 450         x86_pop_reg (code, X86_ESI);
 451         pushed_args--;
 452
 453         /* discard ESP */
 454         x86_pop_reg (code, X86_ESI);
 455         pushed_args--;
 456
 457         /* restore caller saved regs */
 458         x86_pop_reg (code, X86_EBX);
 459         x86_pop_reg (code, X86_EDI);
 460         x86_pop_reg (code, X86_ESI);
 461         x86_pop_reg (code, X86_EBP);
 462
 463         pushed_args -= 4;
 464
 465         /* discard save IP */
 466         x86_alu_reg_imm (code, X86_ADD, X86_ESP, 4);
 467         pushed_args--;
 468
 469         /* restore LMF end */
 470
 471         if (!MONO_TRAMPOLINE_TYPE_MUST_RETURN (tramp_type)) {
 472                 /*
 473                  * Overwrite the method ptr with the address we need to jump to,
 474                  * to free %eax.
 475                  */
 476                 x86_mov_membase_reg (code, X86_ESP, pushed_args * sizeof (gpointer), X86_EAX, 4);
 477         }
 478
 479         /* Restore caller saved registers */
 480         x86_mov_reg_membase (code, X86_ECX, X86_ESP, (pushed_args - pushed_args_caller_saved + X86_ECX) * 4, 4);
 481         x86_mov_reg_membase (code, X86_EDX, X86_ESP, (pushed_args - pushed_args_caller_saved + X86_EDX) * 4, 4);
 482         if ((tramp_type == MONO_TRAMPOLINE_RESTORE_STACK_PROT) || (tramp_type == MONO_TRAMPOLINE_AOT_PLT))
 483                 x86_mov_reg_membase (code, X86_EAX, X86_ESP, (pushed_args - pushed_args_caller_saved + X86_EAX) * 4, 4);
 484
 485         if (!MONO_TRAMPOLINE_TYPE_MUST_RETURN (tramp_type)) {
 486                 /* Pop saved reg array + stack align */
 487                 x86_alu_reg_imm (code, X86_ADD, X86_ESP, 9 * 4);
 488                 pushed_args -= 9;
 489                 g_assert (pushed_args == 0);
 490         } else {
 491                 /* Pop saved reg array + stack align + method ptr */
 492                 x86_alu_reg_imm (code, X86_ADD, X86_ESP, 10 * 4);
 493                 pushed_args -= 10;
 494
 495                 /* We've popped one more stack item than we've pushed (the
 496                    method ptr argument), so we must end up at -1. */
 497                 g_assert (pushed_args == -1);
 498         }
 499
 500         x86_ret (code);
 501
 502         g_assert ((code - buf) <= 256);
 503
 504         if (info)
 505                 *info = mono_tramp_info_create (mono_get_generic_trampoline_name (tramp_type), buf, code - buf, ji, unwind_ops);
 506
 507         if (tramp_type == MONO_TRAMPOLINE_CLASS_INIT) {
 508                 /* Initialize the nullified class init trampoline used in the AOT case */
 509                 nullified_class_init_trampoline = mono_arch_get_nullified_class_init_trampoline (NULL);
 510         }
 511
 512         return buf;
 513 }
 514
 515 gpointer
 516 mono_arch_get_nullified_class_init_trampoline (MonoTrampInfo **info)
 517 {
 518         guint8 *code, *buf;
 519
 520         code = buf = mono_global_codeman_reserve (16);
 521         x86_ret (code);
 522
 523         mono_arch_flush_icache (buf, code - buf);
 524
 525         if (info)
 526                 *info = mono_tramp_info_create (g_strdup_printf ("nullified_class_init_trampoline"), buf, code - buf, NULL, NULL);
 527
 528         return buf;
 529 }
 530
 531 #define TRAMPOLINE_SIZE 10
 532
 533 gpointer
 534 mono_arch_create_specific_trampoline (gpointer arg1, MonoTrampolineType tramp_type, MonoDomain *domain, guint32 *code_len)
 535 {
 536         guint8 *code, *buf, *tramp;
 537
 538         tramp = mono_get_trampoline_code (tramp_type);
 539
 540         code = buf = mono_domain_code_reserve_align (domain, TRAMPOLINE_SIZE, NACL_SIZE (4, kNaClAlignment));
 541
 542         x86_push_imm (buf, arg1);
 543         x86_jump_code (buf, tramp);
 544         g_assert ((buf - code) <= TRAMPOLINE_SIZE);
 545
 546         mono_arch_flush_icache (code, buf - code);
 547
 548         if (code_len)
 549                 *code_len = buf - code;
 550
 551         return code;
 552 }
 553
 554 gpointer
 555 mono_arch_create_rgctx_lazy_fetch_trampoline (guint32 slot, MonoTrampInfo **info, gboolean aot)
 556 {
 557         guint8 *tramp;
 558         guint8 *code, *buf;
 559         guint8 **rgctx_null_jumps;
 560         int tramp_size;
 561         int depth, index;
 562         int i;
 563         gboolean mrgctx;
 564         MonoJumpInfo *ji = NULL;
 565         GSList *unwind_ops = NULL;
 566
 567         unwind_ops = mono_arch_get_cie_program ();
 568
 569         mrgctx = MONO_RGCTX_SLOT_IS_MRGCTX (slot);
 570         index = MONO_RGCTX_SLOT_INDEX (slot);
 571         if (mrgctx)
 572                 index += MONO_SIZEOF_METHOD_RUNTIME_GENERIC_CONTEXT / sizeof (gpointer);
 573         for (depth = 0; ; ++depth) {
 574                 int size = mono_class_rgctx_get_array_size (depth, mrgctx);
 575
 576                 if (index < size - 1)
 577                         break;
 578                 index -= size - 1;
 579         }
 580
 581 #ifdef __native_client_codegen__
 582         /* TODO: align for Native Client */
 583         tramp_size = (aot ? 64 : 36) + 2 * kNaClAlignment +
 584                 6 * (depth + kNaClAlignment);
 585 #else
 586         tramp_size = (aot ? 64 : 36) + 6 * depth;
 587 #endif  /* __native_client_codegen__ */
 588
 589         code = buf = mono_global_codeman_reserve (tramp_size);
 590
 591         rgctx_null_jumps = g_malloc (sizeof (guint8*) * (depth + 2));
 592
 593         /* load vtable/mrgctx ptr */
 594         x86_mov_reg_membase (code, X86_EAX, X86_ESP, 4, 4);
 595         if (!mrgctx) {
 596                 /* load rgctx ptr from vtable */
 597                 x86_mov_reg_membase (code, X86_EAX, X86_EAX, G_STRUCT_OFFSET (MonoVTable, runtime_generic_context), 4);
 598                 /* is the rgctx ptr null? */
 599                 x86_test_reg_reg (code, X86_EAX, X86_EAX);
 600                 /* if yes, jump to actual trampoline */
 601                 rgctx_null_jumps [0] = code;
 602                 x86_branch8 (code, X86_CC_Z, -1, 1);
 603         }
 604
 605         for (i = 0; i < depth; ++i) {
 606                 /* load ptr to next array */
 607                 if (mrgctx && i == 0)
 608                         x86_mov_reg_membase (code, X86_EAX, X86_EAX, MONO_SIZEOF_METHOD_RUNTIME_GENERIC_CONTEXT, 4);
 609                 else
 610                         x86_mov_reg_membase (code, X86_EAX, X86_EAX, 0, 4);
 611                 /* is the ptr null? */
 612                 x86_test_reg_reg (code, X86_EAX, X86_EAX);
 613                 /* if yes, jump to actual trampoline */
 614                 rgctx_null_jumps [i + 1] = code;
 615                 x86_branch8 (code, X86_CC_Z, -1, 1);
 616         }
 617
 618         /* fetch slot */
 619         x86_mov_reg_membase (code, X86_EAX, X86_EAX, sizeof (gpointer) * (index + 1), 4);
 620         /* is the slot null? */
 621         x86_test_reg_reg (code, X86_EAX, X86_EAX);
 622         /* if yes, jump to actual trampoline */
 623         rgctx_null_jumps [depth + 1] = code;
 624         x86_branch8 (code, X86_CC_Z, -1, 1);
 625         /* otherwise return */
 626         x86_ret (code);
 627
 628         for (i = mrgctx ? 1 : 0; i <= depth + 1; ++i)
 629                 x86_patch (rgctx_null_jumps [i], code);
 630
 631         g_free (rgctx_null_jumps);
 632
 633         x86_mov_reg_membase (code, MONO_ARCH_VTABLE_REG, X86_ESP, 4, 4);
 634
 635         if (aot) {
 636                 code = mono_arch_emit_load_aotconst (buf, code, &ji, MONO_PATCH_INFO_JIT_ICALL_ADDR, g_strdup_printf ("specific_trampoline_lazy_fetch_%u", slot));
 637                 x86_jump_reg (code, X86_EAX);
 638         } else {
 639                 tramp = mono_arch_create_specific_trampoline (GUINT_TO_POINTER (slot), MONO_TRAMPOLINE_RGCTX_LAZY_FETCH, mono_get_root_domain (), NULL);
 640
 641                 /* jump to the actual trampoline */
 642                 x86_jump_code (code, tramp);
 643         }
 644
 645         mono_arch_flush_icache (buf, code - buf);
 646
 647         g_assert (code - buf <= tramp_size);
 648
 649         if (info)
 650                 *info = mono_tramp_info_create (mono_get_rgctx_fetch_trampoline_name (slot), buf, code - buf, ji, unwind_ops);
 651
 652         return buf;
 653 }
 654
 655 gpointer
 656 mono_arch_create_generic_class_init_trampoline (MonoTrampInfo **info, gboolean aot)
 657 {
 658         guint8 *tramp;
 659         guint8 *code, *buf;
 660         static int byte_offset = -1;
 661         static guint8 bitmask;
 662         guint8 *jump;
 663         int tramp_size;
 664         GSList *unwind_ops = NULL;
 665         MonoJumpInfo *ji = NULL;
 666
 667         tramp_size = 64;
 668
 669         code = buf = mono_global_codeman_reserve (tramp_size);
 670
 671         unwind_ops = mono_arch_get_cie_program ();
 672
 673         if (byte_offset < 0)
 674                 mono_marshal_find_bitfield_offset (MonoVTable, initialized, &byte_offset, &bitmask);
 675
 676         x86_test_membase_imm (code, MONO_ARCH_VTABLE_REG, byte_offset, bitmask);
 677         jump = code;
 678         x86_branch8 (code, X86_CC_Z, -1, 1);
 679
 680         x86_ret (code);
 681
 682         x86_patch (jump, code);
 683
 684         /* Push the vtable so the stack is the same as in a specific trampoline */
 685         x86_push_reg (code, MONO_ARCH_VTABLE_REG);
 686
 687         if (aot) {
 688                 code = mono_arch_emit_load_aotconst (buf, code, &ji, MONO_PATCH_INFO_JIT_ICALL_ADDR, "generic_trampoline_generic_class_init");
 689                 x86_jump_reg (code, X86_EAX);
 690         } else {
 691                 tramp = mono_get_trampoline_code (MONO_TRAMPOLINE_GENERIC_CLASS_INIT);
 692
 693                 /* jump to the actual trampoline */
 694                 x86_jump_code (code, tramp);
 695         }
 696
 697         mono_arch_flush_icache (code, code - buf);
 698
 699         g_assert (code - buf <= tramp_size);
 700 #ifdef __native_client_codegen__
 701         g_assert (code - buf <= kNaClAlignment);
 702 #endif
 703         if (info)
 704                 *info = mono_tramp_info_create (g_strdup_printf ("generic_class_init_trampoline"), buf, code - buf, ji, unwind_ops);
 705
 706         return buf;
 707 }
 708
 709 #ifdef MONO_ARCH_MONITOR_OBJECT_REG
 710 /*
 711  * The code produced by this trampoline is equivalent to this:
 712  *
 713  * if (obj) {
 714  *      if (obj->synchronisation) {
 715  *              if (obj->synchronisation->owner == 0) {
 716  *                      if (cmpxch (&obj->synchronisation->owner, TID, 0) == 0)
 717  *                              return;
 718  *              }
 719  *              if (obj->synchronisation->owner == TID) {
 720  *                      ++obj->synchronisation->nest;
 721  *                      return;
 722  *              }
 723  *      }
 724  * }
 725  * return full_monitor_enter ();
 726  *
 727  */
 728 gpointer
 729 mono_arch_create_monitor_enter_trampoline (MonoTrampInfo **info, gboolean aot)
 730 {
 731         guint8 *tramp = mono_get_trampoline_code (MONO_TRAMPOLINE_MONITOR_ENTER);
 732         guint8 *code, *buf;
 733         guint8 *jump_obj_null, *jump_sync_null, *jump_other_owner, *jump_cmpxchg_failed, *jump_tid;
 734         int tramp_size;
 735         int owner_offset, nest_offset, dummy;
 736         MonoJumpInfo *ji = NULL;
 737         GSList *unwind_ops = NULL;
 738
 739         g_assert (MONO_ARCH_MONITOR_OBJECT_REG == X86_EAX);
 740
 741         mono_monitor_threads_sync_members_offset (&owner_offset, &nest_offset, &dummy);
 742         g_assert (MONO_THREADS_SYNC_MEMBER_SIZE (owner_offset) == sizeof (gpointer));
 743         g_assert (MONO_THREADS_SYNC_MEMBER_SIZE (nest_offset) == sizeof (guint32));
 744         owner_offset = MONO_THREADS_SYNC_MEMBER_OFFSET (owner_offset);
 745         nest_offset = MONO_THREADS_SYNC_MEMBER_OFFSET (nest_offset);
 746
 747         tramp_size = NACL_SIZE (64, 128);
 748
 749         code = buf = mono_global_codeman_reserve (tramp_size);
 750
 751         if (mono_thread_get_tls_offset () != -1) {
 752                 /* MonoObject* obj is in EAX */
 753                 /* is obj null? */
 754                 x86_test_reg_reg (code, X86_EAX, X86_EAX);
 755                 /* if yes, jump to actual trampoline */
 756                 jump_obj_null = code;
 757                 x86_branch8 (code, X86_CC_Z, -1, 1);
 758
 759                 /* load obj->synchronization to ECX */
 760                 x86_mov_reg_membase (code, X86_ECX, X86_EAX, G_STRUCT_OFFSET (MonoObject, synchronisation), 4);
 761                 /* is synchronization null? */
 762                 x86_test_reg_reg (code, X86_ECX, X86_ECX);
 763                 /* if yes, jump to actual trampoline */
 764                 jump_sync_null = code;
 765                 x86_branch8 (code, X86_CC_Z, -1, 1);
 766
 767                 /* load MonoInternalThread* into EDX */
 768                 code = mono_x86_emit_tls_get (code, X86_EDX, mono_thread_get_tls_offset ());
 769                 /* load TID into EDX */
 770                 x86_mov_reg_membase (code, X86_EDX, X86_EDX, G_STRUCT_OFFSET (MonoInternalThread, tid), 4);
 771
 772                 /* is synchronization->owner null? */
 773                 x86_alu_membase_imm (code, X86_CMP, X86_ECX, owner_offset, 0);
 774                 /* if not, jump to next case */
 775                 jump_tid = code;
 776                 x86_branch8 (code, X86_CC_NZ, -1, 1);
 777
 778                 /* if yes, try a compare-exchange with the TID */
 779                 /* free up register EAX, needed for the zero */
 780                 x86_push_reg (code, X86_EAX);
 781                 /* zero EAX */
 782                 x86_alu_reg_reg (code, X86_XOR, X86_EAX, X86_EAX);
 783                 /* compare and exchange */
 784                 x86_prefix (code, X86_LOCK_PREFIX);
 785                 x86_cmpxchg_membase_reg (code, X86_ECX, owner_offset, X86_EDX);
 786                 /* if not successful, jump to actual trampoline */
 787                 jump_cmpxchg_failed = code;
 788                 x86_branch8 (code, X86_CC_NZ, -1, 1);
 789                 /* if successful, pop and return */
 790                 x86_pop_reg (code, X86_EAX);
 791                 x86_ret (code);
 792
 793                 /* next case: synchronization->owner is not null */
 794                 x86_patch (jump_tid, code);
 795                 /* is synchronization->owner == TID? */
 796                 x86_alu_membase_reg (code, X86_CMP, X86_ECX, owner_offset, X86_EDX);
 797                 /* if not, jump to actual trampoline */
 798                 jump_other_owner = code;
 799                 x86_branch8 (code, X86_CC_NZ, -1, 1);
 800                 /* if yes, increment nest */
 801                 x86_inc_membase (code, X86_ECX, nest_offset);
 802                 /* return */
 803                 x86_ret (code);
 804
 805                 /* push obj */
 806                 x86_patch (jump_obj_null, code);
 807                 x86_patch (jump_sync_null, code);
 808                 x86_patch (jump_other_owner, code);
 809                 x86_push_reg (code, X86_EAX);
 810                 /* jump to the actual trampoline */
 811                 x86_patch (jump_cmpxchg_failed, code);
 812                 if (aot) {
 813                         /* We are calling the generic trampoline directly, the argument is pushed
 814                          * on the stack just like a specific trampoline.
 815                          */
 816                         code = mono_arch_emit_load_aotconst (buf, code, &ji, MONO_PATCH_INFO_JIT_ICALL_ADDR, "generic_trampoline_monitor_enter");
 817                         x86_jump_reg (code, X86_EAX);
 818                 } else {
 819                         x86_jump_code (code, tramp);
 820                 }
 821         } else {
 822                 /* push obj and jump to the actual trampoline */
 823                 x86_push_reg (code, X86_EAX);
 824                 if (aot) {
 825                         code = mono_arch_emit_load_aotconst (buf, code, &ji, MONO_PATCH_INFO_JIT_ICALL_ADDR, "generic_trampoline_monitor_enter");
 826                         x86_jump_reg (code, X86_EAX);
 827                 } else {
 828                         x86_jump_code (code, tramp);
 829                 }
 830         }
 831
 832         mono_arch_flush_icache (buf, code - buf);
 833         g_assert (code - buf <= tramp_size);
 834
 835         if (info)
 836                 *info = mono_tramp_info_create (g_strdup_printf ("monitor_enter_trampoline"), buf, code - buf, ji, unwind_ops);
 837
 838         return buf;
 839 }
 840
 841 gpointer
 842 mono_arch_create_monitor_exit_trampoline (MonoTrampInfo **info, gboolean aot)
 843 {
 844         guint8 *tramp = mono_get_trampoline_code (MONO_TRAMPOLINE_MONITOR_EXIT);
 845         guint8 *code, *buf;
 846         guint8 *jump_obj_null, *jump_have_waiters, *jump_sync_null, *jump_not_owned;
 847         guint8 *jump_next;
 848         int tramp_size;
 849         int owner_offset, nest_offset, entry_count_offset;
 850         MonoJumpInfo *ji = NULL;
 851         GSList *unwind_ops = NULL;
 852
 853         g_assert (MONO_ARCH_MONITOR_OBJECT_REG == X86_EAX);
 854
 855         mono_monitor_threads_sync_members_offset (&owner_offset, &nest_offset, &entry_count_offset);
 856         g_assert (MONO_THREADS_SYNC_MEMBER_SIZE (owner_offset) == sizeof (gpointer));
 857         g_assert (MONO_THREADS_SYNC_MEMBER_SIZE (nest_offset) == sizeof (guint32));
 858         g_assert (MONO_THREADS_SYNC_MEMBER_SIZE (entry_count_offset) == sizeof (gint32));
 859         owner_offset = MONO_THREADS_SYNC_MEMBER_OFFSET (owner_offset);
 860         nest_offset = MONO_THREADS_SYNC_MEMBER_OFFSET (nest_offset);
 861         entry_count_offset = MONO_THREADS_SYNC_MEMBER_OFFSET (entry_count_offset);
 862
 863         tramp_size = NACL_SIZE (64, 128);
 864
 865         code = buf = mono_global_codeman_reserve (tramp_size);
 866
 867         if (mono_thread_get_tls_offset () != -1) {
 868                 /* MonoObject* obj is in EAX */
 869                 /* is obj null? */
 870                 x86_test_reg_reg (code, X86_EAX, X86_EAX);
 871                 /* if yes, jump to actual trampoline */
 872                 jump_obj_null = code;
 873                 x86_branch8 (code, X86_CC_Z, -1, 1);
 874
 875                 /* load obj->synchronization to ECX */
 876                 x86_mov_reg_membase (code, X86_ECX, X86_EAX, G_STRUCT_OFFSET (MonoObject, synchronisation), 4);
 877                 /* is synchronization null? */
 878                 x86_test_reg_reg (code, X86_ECX, X86_ECX);
 879                 /* if yes, jump to actual trampoline */
 880                 jump_sync_null = code;
 881                 x86_branch8 (code, X86_CC_Z, -1, 1);
 882
 883                 /* next case: synchronization is not null */
 884                 /* load MonoInternalThread* into EDX */
 885                 code = mono_x86_emit_tls_get (code, X86_EDX, mono_thread_get_tls_offset ());
 886                 /* load TID into EDX */
 887                 x86_mov_reg_membase (code, X86_EDX, X86_EDX, G_STRUCT_OFFSET (MonoInternalThread, tid), 4);
 888                 /* is synchronization->owner == TID */
 889                 x86_alu_membase_reg (code, X86_CMP, X86_ECX, owner_offset, X86_EDX);
 890                 /* if no, jump to actual trampoline */
 891                 jump_not_owned = code;
 892                 x86_branch8 (code, X86_CC_NZ, -1, 1);
 893
 894                 /* next case: synchronization->owner == TID */
 895                 /* is synchronization->nest == 1 */
 896                 x86_alu_membase_imm (code, X86_CMP, X86_ECX, nest_offset, 1);
 897                 /* if not, jump to next case */
 898                 jump_next = code;
 899                 x86_branch8 (code, X86_CC_NZ, -1, 1);
 900                 /* if yes, is synchronization->entry_count zero? */
 901                 x86_alu_membase_imm (code, X86_CMP, X86_ECX, entry_count_offset, 0);
 902                 /* if not, jump to actual trampoline */
 903                 jump_have_waiters = code;
 904                 x86_branch8 (code, X86_CC_NZ, -1 , 1);
 905                 /* if yes, set synchronization->owner to null and return */
 906                 x86_mov_membase_imm (code, X86_ECX, owner_offset, 0, 4);
 907                 x86_ret (code);
 908
 909                 /* next case: synchronization->nest is not 1 */
 910                 x86_patch (jump_next, code);
 911                 /* decrease synchronization->nest and return */
 912                 x86_dec_membase (code, X86_ECX, nest_offset);
 913                 x86_ret (code);
 914
 915                 /* push obj and jump to the actual trampoline */
 916                 x86_patch (jump_obj_null, code);
 917                 x86_patch (jump_have_waiters, code);
 918                 x86_patch (jump_not_owned, code);
 919                 x86_patch (jump_sync_null, code);
 920         }
 921
 922         /* push obj and jump to the actual trampoline */
 923         x86_push_reg (code, X86_EAX);
 924         if (aot) {
 925                 code = mono_arch_emit_load_aotconst (buf, code, &ji, MONO_PATCH_INFO_JIT_ICALL_ADDR, "generic_trampoline_monitor_exit");
 926                 x86_jump_reg (code, X86_EAX);
 927         } else {
 928                 x86_jump_code (code, tramp);
 929         }
 930
 931         mono_arch_flush_icache (buf, code - buf);
 932         g_assert (code - buf <= tramp_size);
 933
 934         if (info)
 935                 *info = mono_tramp_info_create (g_strdup_printf ("monitor_exit_trampoline"), buf, code - buf, ji, unwind_ops);
 936
 937         return buf;
 938 }
 939
 940 #else
 941
 942 gpointer
 943 mono_arch_create_monitor_enter_trampoline (MonoTrampInfo **info, gboolean aot)
 944 {
 945         g_assert_not_reached ();
 946         return NULL;
 947 }
 948
 949 gpointer
 950 mono_arch_create_monitor_exit_trampoline (MonoTrampInfo **info, gboolean aot)
 951 {
 952         g_assert_not_reached ();
 953         return NULL;
 954 }
 955
 956 #endif
 957
 958 void
 959 mono_arch_invalidate_method (MonoJitInfo *ji, void *func, gpointer func_arg)
 960 {
 961         /* FIXME: This is not thread safe */
 962         guint8 *code = ji->code_start;
 963
 964         x86_push_imm (code, func_arg);
 965         x86_call_code (code, (guint8*)func);
 966 }
 967
 968 static void
 969 handler_block_trampoline_helper (gpointer *ptr)
 970 {
 971         MonoJitTlsData *jit_tls = TlsGetValue (mono_jit_tls_id);
 972         *ptr = jit_tls->handler_block_return_address;
 973 }
 974
 975 gpointer
 976 mono_arch_create_handler_block_trampoline (void)
 977 {
 978         guint8 *tramp = mono_get_trampoline_code (MONO_TRAMPOLINE_HANDLER_BLOCK_GUARD);
 979         guint8 *code, *buf;
 980         int tramp_size = 64;
 981         code = buf = mono_global_codeman_reserve (tramp_size);
 982
 983         /*
 984         This trampoline restore the call chain of the handler block then jumps into the code that deals with it.
 985         */
 986
 987         if (mono_get_jit_tls_offset () != -1) {
 988                 code = mono_x86_emit_tls_get (code, X86_EAX, mono_get_jit_tls_offset ());
 989                 x86_mov_reg_membase (code, X86_EAX, X86_EAX, G_STRUCT_OFFSET (MonoJitTlsData, handler_block_return_address), 4);
 990                 /*simulate a call*/
 991                 x86_push_reg (code, X86_EAX);
 992                 x86_jump_code (code, tramp);
 993         } else {
 994                 /*Slow path uses a c helper*/
 995                 x86_push_reg (code, X86_ESP);
 996                 x86_push_imm (code, tramp);
 997                 x86_jump_code (code, handler_block_trampoline_helper);
 998         }
 999
1000         mono_arch_flush_icache (buf, code - buf);
1001         g_assert (code - buf <= tramp_size);
1002
1003         return buf;
1004 }
1005
1006 guint8*
1007 mono_arch_get_call_target (guint8 *code)
1008 {
1009         if (code [-5] == 0xe8) {
1010                 guint32 disp = *(guint32*)(code - 4);
1011                 guint8 *target = code + disp;
1012
1013                 return target;
1014         } else {
1015                 return NULL;
1016         }
1017 }
1018
1019 guint32
1020 mono_arch_get_plt_info_offset (guint8 *plt_entry, mgreg_t *regs, guint8 *code)
1021 {
1022         return *(guint32*)(plt_entry + NACL_SIZE (6, 12));
1023 }