mono/mini/tramp-amd64.c

   1 /*
   2  * tramp-amd64.c: JIT trampoline code for amd64
   3  *
   4  * Authors:
   5  *   Dietmar Maurer (dietmar@ximian.com)
   6  *   Zoltan Varga (vargaz@gmail.com)
   7  *
   8  * (C) 2001 Ximian, Inc.
   9  * Copyright 2003-2011 Novell, Inc (http://www.novell.com)
  10  * Copyright 2011 Xamarin, Inc (http://www.xamarin.com)
  11  */
  12
  13 #include <config.h>
  14 #include <glib.h>
  15
  16 #include <mono/metadata/abi-details.h>
  17 #include <mono/metadata/appdomain.h>
  18 #include <mono/metadata/marshal.h>
  19 #include <mono/metadata/tabledefs.h>
  20 #include <mono/metadata/mono-debug-debugger.h>
  21 #include <mono/metadata/profiler-private.h>
  22 #include <mono/metadata/gc-internal.h>
  23 #include <mono/arch/amd64/amd64-codegen.h>
  24
  25 #include <mono/utils/memcheck.h>
  26
  27 #include "mini.h"
  28 #include "mini-amd64.h"
  29 #include "debugger-agent.h"
  30
  31 #if defined(__native_client_codegen__) && defined(__native_client__)
  32 #include <malloc.h>
  33 #include <nacl/nacl_dyncode.h>
  34 #endif
  35
  36 #define ALIGN_TO(val,align) ((((guint64)val) + ((align) - 1)) & ~((align) - 1))
  37
  38 #define IS_REX(inst) (((inst) >= 0x40) && ((inst) <= 0x4f))
  39
  40 /*
  41  * mono_arch_get_unbox_trampoline:
  42  * @m: method pointer
  43  * @addr: pointer to native code for @m
  44  *
  45  * when value type methods are called through the vtable we need to unbox the
  46  * this argument. This method returns a pointer to a trampoline which does
  47  * unboxing before calling the method
  48  */
  49 gpointer
  50 mono_arch_get_unbox_trampoline (MonoMethod *m, gpointer addr)
  51 {
  52         guint8 *code, *start;
  53         GSList *unwind_ops;
  54         int this_reg, size = NACL_SIZE (20, 32);
  55
  56         MonoDomain *domain = mono_domain_get ();
  57
  58         this_reg = mono_arch_get_this_arg_reg (NULL);
  59
  60         start = code = mono_domain_code_reserve (domain, size);
  61
  62         unwind_ops = mono_arch_get_cie_program ();
  63
  64         amd64_alu_reg_imm (code, X86_ADD, this_reg, sizeof (MonoObject));
  65         /* FIXME: Optimize this */
  66         amd64_mov_reg_imm (code, AMD64_RAX, addr);
  67         amd64_jump_reg (code, AMD64_RAX);
  68         g_assert ((code - start) < size);
  69
  70         nacl_domain_code_validate (domain, &start, size, &code);
  71
  72         mono_arch_flush_icache (start, code - start);
  73         mono_profiler_code_buffer_new (start, code - start, MONO_PROFILER_CODE_BUFFER_UNBOX_TRAMPOLINE, m);
  74
  75         mono_tramp_info_register (mono_tramp_info_create (NULL, start, code - start, NULL, unwind_ops), domain);
  76
  77         return start;
  78 }
  79
  80 /*
  81  * mono_arch_get_static_rgctx_trampoline:
  82  *
  83  *   Create a trampoline which sets RGCTX_REG to MRGCTX, then jumps to ADDR.
  84  */
  85 gpointer
  86 mono_arch_get_static_rgctx_trampoline (MonoMethod *m, MonoMethodRuntimeGenericContext *mrgctx, gpointer addr)
  87 {
  88         guint8 *code, *start;
  89         GSList *unwind_ops;
  90         int buf_len;
  91
  92         MonoDomain *domain = mono_domain_get ();
  93
  94 #ifdef MONO_ARCH_NOMAP32BIT
  95         buf_len = 32;
  96 #else
  97         /* AOTed code could still have a non-32 bit address */
  98         if ((((guint64)addr) >> 32) == 0)
  99                 buf_len = NACL_SIZE (16, 32);
 100         else
 101                 buf_len = NACL_SIZE (30, 32);
 102 #endif
 103
 104         start = code = mono_domain_code_reserve (domain, buf_len);
 105
 106         unwind_ops = mono_arch_get_cie_program ();
 107
 108         amd64_mov_reg_imm (code, MONO_ARCH_RGCTX_REG, mrgctx);
 109         amd64_jump_code (code, addr);
 110         g_assert ((code - start) < buf_len);
 111
 112         nacl_domain_code_validate (domain, &start, buf_len, &code);
 113         mono_arch_flush_icache (start, code - start);
 114         mono_profiler_code_buffer_new (start, code - start, MONO_PROFILER_CODE_BUFFER_GENERICS_TRAMPOLINE, NULL);
 115
 116         mono_tramp_info_register (mono_tramp_info_create (NULL, start, code - start, NULL, unwind_ops), domain);
 117
 118         return start;
 119 }
 120
 121 gpointer
 122 mono_arch_get_llvm_imt_trampoline (MonoDomain *domain, MonoMethod *m, int vt_offset)
 123 {
 124         guint8 *code, *start;
 125         int buf_len;
 126         int this_reg;
 127
 128         buf_len = 32;
 129
 130         start = code = mono_domain_code_reserve (domain, buf_len);
 131
 132         this_reg = mono_arch_get_this_arg_reg (NULL);
 133
 134         /* Set imt arg */
 135         amd64_mov_reg_imm (code, MONO_ARCH_IMT_REG, m);
 136         /* Load vtable address */
 137         amd64_mov_reg_membase (code, AMD64_RAX, this_reg, 0, 8);
 138         amd64_jump_membase (code, AMD64_RAX, vt_offset);
 139         amd64_ret (code);
 140
 141         g_assert ((code - start) < buf_len);
 142
 143         nacl_domain_code_validate (domain, &start, buf_len, &code);
 144
 145         mono_arch_flush_icache (start, code - start);
 146         mono_profiler_code_buffer_new (start, code - start, MONO_PROFILER_CODE_BUFFER_IMT_TRAMPOLINE, NULL);
 147
 148         return start;
 149 }
 150
 151 /*
 152  * mono_arch_patch_callsite:
 153  *
 154  *   Patch the callsite whose address is given by ORIG_CODE so it calls ADDR. ORIG_CODE
 155  * points to the pc right after the call.
 156  */
 157 void
 158 mono_arch_patch_callsite (guint8 *method_start, guint8 *orig_code, guint8 *addr)
 159 {
 160 #if defined(__default_codegen__)
 161         guint8 *code;
 162         guint8 buf [16];
 163         gboolean can_write = mono_breakpoint_clean_code (method_start, orig_code, 14, buf, sizeof (buf));
 164
 165         code = buf + 14;
 166
 167         /* mov 64-bit imm into r11 (followed by call reg?)  or direct call*/
 168         if (((code [-13] == 0x49) && (code [-12] == 0xbb)) || (code [-5] == 0xe8)) {
 169                 if (code [-5] != 0xe8) {
 170                         if (can_write) {
 171                                 InterlockedExchangePointer ((gpointer*)(orig_code - 11), addr);
 172                                 VALGRIND_DISCARD_TRANSLATIONS (orig_code - 11, sizeof (gpointer));
 173                         }
 174                 } else {
 175                         gboolean disp_32bit = ((((gint64)addr - (gint64)orig_code)) < (1 << 30)) && ((((gint64)addr - (gint64)orig_code)) > -(1 << 30));
 176
 177                         if ((((guint64)(addr)) >> 32) != 0 && !disp_32bit) {
 178                                 /*
 179                                  * This might happen with LLVM or when calling AOTed code. Create a thunk.
 180                                  */
 181                                 guint8 *thunk_start, *thunk_code;
 182
 183                                 thunk_start = thunk_code = mono_domain_code_reserve (mono_domain_get (), 32);
 184                                 amd64_jump_membase (thunk_code, AMD64_RIP, 0);
 185                                 *(guint64*)thunk_code = (guint64)addr;
 186                                 addr = thunk_start;
 187                                 g_assert ((((guint64)(addr)) >> 32) == 0);
 188                                 mono_arch_flush_icache (thunk_start, thunk_code - thunk_start);
 189                                 mono_profiler_code_buffer_new (thunk_start, thunk_code - thunk_start, MONO_PROFILER_CODE_BUFFER_HELPER, NULL);
 190                         }
 191                         if (can_write) {
 192                                 InterlockedExchange ((gint32*)(orig_code - 4), ((gint64)addr - (gint64)orig_code));
 193                                 VALGRIND_DISCARD_TRANSLATIONS (orig_code - 5, 4);
 194                         }
 195                 }
 196         }
 197         else if ((code [-7] == 0x41) && (code [-6] == 0xff) && (code [-5] == 0x15)) {
 198                 /* call *<OFFSET>(%rip) */
 199                 gpointer *got_entry = (gpointer*)((guint8*)orig_code + (*(guint32*)(orig_code - 4)));
 200                 if (can_write) {
 201                         InterlockedExchangePointer (got_entry, addr);
 202                         VALGRIND_DISCARD_TRANSLATIONS (orig_code - 5, sizeof (gpointer));
 203                 }
 204         }
 205 #elif defined(__native_client__)
 206         /* These are essentially the same 2 cases as above, modified for NaCl*/
 207
 208         /* Target must be bundle-aligned */
 209         g_assert (((guint32)addr & kNaClAlignmentMask) == 0);
 210         /* Return target must be bundle-aligned */
 211         g_assert (((guint32)orig_code & kNaClAlignmentMask) == 0);
 212
 213         if (orig_code[-5] == 0xe8) {
 214                 /* Direct call */
 215                 int ret;
 216                 gint32 offset = (gint32)addr - (gint32)orig_code;
 217                 guint8 buf[sizeof(gint32)];
 218                 *((gint32*)(buf)) = offset;
 219                 ret = nacl_dyncode_modify (orig_code - sizeof(gint32), buf, sizeof(gint32));
 220                 g_assert (ret == 0);
 221         }
 222
 223         else if (is_nacl_call_reg_sequence (orig_code - 10) && orig_code[-16] == 0x41 && orig_code[-15] == 0xbb) {
 224                 int ret;
 225                 guint8 buf[sizeof(gint32)];
 226                 *((gint32 *)(buf)) = addr;
 227                 /* orig_code[-14] is the start of the immediate. */
 228                 ret = nacl_dyncode_modify (orig_code - 14, buf, sizeof(gint32));
 229                 g_assert (ret == 0);
 230         }
 231         else {
 232                 g_assert_not_reached ();
 233         }
 234
 235         return;
 236 #endif
 237 }
 238
 239 guint8*
 240 mono_arch_create_llvm_native_thunk (MonoDomain *domain, guint8 *addr)
 241 {
 242         /*
 243          * The caller is LLVM code and the call displacement might exceed 32 bits. We can't determine the caller address, so
 244          * we add a thunk every time.
 245          * Since the caller is also allocated using the domain code manager, hopefully the displacement will fit into 32 bits.
 246          * FIXME: Avoid this if possible if !MONO_ARCH_NOMAP32BIT and ADDR is 32 bits.
 247          */
 248         guint8 *thunk_start, *thunk_code;
 249
 250         thunk_start = thunk_code = mono_domain_code_reserve (mono_domain_get (), 32);
 251         amd64_jump_membase (thunk_code, AMD64_RIP, 0);
 252         *(guint64*)thunk_code = (guint64)addr;
 253         addr = thunk_start;
 254         mono_arch_flush_icache (thunk_start, thunk_code - thunk_start);
 255         mono_profiler_code_buffer_new (thunk_start, thunk_code - thunk_start, MONO_PROFILER_CODE_BUFFER_HELPER, NULL);
 256         return addr;
 257 }
 258
 259 void
 260 mono_arch_patch_plt_entry (guint8 *code, gpointer *got, mgreg_t *regs, guint8 *addr)
 261 {
 262         gint32 disp;
 263         gpointer *plt_jump_table_entry;
 264
 265 #if defined(__default_codegen__)
 266         /* A PLT entry: jmp *<DISP>(%rip) */
 267         g_assert (code [0] == 0xff);
 268         g_assert (code [1] == 0x25);
 269
 270         disp = *(gint32*)(code + 2);
 271
 272         plt_jump_table_entry = (gpointer*)(code + 6 + disp);
 273 #elif defined(__native_client_codegen__)
 274         /* A PLT entry:            */
 275         /* mov <DISP>(%rip), %r11d */
 276         /* nacljmp *%r11           */
 277
 278         /* Verify the 'mov' */
 279         g_assert (code [0] == 0x45);
 280         g_assert (code [1] == 0x8b);
 281         g_assert (code [2] == 0x1d);
 282
 283         disp = *(gint32*)(code + 3);
 284
 285         /* 7 = 3 (mov opcode) + 4 (disp) */
 286         /* This needs to resolve to the target of the RIP-relative offset */
 287         plt_jump_table_entry = (gpointer*)(code + 7 + disp);
 288
 289 #endif /* __native_client_codegen__ */
 290
 291         InterlockedExchangePointer (plt_jump_table_entry, addr);
 292 }
 293
 294 static void
 295 stack_unaligned (MonoTrampolineType tramp_type)
 296 {
 297         printf ("%d\n", tramp_type);
 298         g_assert_not_reached ();
 299 }
 300
 301 guchar*
 302 mono_arch_create_generic_trampoline (MonoTrampolineType tramp_type, MonoTrampInfo **info, gboolean aot)
 303 {
 304         char *tramp_name;
 305         guint8 *buf, *code, *tramp, *br [2], *r11_save_code, *after_r11_save_code;
 306         int i, lmf_offset, offset, res_offset, arg_offset, rax_offset, tramp_offset, ctx_offset, saved_regs_offset;
 307         int r11_save_offset, saved_fpregs_offset, rbp_offset, framesize, orig_rsp_to_rbp_offset, cfa_offset;
 308         gboolean has_caller;
 309         GSList *unwind_ops = NULL;
 310         MonoJumpInfo *ji = NULL;
 311         const guint kMaxCodeSize = NACL_SIZE (600, 600*2);
 312
 313 #if defined(__native_client_codegen__)
 314         const guint kNaClTrampOffset = 17;
 315 #endif
 316
 317         if (tramp_type == MONO_TRAMPOLINE_JUMP || tramp_type == MONO_TRAMPOLINE_HANDLER_BLOCK_GUARD)
 318                 has_caller = FALSE;
 319         else
 320                 has_caller = TRUE;
 321
 322         code = buf = mono_global_codeman_reserve (kMaxCodeSize);
 323
 324         /* Compute stack frame size and offsets */
 325         offset = 0;
 326         rbp_offset = -offset;
 327
 328         offset += sizeof(mgreg_t);
 329         rax_offset = -offset;
 330
 331         offset += sizeof(mgreg_t);
 332         r11_save_offset = -offset;
 333
 334         offset += sizeof(mgreg_t);
 335         tramp_offset = -offset;
 336
 337         offset += sizeof(gpointer);
 338         arg_offset = -offset;
 339
 340         offset += sizeof(mgreg_t);
 341         res_offset = -offset;
 342
 343         offset += sizeof (MonoContext);
 344         ctx_offset = -offset;
 345         saved_regs_offset = ctx_offset + MONO_STRUCT_OFFSET (MonoContext, gregs);
 346         saved_fpregs_offset = ctx_offset + MONO_STRUCT_OFFSET (MonoContext, fregs);
 347
 348         offset += sizeof (MonoLMFTramp);
 349         lmf_offset = -offset;
 350
 351 #ifdef TARGET_WIN32
 352         /* Reserve space where the callee can save the argument registers */
 353         offset += 4 * sizeof (mgreg_t);
 354 #endif
 355
 356         framesize = ALIGN_TO (offset, MONO_ARCH_FRAME_ALIGNMENT);
 357
 358         // CFA = sp + 16 (the trampoline address is on the stack)
 359         cfa_offset = 16;
 360         mono_add_unwind_op_def_cfa (unwind_ops, code, buf, AMD64_RSP, 16);
 361         // IP saved at CFA - 8
 362         mono_add_unwind_op_offset (unwind_ops, code, buf, AMD64_RIP, -8);
 363
 364         orig_rsp_to_rbp_offset = 0;
 365         r11_save_code = code;
 366         /* Reserve space for the mov_membase_reg to save R11 */
 367         code += 5;
 368         after_r11_save_code = code;
 369
 370         /* Pop the return address off the stack */
 371         amd64_pop_reg (code, AMD64_R11);
 372         orig_rsp_to_rbp_offset += sizeof(mgreg_t);
 373
 374         cfa_offset -= sizeof(mgreg_t);
 375         mono_add_unwind_op_def_cfa_offset (unwind_ops, code, buf, cfa_offset);
 376
 377         /*
 378          * Allocate a new stack frame
 379          */
 380         amd64_push_reg (code, AMD64_RBP);
 381         cfa_offset += sizeof(mgreg_t);
 382         mono_add_unwind_op_def_cfa_offset (unwind_ops, code, buf, cfa_offset);
 383         mono_add_unwind_op_offset (unwind_ops, code, buf, AMD64_RBP, - cfa_offset);
 384
 385         orig_rsp_to_rbp_offset -= sizeof(mgreg_t);
 386         amd64_mov_reg_reg (code, AMD64_RBP, AMD64_RSP, sizeof(mgreg_t));
 387         mono_add_unwind_op_def_cfa_reg (unwind_ops, code, buf, AMD64_RBP);
 388         amd64_alu_reg_imm (code, X86_SUB, AMD64_RSP, framesize);
 389
 390         /* Compute the trampoline address from the return address */
 391         if (aot) {
 392 #if defined(__default_codegen__)
 393                 /* 7 = length of call *<offset>(rip) */
 394                 amd64_alu_reg_imm (code, X86_SUB, AMD64_R11, 7);
 395 #elif defined(__native_client_codegen__)
 396                 amd64_alu_reg_imm (code, X86_SUB, AMD64_R11, kNaClTrampOffset);
 397 #endif
 398         } else {
 399                 /* 5 = length of amd64_call_membase () */
 400                 amd64_alu_reg_imm (code, X86_SUB, AMD64_R11, 5);
 401         }
 402         amd64_mov_membase_reg (code, AMD64_RBP, tramp_offset, AMD64_R11, sizeof(gpointer));
 403
 404         /* Save all registers */
 405         for (i = 0; i < AMD64_NREG; ++i) {
 406                 if (i == AMD64_RBP) {
 407                         /* RAX is already saved */
 408                         amd64_mov_reg_membase (code, AMD64_RAX, AMD64_RBP, rbp_offset, sizeof(mgreg_t));
 409                         amd64_mov_membase_reg (code, AMD64_RBP, saved_regs_offset + (i * sizeof(mgreg_t)), AMD64_RAX, sizeof(mgreg_t));
 410                 } else if (i == AMD64_RIP) {
 411                         if (has_caller)
 412                                 amd64_mov_reg_membase (code, AMD64_R11, AMD64_RBP, 8, sizeof(gpointer));
 413                         else
 414                                 amd64_mov_reg_imm (code, AMD64_R11, 0);
 415                         amd64_mov_membase_reg (code, AMD64_RBP, saved_regs_offset + (i * sizeof(mgreg_t)), AMD64_R11, sizeof(mgreg_t));
 416                 } else if (i == AMD64_RSP) {
 417                         amd64_mov_reg_reg (code, AMD64_R11, AMD64_RSP, sizeof(mgreg_t));
 418                         amd64_alu_reg_imm (code, X86_ADD, AMD64_R11, framesize + 16);
 419                         amd64_mov_membase_reg (code, AMD64_RBP, saved_regs_offset + (i * sizeof(mgreg_t)), AMD64_R11, sizeof(mgreg_t));
 420                 } else if (i != AMD64_R11) {
 421                         amd64_mov_membase_reg (code, AMD64_RBP, saved_regs_offset + (i * sizeof(mgreg_t)), i, sizeof(mgreg_t));
 422                 } else {
 423                         /* We have to save R11 right at the start of
 424                            the trampoline code because it's used as a
 425                            scratch register */
 426                         /* This happens before the frame is set up, so it goes into the redzone */
 427                         amd64_mov_membase_reg (r11_save_code, AMD64_RSP, r11_save_offset + orig_rsp_to_rbp_offset, i, sizeof(mgreg_t));
 428                         g_assert (r11_save_code == after_r11_save_code);
 429
 430                         /* Copy from the save slot into the register array slot */
 431                         amd64_mov_reg_membase (code, i, AMD64_RSP, r11_save_offset + orig_rsp_to_rbp_offset, sizeof(mgreg_t));
 432                         amd64_mov_membase_reg (code, AMD64_RBP, saved_regs_offset + (i * sizeof(mgreg_t)), i, sizeof(mgreg_t));
 433                 }
 434         }
 435         for (i = 0; i < 8; ++i)
 436                 amd64_movsd_membase_reg (code, AMD64_RBP, saved_fpregs_offset + (i * sizeof(mgreg_t)), i);
 437
 438         /* Check that the stack is aligned */
 439 #if defined(__default_codegen__)
 440         amd64_mov_reg_reg (code, AMD64_R11, AMD64_RSP, sizeof (mgreg_t));
 441         amd64_alu_reg_imm (code, X86_AND, AMD64_R11, 15);
 442         amd64_alu_reg_imm (code, X86_CMP, AMD64_R11, 0);
 443         br [0] = code;
 444         amd64_branch_disp (code, X86_CC_Z, 0, FALSE);
 445         if (aot) {
 446                 amd64_mov_reg_imm (code, AMD64_R11, 0);
 447                 amd64_mov_reg_membase (code, AMD64_R11, AMD64_R11, 0, 8);
 448         } else {
 449                 amd64_mov_reg_imm (code, MONO_AMD64_ARG_REG1, tramp_type);
 450                 amd64_mov_reg_imm (code, AMD64_R11, stack_unaligned);
 451                 amd64_call_reg (code, AMD64_R11);
 452         }
 453         mono_amd64_patch (br [0], code);
 454         //amd64_breakpoint (code);
 455 #endif
 456
 457         if (tramp_type != MONO_TRAMPOLINE_HANDLER_BLOCK_GUARD) {
 458                 /* Obtain the trampoline argument which is encoded in the instruction stream */
 459                 if (aot) {
 460                         /* Load the GOT offset */
 461                         amd64_mov_reg_membase (code, AMD64_R11, AMD64_RBP, tramp_offset, sizeof(gpointer));
 462 #if defined(__default_codegen__)
 463                         /*
 464                          * r11 points to a call *<offset>(%rip) instruction, load the
 465                          * pc-relative offset from the instruction itself.
 466                          */
 467                         amd64_mov_reg_membase (code, AMD64_RAX, AMD64_R11, 3, 4);
 468                         /* 7 is the length of the call, 8 is the offset to the next got slot */
 469                         amd64_alu_reg_imm_size (code, X86_ADD, AMD64_RAX, 7 + sizeof (gpointer), sizeof(gpointer));
 470 #elif defined(__native_client_codegen__)
 471                         /* The arg is hidden in a "push imm32" instruction, */
 472                         /* add one to skip the opcode.                      */
 473                         amd64_mov_reg_membase (code, AMD64_RAX, AMD64_R11, kNaClTrampOffset+1, 4);
 474 #endif
 475                         /* Compute the address of the GOT slot */
 476                         amd64_alu_reg_reg_size (code, X86_ADD, AMD64_R11, AMD64_RAX, sizeof(gpointer));
 477                         /* Load the value */
 478                         amd64_mov_reg_membase (code, AMD64_R11, AMD64_R11, 0, sizeof(gpointer));
 479                 } else {
 480                         amd64_mov_reg_membase (code, AMD64_R11, AMD64_RBP, tramp_offset, sizeof(gpointer));
 481 #if defined(__default_codegen__)
 482                         amd64_mov_reg_membase (code, AMD64_RAX, AMD64_R11, 5, 1);
 483                         amd64_widen_reg (code, AMD64_RAX, AMD64_RAX, TRUE, FALSE);
 484                         amd64_alu_reg_imm_size (code, X86_CMP, AMD64_RAX, 4, 1);
 485                         br [0] = code;
 486                         x86_branch8 (code, X86_CC_NE, 6, FALSE);
 487                         /* 32 bit immediate */
 488                         amd64_mov_reg_membase (code, AMD64_R11, AMD64_R11, 6, 4);
 489                         br [1] = code;
 490                         x86_jump8 (code, 10);
 491                         /* 64 bit immediate */
 492                         mono_amd64_patch (br [0], code);
 493                         amd64_mov_reg_membase (code, AMD64_R11, AMD64_R11, 6, 8);
 494                         mono_amd64_patch (br [1], code);
 495 #elif defined(__native_client_codegen__)
 496                         /* All args are 32-bit pointers in NaCl */
 497                         amd64_mov_reg_membase (code, AMD64_R11, AMD64_R11, 6, 4);
 498 #endif
 499                 }
 500                 amd64_mov_membase_reg (code, AMD64_RBP, arg_offset, AMD64_R11, sizeof(gpointer));
 501         } else {
 502                 amd64_mov_reg_membase (code, AMD64_R11, AMD64_RBP, saved_regs_offset + (MONO_AMD64_ARG_REG1 * sizeof(mgreg_t)), sizeof(mgreg_t));
 503                 amd64_mov_membase_reg (code, AMD64_RBP, arg_offset, AMD64_R11, sizeof(gpointer));
 504         }
 505
 506         /* Save LMF begin */
 507
 508         /* Save ip */
 509         if (has_caller)
 510                 amd64_mov_reg_membase (code, AMD64_R11, AMD64_RBP, 8, sizeof(gpointer));
 511         else
 512                 amd64_mov_reg_imm (code, AMD64_R11, 0);
 513         amd64_mov_membase_reg (code, AMD64_RBP, lmf_offset + MONO_STRUCT_OFFSET (MonoLMF, rip), AMD64_R11, sizeof(mgreg_t));
 514         /* Save sp */
 515         amd64_mov_reg_reg (code, AMD64_R11, AMD64_RSP, sizeof(mgreg_t));
 516         amd64_alu_reg_imm (code, X86_ADD, AMD64_R11, framesize + 16);
 517         amd64_mov_membase_reg (code, AMD64_RBP, lmf_offset + MONO_STRUCT_OFFSET (MonoLMF, rsp), AMD64_R11, sizeof(mgreg_t));
 518         /* Save pointer to context */
 519         amd64_lea_membase (code, AMD64_R11, AMD64_RBP, ctx_offset);
 520         amd64_mov_membase_reg (code, AMD64_RBP, lmf_offset + MONO_STRUCT_OFFSET (MonoLMFTramp, ctx), AMD64_R11, sizeof(mgreg_t));
 521
 522         if (aot) {
 523                 code = mono_arch_emit_load_aotconst (buf, code, &ji, MONO_PATCH_INFO_JIT_ICALL_ADDR, "mono_get_lmf_addr");
 524         } else {
 525                 amd64_mov_reg_imm (code, AMD64_R11, mono_get_lmf_addr);
 526         }
 527         amd64_call_reg (code, AMD64_R11);
 528
 529         /* Save lmf_addr */
 530         amd64_mov_membase_reg (code, AMD64_RBP, lmf_offset + MONO_STRUCT_OFFSET (MonoLMFTramp, lmf_addr), AMD64_RAX, sizeof(gpointer));
 531         /* Save previous_lmf */
 532         /* Set the lowest bit to signal that this LMF has the ip field set */
 533         /* Set the third lowest bit to signal that this is a MonoLMFTramp structure */
 534         amd64_mov_reg_membase (code, AMD64_R11, AMD64_RAX, 0, sizeof(gpointer));
 535         amd64_alu_reg_imm_size (code, X86_ADD, AMD64_R11, 0x5, sizeof(gpointer));
 536         amd64_mov_membase_reg (code, AMD64_RBP, lmf_offset + MONO_STRUCT_OFFSET (MonoLMF, previous_lmf), AMD64_R11, sizeof(gpointer));
 537         /* Set new lmf */
 538         amd64_lea_membase (code, AMD64_R11, AMD64_RBP, lmf_offset);
 539         amd64_mov_membase_reg (code, AMD64_RAX, 0, AMD64_R11, sizeof(gpointer));
 540
 541         /* Save LMF end */
 542
 543         /* Arg1 is the pointer to the saved registers */
 544         amd64_lea_membase (code, AMD64_ARG_REG1, AMD64_RBP, saved_regs_offset);
 545
 546         /* Arg2 is the address of the calling code */
 547         if (has_caller)
 548                 amd64_mov_reg_membase (code, AMD64_ARG_REG2, AMD64_RBP, 8, sizeof(gpointer));
 549         else
 550                 amd64_mov_reg_imm (code, AMD64_ARG_REG2, 0);
 551
 552         /* Arg3 is the method/vtable ptr */
 553         amd64_mov_reg_membase (code, AMD64_ARG_REG3, AMD64_RBP, arg_offset, sizeof(gpointer));
 554
 555         /* Arg4 is the trampoline address */
 556         amd64_mov_reg_membase (code, AMD64_ARG_REG4, AMD64_RBP, tramp_offset, sizeof(gpointer));
 557
 558         if (aot) {
 559                 char *icall_name = g_strdup_printf ("trampoline_func_%d", tramp_type);
 560                 code = mono_arch_emit_load_aotconst (buf, code, &ji, MONO_PATCH_INFO_JIT_ICALL_ADDR, icall_name);
 561         } else {
 562                 tramp = (guint8*)mono_get_trampoline_func (tramp_type);
 563                 amd64_mov_reg_imm (code, AMD64_R11, tramp);
 564         }
 565         amd64_call_reg (code, AMD64_R11);
 566
 567         /* Check for thread interruption */
 568         /* This is not perf critical code so no need to check the interrupt flag */
 569         /*
 570          * Have to call the _force_ variant, since there could be a protected wrapper on the top of the stack.
 571          */
 572         amd64_mov_membase_reg (code, AMD64_RBP, res_offset, AMD64_RAX, sizeof(mgreg_t));
 573         if (aot) {
 574                 code = mono_arch_emit_load_aotconst (buf, code, &ji, MONO_PATCH_INFO_JIT_ICALL_ADDR, "mono_thread_force_interruption_checkpoint");
 575         } else {
 576                 amd64_mov_reg_imm (code, AMD64_R11, (guint8*)mono_thread_force_interruption_checkpoint);
 577         }
 578         amd64_call_reg (code, AMD64_R11);
 579
 580         amd64_mov_reg_membase (code, AMD64_RAX, AMD64_RBP, res_offset, sizeof(mgreg_t));
 581
 582         /* Restore LMF */
 583         amd64_mov_reg_membase (code, AMD64_RCX, AMD64_RBP, lmf_offset + MONO_STRUCT_OFFSET (MonoLMF, previous_lmf), sizeof(gpointer));
 584         amd64_alu_reg_imm_size (code, X86_SUB, AMD64_RCX, 0x5, sizeof(gpointer));
 585         amd64_mov_reg_membase (code, AMD64_R11, AMD64_RBP, lmf_offset + MONO_STRUCT_OFFSET (MonoLMFTramp, lmf_addr), sizeof(gpointer));
 586         amd64_mov_membase_reg (code, AMD64_R11, 0, AMD64_RCX, sizeof(gpointer));
 587
 588         /*
 589          * Save rax to the stack, after the leave instruction, this will become part of
 590          * the red zone.
 591          */
 592         amd64_mov_membase_reg (code, AMD64_RBP, rax_offset, AMD64_RAX, sizeof(mgreg_t));
 593
 594         /* Restore argument registers, r10 (imt method/rgxtx)
 595            and rax (needed for direct calls to C vararg functions). */
 596         for (i = 0; i < AMD64_NREG; ++i)
 597                 if (AMD64_IS_ARGUMENT_REG (i) || i == AMD64_R10 || i == AMD64_RAX)
 598                         amd64_mov_reg_membase (code, i, AMD64_RBP, saved_regs_offset + (i * sizeof(mgreg_t)), sizeof(mgreg_t));
 599         for (i = 0; i < 8; ++i)
 600                 amd64_movsd_reg_membase (code, i, AMD64_RBP, saved_fpregs_offset + (i * sizeof(mgreg_t)));
 601
 602         /* Restore stack */
 603         amd64_leave (code);
 604         cfa_offset -= sizeof (mgreg_t);
 605         mono_add_unwind_op_def_cfa (unwind_ops, code, buf, AMD64_RSP, cfa_offset);
 606
 607
 608         if (MONO_TRAMPOLINE_TYPE_MUST_RETURN (tramp_type)) {
 609                 /* Load result */
 610                 amd64_mov_reg_membase (code, AMD64_RAX, AMD64_RSP, rax_offset - sizeof(mgreg_t), sizeof(mgreg_t));
 611                 amd64_ret (code);
 612         } else {
 613                 /* call the compiled method using the saved rax */
 614                 amd64_jump_membase (code, AMD64_RSP, rax_offset - sizeof(mgreg_t));
 615         }
 616
 617         g_assert ((code - buf) <= kMaxCodeSize);
 618
 619         nacl_global_codeman_validate (&buf, kMaxCodeSize, &code);
 620
 621         mono_arch_flush_icache (buf, code - buf);
 622         mono_profiler_code_buffer_new (buf, code - buf, MONO_PROFILER_CODE_BUFFER_HELPER, NULL);
 623
 624         tramp_name = mono_get_generic_trampoline_name (tramp_type);
 625         *info = mono_tramp_info_create (tramp_name, buf, code - buf, ji, unwind_ops);
 626         g_free (tramp_name);
 627
 628         return buf;
 629 }
 630
 631 gpointer
 632 mono_arch_create_specific_trampoline (gpointer arg1, MonoTrampolineType tramp_type, MonoDomain *domain, guint32 *code_len)
 633 {
 634         guint8 *code, *buf, *tramp;
 635         int size;
 636         gboolean far_addr = FALSE;
 637
 638         tramp = mono_get_trampoline_code (tramp_type);
 639
 640 #if defined(__default_codegen__)
 641         if ((((guint64)arg1) >> 32) == 0)
 642                 size = 5 + 1 + 4;
 643         else
 644                 size = 5 + 1 + 8;
 645
 646         code = buf = mono_domain_code_reserve_align (domain, size, 1);
 647
 648         if (((gint64)tramp - (gint64)code) >> 31 != 0 && ((gint64)tramp - (gint64)code) >> 31 != -1) {
 649 #ifndef MONO_ARCH_NOMAP32BIT
 650                 g_assert_not_reached ();
 651 #endif
 652                 far_addr = TRUE;
 653                 size += 16;
 654                 code = buf = mono_domain_code_reserve_align (domain, size, 1);
 655         }
 656 #elif defined(__native_client_codegen__)
 657         size = 5 + 1 + 4;
 658         /* Aligning the call site below could */
 659         /* add up to kNaClAlignment-1 bytes   */
 660         size += (kNaClAlignment-1);
 661         size = NACL_BUNDLE_ALIGN_UP (size);
 662         buf = mono_domain_code_reserve_align (domain, size, kNaClAlignment);
 663         code = buf;
 664 #endif
 665
 666         if (far_addr) {
 667                 amd64_mov_reg_imm (code, AMD64_R11, tramp);
 668                 amd64_call_reg (code, AMD64_R11);
 669         } else {
 670                 amd64_call_code (code, tramp);
 671         }
 672         /* The trampoline code will obtain the argument from the instruction stream */
 673 #if defined(__default_codegen__)
 674         if ((((guint64)arg1) >> 32) == 0) {
 675                 *code = 0x4;
 676                 *(guint32*)(code + 1) = (gint64)arg1;
 677                 code += 5;
 678         } else {
 679                 *code = 0x8;
 680                 *(guint64*)(code + 1) = (gint64)arg1;
 681                 code += 9;
 682         }
 683 #elif defined(__native_client_codegen__)
 684         /* For NaCl, all tramp args are 32-bit because they're pointers */
 685         *code = 0x68; /* push imm32 */
 686         *(guint32*)(code + 1) = (gint32)arg1;
 687         code += 5;
 688 #endif
 689
 690         g_assert ((code - buf) <= size);
 691
 692         if (code_len)
 693                 *code_len = size;
 694
 695         nacl_domain_code_validate(domain, &buf, size, &code);
 696
 697         mono_arch_flush_icache (buf, size);
 698         mono_profiler_code_buffer_new (buf, code - buf, MONO_PROFILER_CODE_BUFFER_SPECIFIC_TRAMPOLINE, mono_get_generic_trampoline_simple_name (tramp_type));
 699
 700         return buf;
 701 }
 702
 703 gpointer
 704 mono_arch_create_rgctx_lazy_fetch_trampoline (guint32 slot, MonoTrampInfo **info, gboolean aot)
 705 {
 706         guint8 *tramp;
 707         guint8 *code, *buf;
 708         guint8 **rgctx_null_jumps;
 709         int tramp_size;
 710         int depth, index;
 711         int i;
 712         gboolean mrgctx;
 713         MonoJumpInfo *ji = NULL;
 714         GSList *unwind_ops;
 715
 716         mrgctx = MONO_RGCTX_SLOT_IS_MRGCTX (slot);
 717         index = MONO_RGCTX_SLOT_INDEX (slot);
 718         if (mrgctx)
 719                 index += MONO_SIZEOF_METHOD_RUNTIME_GENERIC_CONTEXT / sizeof (gpointer);
 720         for (depth = 0; ; ++depth) {
 721                 int size = mono_class_rgctx_get_array_size (depth, mrgctx);
 722
 723                 if (index < size - 1)
 724                         break;
 725                 index -= size - 1;
 726         }
 727
 728         tramp_size = NACL_SIZE (64 + 8 * depth, 128 + 8 * depth);
 729
 730         code = buf = mono_global_codeman_reserve (tramp_size);
 731
 732         unwind_ops = mono_arch_get_cie_program ();
 733
 734         rgctx_null_jumps = g_malloc (sizeof (guint8*) * (depth + 2));
 735
 736         if (mrgctx) {
 737                 /* get mrgctx ptr */
 738                 amd64_mov_reg_reg (code, AMD64_RAX, AMD64_ARG_REG1, 8);
 739         } else {
 740                 /* load rgctx ptr from vtable */
 741                 amd64_mov_reg_membase (code, AMD64_RAX, AMD64_ARG_REG1, MONO_STRUCT_OFFSET (MonoVTable, runtime_generic_context), sizeof(gpointer));
 742                 /* is the rgctx ptr null? */
 743                 amd64_test_reg_reg (code, AMD64_RAX, AMD64_RAX);
 744                 /* if yes, jump to actual trampoline */
 745                 rgctx_null_jumps [0] = code;
 746                 amd64_branch8 (code, X86_CC_Z, -1, 1);
 747         }
 748
 749         for (i = 0; i < depth; ++i) {
 750                 /* load ptr to next array */
 751                 if (mrgctx && i == 0)
 752                         amd64_mov_reg_membase (code, AMD64_RAX, AMD64_RAX, MONO_SIZEOF_METHOD_RUNTIME_GENERIC_CONTEXT, sizeof(gpointer));
 753                 else
 754                         amd64_mov_reg_membase (code, AMD64_RAX, AMD64_RAX, 0, sizeof(gpointer));
 755                 /* is the ptr null? */
 756                 amd64_test_reg_reg (code, AMD64_RAX, AMD64_RAX);
 757                 /* if yes, jump to actual trampoline */
 758                 rgctx_null_jumps [i + 1] = code;
 759                 amd64_branch8 (code, X86_CC_Z, -1, 1);
 760         }
 761
 762         /* fetch slot */
 763         amd64_mov_reg_membase (code, AMD64_RAX, AMD64_RAX, sizeof (gpointer) * (index + 1), sizeof(gpointer));
 764         /* is the slot null? */
 765         amd64_test_reg_reg (code, AMD64_RAX, AMD64_RAX);
 766         /* if yes, jump to actual trampoline */
 767         rgctx_null_jumps [depth + 1] = code;
 768         amd64_branch8 (code, X86_CC_Z, -1, 1);
 769         /* otherwise return */
 770         amd64_ret (code);
 771
 772         for (i = mrgctx ? 1 : 0; i <= depth + 1; ++i)
 773                 mono_amd64_patch (rgctx_null_jumps [i], code);
 774
 775         g_free (rgctx_null_jumps);
 776
 777         /* move the rgctx pointer to the VTABLE register */
 778         amd64_mov_reg_reg (code, MONO_ARCH_VTABLE_REG, AMD64_ARG_REG1, sizeof(gpointer));
 779
 780         if (aot) {
 781                 code = mono_arch_emit_load_aotconst (buf, code, &ji, MONO_PATCH_INFO_JIT_ICALL_ADDR, g_strdup_printf ("specific_trampoline_lazy_fetch_%u", slot));
 782                 amd64_jump_reg (code, AMD64_R11);
 783         } else {
 784                 tramp = mono_arch_create_specific_trampoline (GUINT_TO_POINTER (slot), MONO_TRAMPOLINE_RGCTX_LAZY_FETCH, mono_get_root_domain (), NULL);
 785
 786                 /* jump to the actual trampoline */
 787                 amd64_jump_code (code, tramp);
 788         }
 789
 790         nacl_global_codeman_validate (&buf, tramp_size, &code);
 791         mono_arch_flush_icache (buf, code - buf);
 792         mono_profiler_code_buffer_new (buf, code - buf, MONO_PROFILER_CODE_BUFFER_GENERICS_TRAMPOLINE, NULL);
 793
 794         g_assert (code - buf <= tramp_size);
 795
 796         char *name = mono_get_rgctx_fetch_trampoline_name (slot);
 797         *info = mono_tramp_info_create (name, buf, code - buf, ji, unwind_ops);
 798         g_free (name);
 799
 800         return buf;
 801 }
 802
 803 void
 804 mono_arch_invalidate_method (MonoJitInfo *ji, void *func, gpointer func_arg)
 805 {
 806         /* FIXME: This is not thread safe */
 807         guint8 *code = ji->code_start;
 808
 809         amd64_mov_reg_imm (code, AMD64_ARG_REG1, func_arg);
 810         amd64_mov_reg_imm (code, AMD64_R11, func);
 811
 812         x86_push_imm (code, (guint64)func_arg);
 813         amd64_call_reg (code, AMD64_R11);
 814 }
 815
 816
 817 static void
 818 handler_block_trampoline_helper (gpointer *ptr)
 819 {
 820         MonoJitTlsData *jit_tls = mono_native_tls_get_value (mono_jit_tls_id);
 821         *ptr = jit_tls->handler_block_return_address;
 822 }
 823
 824 gpointer
 825 mono_arch_create_handler_block_trampoline (MonoTrampInfo **info, gboolean aot)
 826 {
 827         guint8 *tramp = mono_get_trampoline_code (MONO_TRAMPOLINE_HANDLER_BLOCK_GUARD);
 828         guint8 *code, *buf;
 829         int tramp_size = 64;
 830         MonoJumpInfo *ji = NULL;
 831         GSList *unwind_ops;
 832
 833         g_assert (!aot);
 834
 835         code = buf = mono_global_codeman_reserve (tramp_size);
 836
 837         unwind_ops = mono_arch_get_cie_program ();
 838
 839         /*
 840         This trampoline restore the call chain of the handler block then jumps into the code that deals with it.
 841         */
 842         if (mono_get_jit_tls_offset () != -1) {
 843                 code = mono_amd64_emit_tls_get (code, MONO_AMD64_ARG_REG1, mono_get_jit_tls_offset ());
 844                 amd64_mov_reg_membase (code, MONO_AMD64_ARG_REG1, MONO_AMD64_ARG_REG1, MONO_STRUCT_OFFSET (MonoJitTlsData, handler_block_return_address), 8);
 845                 /* Simulate a call */
 846                 amd64_push_reg (code, AMD64_RAX);
 847                 mono_add_unwind_op_def_cfa_offset (unwind_ops, code, buf, 16);
 848                 amd64_jump_code (code, tramp);
 849         } else {
 850                 /*Slow path uses a c helper*/
 851                 amd64_mov_reg_reg (code, MONO_AMD64_ARG_REG1, AMD64_RSP, 8);
 852                 amd64_mov_reg_imm (code, AMD64_RAX, tramp);
 853                 amd64_push_reg (code, AMD64_RAX);
 854                 mono_add_unwind_op_def_cfa_offset (unwind_ops, code, buf, 16);
 855                 amd64_push_reg (code, AMD64_RAX);
 856                 mono_add_unwind_op_def_cfa_offset (unwind_ops, code, buf, 24);
 857                 amd64_jump_code (code, handler_block_trampoline_helper);
 858         }
 859
 860         mono_arch_flush_icache (buf, code - buf);
 861         mono_profiler_code_buffer_new (buf, code - buf, MONO_PROFILER_CODE_BUFFER_HELPER, NULL);
 862         g_assert (code - buf <= tramp_size);
 863
 864         *info = mono_tramp_info_create ("handler_block_trampoline", buf, code - buf, ji, unwind_ops);
 865
 866         return buf;
 867 }
 868
 869 /*
 870  * mono_arch_get_call_target:
 871  *
 872  *   Return the address called by the code before CODE if exists.
 873  */
 874 guint8*
 875 mono_arch_get_call_target (guint8 *code)
 876 {
 877         if (code [-5] == 0xe8) {
 878                 gint32 disp = *(gint32*)(code - 4);
 879                 guint8 *target = code + disp;
 880
 881                 return target;
 882         } else {
 883                 return NULL;
 884         }
 885 }
 886
 887 /*
 888  * mono_arch_get_plt_info_offset:
 889  *
 890  *   Return the PLT info offset belonging to the plt entry PLT_ENTRY.
 891  */
 892 guint32
 893 mono_arch_get_plt_info_offset (guint8 *plt_entry, mgreg_t *regs, guint8 *code)
 894 {
 895 #if defined(__native_client__) || defined(__native_client_codegen__)
 896         /* 18 = 3 (mov opcode) + 4 (disp) + 10 (nacljmp) + 1 (push opcode) */
 897         /* See aot-compiler.c arch_emit_plt_entry for details.             */
 898         return *(guint32*)(plt_entry + 18);
 899 #else
 900         return *(guint32*)(plt_entry + 6);
 901 #endif
 902 }
 903
 904 /*
 905  * mono_arch_create_sdb_trampoline:
 906  *
 907  *   Return a trampoline which captures the current context, passes it to
 908  * debugger_agent_single_step_from_context ()/debugger_agent_breakpoint_from_context (),
 909  * then restores the (potentially changed) context.
 910  */
 911 guint8*
 912 mono_arch_create_sdb_trampoline (gboolean single_step, MonoTrampInfo **info, gboolean aot)
 913 {
 914         int tramp_size = 256;
 915         int i, framesize, ctx_offset, cfa_offset, gregs_offset;
 916         guint8 *code, *buf;
 917         GSList *unwind_ops = NULL;
 918         MonoJumpInfo *ji = NULL;
 919
 920         code = buf = mono_global_codeman_reserve (tramp_size);
 921
 922         framesize = 0;
 923 #ifdef TARGET_WIN32
 924         /* Reserve space where the callee can save the argument registers */
 925         framesize += 4 * sizeof (mgreg_t);
 926 #endif
 927
 928         ctx_offset = framesize;
 929         framesize += sizeof (MonoContext);
 930
 931         framesize = ALIGN_TO (framesize, MONO_ARCH_FRAME_ALIGNMENT);
 932
 933         // CFA = sp + 8
 934         cfa_offset = 8;
 935         mono_add_unwind_op_def_cfa (unwind_ops, code, buf, AMD64_RSP, 8);
 936         // IP saved at CFA - 8
 937         mono_add_unwind_op_offset (unwind_ops, code, buf, AMD64_RIP, -cfa_offset);
 938
 939         amd64_push_reg (code, AMD64_RBP);
 940         cfa_offset += sizeof(mgreg_t);
 941         mono_add_unwind_op_def_cfa_offset (unwind_ops, code, buf, cfa_offset);
 942         mono_add_unwind_op_offset (unwind_ops, code, buf, AMD64_RBP, - cfa_offset);
 943
 944         amd64_mov_reg_reg (code, AMD64_RBP, AMD64_RSP, sizeof(mgreg_t));
 945         mono_add_unwind_op_def_cfa_reg (unwind_ops, code, buf, AMD64_RBP);
 946         amd64_alu_reg_imm (code, X86_SUB, AMD64_RSP, framesize);
 947
 948         gregs_offset = ctx_offset + MONO_STRUCT_OFFSET (MonoContext, gregs);
 949
 950         /* Initialize a MonoContext structure on the stack */
 951         for (i = 0; i < AMD64_NREG; ++i) {
 952                 if (i != AMD64_RIP && i != AMD64_RSP && i != AMD64_RBP)
 953                         amd64_mov_membase_reg (code, AMD64_RSP, gregs_offset + (i * sizeof (mgreg_t)), i, sizeof (mgreg_t));
 954         }
 955         amd64_mov_reg_membase (code, AMD64_R11, AMD64_RBP, 0, sizeof (mgreg_t));
 956         amd64_mov_membase_reg (code, AMD64_RSP, gregs_offset + (AMD64_RBP * sizeof (mgreg_t)), AMD64_R11, sizeof (mgreg_t));
 957         amd64_lea_membase (code, AMD64_R11, AMD64_RBP, 2 * sizeof (mgreg_t));
 958         amd64_mov_membase_reg (code, AMD64_RSP, gregs_offset + (AMD64_RSP * sizeof (mgreg_t)), AMD64_R11, sizeof (mgreg_t));
 959         amd64_mov_reg_membase (code, AMD64_R11, AMD64_RBP, sizeof (mgreg_t), sizeof (mgreg_t));
 960         amd64_mov_membase_reg (code, AMD64_RSP, gregs_offset + (AMD64_RIP * sizeof (mgreg_t)), AMD64_R11, sizeof (mgreg_t));
 961
 962         /* Call the single step/breakpoint function in sdb */
 963         amd64_lea_membase (code, AMD64_ARG_REG1, AMD64_RSP, ctx_offset);
 964
 965         if (aot) {
 966                 if (single_step)
 967                         code = mono_arch_emit_load_aotconst (buf, code, &ji, MONO_PATCH_INFO_JIT_ICALL_ADDR, "debugger_agent_single_step_from_context");
 968                 else
 969                         code = mono_arch_emit_load_aotconst (buf, code, &ji, MONO_PATCH_INFO_JIT_ICALL_ADDR, "debugger_agent_breakpoint_from_context");
 970                 amd64_call_reg (code, AMD64_R11);
 971         } else {
 972                 if (single_step)
 973                         amd64_call_code (code, debugger_agent_single_step_from_context);
 974                 else
 975                         amd64_call_code (code, debugger_agent_breakpoint_from_context);
 976         }
 977
 978         /* Restore registers from ctx */
 979         for (i = 0; i < AMD64_NREG; ++i) {
 980                 if (i != AMD64_RIP && i != AMD64_RSP && i != AMD64_RBP)
 981                         amd64_mov_reg_membase (code, AMD64_RSP, i, gregs_offset + (i * sizeof (mgreg_t)), sizeof (mgreg_t));
 982         }
 983         amd64_mov_reg_membase (code, AMD64_R11, AMD64_RSP, gregs_offset + (AMD64_RBP * sizeof (mgreg_t)), sizeof (mgreg_t));
 984         amd64_mov_membase_reg (code, AMD64_RBP, 0, AMD64_R11, sizeof (mgreg_t));
 985         amd64_mov_reg_membase (code, AMD64_R11, AMD64_RSP, gregs_offset + (AMD64_RIP * sizeof (mgreg_t)), sizeof (mgreg_t));
 986         amd64_mov_membase_reg (code, AMD64_RBP, sizeof (mgreg_t), AMD64_R11, sizeof (mgreg_t));
 987
 988         amd64_leave (code);
 989         cfa_offset -= sizeof (mgreg_t);
 990         mono_add_unwind_op_def_cfa (unwind_ops, code, buf, AMD64_RSP, cfa_offset);
 991         amd64_ret (code);
 992
 993         mono_arch_flush_icache (code, code - buf);
 994         g_assert (code - buf <= tramp_size);
 995
 996         const char *tramp_name = single_step ? "sdb_single_step_trampoline" : "sdb_breakpoint_trampoline";
 997         *info = mono_tramp_info_create (tramp_name, buf, code - buf, ji, unwind_ops);
 998
 999         return buf;
1000 }