2009-02-18 Rodrigo Kumpera <rkumpera@novell.com>

	* aot-runtime.c:
	* mini-amd64.c:
	* mini-arm.c:
	* mini-ia64.c:
	* mini-mips.c:
	* mini-ppc.c:
	* mini-sparc.c:
	* mini-trampolines.c:
	* mini-x86.c:
	* mini.c:
	* tramp-alpha.c:
	* tramp-amd64.c:
	* tramp-arm.c:
	* tramp-hppa.c:
	* tramp-ia64.c:
	* tramp-mips.c:
	* tramp-ppc.c:
	* tramp-s390.c:
	* tramp-s390x.c:
	* tramp-sparc.c:
	* tramp-x86.c: Use mono_domain_code_* functions instead of using MonoDomain::code_mp directly.

svn path=/trunk/mono/; revision=127429

diff --git a/mono/mini/ChangeLog b/mono/mini/ChangeLog
index b991b75299c8dea67234ebeb279fdc5de174d016..3c55303944b13a82cfe0a2536a0f942899aa7390 100644 (file)
--- a/mono/mini/ChangeLog
+++ b/mono/mini/ChangeLog
@@ -1,3 +1,27 @@
+2009-02-18  Rodrigo Kumpera  <rkumpera@novell.com>
+
+       * aot-runtime.c:
+       * mini-amd64.c:
+       * mini-arm.c:
+       * mini-ia64.c:
+       * mini-mips.c:
+       * mini-ppc.c:
+       * mini-sparc.c:
+       * mini-trampolines.c:
+       * mini-x86.c:
+       * mini.c:
+       * tramp-alpha.c:
+       * tramp-amd64.c:
+       * tramp-arm.c:
+       * tramp-hppa.c:
+       * tramp-ia64.c:
+       * tramp-mips.c:
+       * tramp-ppc.c:
+       * tramp-s390.c:
+       * tramp-s390x.c:
+       * tramp-sparc.c:
+       * tramp-x86.c: Use mono_domain_code_* functions instead of using MonoDomain::code_mp directly.
+
 2009-02-18  Zoltan Varga  <vargaz@gmail.com>
 
        * mini-codegen.c (mono_local_regalloc): Remove a ! from if (!dest_sreg1)

diff --git a/mono/mini/aot-runtime.c b/mono/mini/aot-runtime.c
index 5dd2a41823fd07b6b414cd2a7f1ee072e9208260..fadaa4480ddc0da2c782ec3518222e5b1c67f5e4 100644 (file)
--- a/mono/mini/aot-runtime.c
+++ b/mono/mini/aot-runtime.c
@@ -2062,9 +2062,7 @@ load_method (MonoDomain *domain, MonoAotModule *aot_module, MonoImage *image, Mo
                        jinfo = decode_exception_debug_info (aot_module, domain, method, ex_info, code);
                }
 
-               mono_domain_lock (domain);
-               code2 = mono_code_manager_reserve (domain->code_mp, jinfo->code_size);
-               mono_domain_unlock (domain);
+               code2 = mono_domain_code_reserve (domain, jinfo->code_size);
                memcpy (code2, code, jinfo->code_size);
                mono_arch_flush_icache (code2, jinfo->code_size);
                code = code2;

diff --git a/mono/mini/mini-amd64.c b/mono/mini/mini-amd64.c
index 4606dcf7a65e792dab71fa041680167014de86bf..cd4fd637869546f48df21a684fd52ed5d403e853 100644 (file)
--- a/mono/mini/mini-amd64.c
+++ b/mono/mini/mini-amd64.c
@@ -5918,7 +5918,7 @@ mono_arch_build_imt_thunk (MonoVTable *vtable, MonoDomain *domain, MonoIMTCheckI
        if (fail_tramp)
                code = mono_method_alloc_generic_virtual_thunk (domain, size);
        else
-               code = mono_code_manager_reserve (domain->code_mp, size);
+               code = mono_domain_code_reserve (domain, size);
        start = code;
        for (i = 0; i < count; ++i) {
                MonoIMTCheckItem *item = imt_entries [i];

diff --git a/mono/mini/mini-arm.c b/mono/mini/mini-arm.c
index eb8158e8c2bc60ca40d7fb8ca7ce3df5a982c7da..b9a1c072ca589981a8114ef1115d335501529c22 100644 (file)
--- a/mono/mini/mini-arm.c
+++ b/mono/mini/mini-arm.c
@@ -2045,12 +2045,12 @@ handle_thunk (int absolute, guchar *code, const guchar *target) {
        pdata.found = 0;
 
        mono_domain_lock (domain);
-       mono_code_manager_foreach (domain->code_mp, search_thunk_slot, &pdata);
+       mono_domain_code_foreach (domain, search_thunk_slot, &pdata);
 
        if (!pdata.found) {
                /* this uses the first available slot */
                pdata.found = 2;
-               mono_code_manager_foreach (domain->code_mp, search_thunk_slot, &pdata);
+               mono_domain_code_foreach (domain, search_thunk_slot, &pdata);
        }
        mono_domain_unlock (domain);
 
@@ -4322,7 +4322,7 @@ mono_arch_build_imt_thunk (MonoVTable *vtable, MonoDomain *domain, MonoIMTCheckI
        if (large_offsets)
                size += 4 * count; /* The ARM_ADD_REG_IMM to pop the stack */
 
-       start = code = mono_code_manager_reserve (domain->code_mp, size);
+       start = code = mono_domain_code_reserve (domain, size);
 
 #if DEBUG_IMT
        printf ("building IMT thunk for class %s %s entries %d code size %d code at %p end %p vtable %p\n", vtable->klass->name_space, vtable->klass->name, count, size, start, ((guint8*)start) + size, vtable);

diff --git a/mono/mini/mini-ia64.c b/mono/mini/mini-ia64.c
index 2ffd375f54d30157fac539e60c31704f6d6ea434..aa5e0918a68b6746ab49df05777048c0c729ffe6 100644 (file)
--- a/mono/mini/mini-ia64.c
+++ b/mono/mini/mini-ia64.c
@@ -4669,7 +4669,7 @@ mono_arch_build_imt_thunk (MonoVTable *vtable, MonoDomain *domain, MonoIMTCheckI
        g_assert (code.buf - buf <= size);
 
        size = code.buf - buf;
-       start = mono_code_manager_reserve (domain->code_mp, size);
+       start = mono_domain_code_reserve (domain, size);
        memcpy (start, buf, size);
 
        mono_arch_flush_icache (start, size);

diff --git a/mono/mini/mini-mips.c b/mono/mini/mini-mips.c
index 9e33d47c13c3a3232429998c1dd1ebbb8e636c55..b70e740b5fa4ada596d9564f1657cdc810200d80 100644 (file)
--- a/mono/mini/mini-mips.c
+++ b/mono/mini/mini-mips.c
@@ -5523,7 +5523,7 @@ mono_arch_build_imt_thunk (MonoVTable *vtable, MonoDomain *domain, MonoIMTCheckI
        } else {
                /* the initial load of the vtable address */
                size += 8;
-               code = mono_code_manager_reserve (domain->code_mp, size);
+               code = mono_domain_code_reserve (domain, size);
        }
        start = code;
        if (!fail_tramp)

diff --git a/mono/mini/mini-ppc.c b/mono/mini/mini-ppc.c
index 4fbba1a4b80f803708fb6a53bfeb50ad24e4d585..8ec1015cc5cc7566262f6c41959abf3c13e1964a 100644 (file)
--- a/mono/mini/mini-ppc.c
+++ b/mono/mini/mini-ppc.c
@@ -2603,12 +2603,12 @@ handle_thunk (int absolute, guchar *code, const guchar *target) {
        pdata.found = 0;
 
        mono_domain_lock (domain);
-       mono_code_manager_foreach (domain->code_mp, search_thunk_slot, &pdata);
+       mono_domain_code_foreach (domain, search_thunk_slot, &pdata);
 
        if (!pdata.found) {
                /* this uses the first available slot */
                pdata.found = 2;
-               mono_code_manager_foreach (domain->code_mp, search_thunk_slot, &pdata);
+               mono_domain_code_foreach (domain, search_thunk_slot, &pdata);
        }
        mono_domain_unlock (domain);
 
@@ -5263,7 +5263,7 @@ mono_arch_build_imt_thunk (MonoVTable *vtable, MonoDomain *domain, MonoIMTCheckI
        } else {
                /* the initial load of the vtable address */
                size += PPC_LOAD_SEQUENCE_LENGTH + LOADSTORE_SIZE;
-               code = mono_code_manager_reserve (domain->code_mp, size);
+               code = mono_domain_code_reserve (domain, size);
        }
        start = code;
        if (!fail_tramp) {

diff --git a/mono/mini/mini-sparc.c b/mono/mini/mini-sparc.c
index 6a237c030c6cc1a71e69cb8f66c3f9ef1f175644..e44f8ffdb579bc89458cdd7e86df65b082c06225 100644 (file)
--- a/mono/mini/mini-sparc.c
+++ b/mono/mini/mini-sparc.c
@@ -2366,7 +2366,7 @@ mono_arch_build_imt_thunk (MonoVTable *vtable, MonoDomain *domain, MonoIMTCheckI
                }
                size += item->chunk_size;
        }
-       code = mono_code_manager_reserve (domain->code_mp, size * 4);
+       code = mono_domain_code_reserve (domain, size * 4);
        start = code;
 
        for (i = 0; i < count; ++i) {

diff --git a/mono/mini/mini-trampolines.c b/mono/mini/mini-trampolines.c
index 67ae72fcad5db72a0593346643ee91af525cff71..ddbdf8bfffaa2bc350e218d4d990b3b7400fc9c8 100644 (file)
--- a/mono/mini/mini-trampolines.c
+++ b/mono/mini/mini-trampolines.c
@@ -893,9 +893,7 @@ mono_create_jit_trampoline_from_token (MonoImage *image, guint32 token)
        MonoDomain *domain = mono_domain_get ();
        guint8 *buf, *start;
 
-       mono_domain_lock (domain);
-       buf = start = mono_code_manager_reserve (domain->code_mp, 2 * sizeof (gpointer));
-       mono_domain_unlock (domain);
+       buf = start = mono_domain_code_reserve (domain, 2 * sizeof (gpointer));
 
        *(gpointer*)(gpointer)buf = image;
        buf += sizeof (gpointer);

diff --git a/mono/mini/mini-x86.c b/mono/mini/mini-x86.c
index 1736cdc883de0c715ea30fdcaca2bffae7063a5d..74469dfb9337adfa247ceb9a4fc87f83232c0cf7 100644 (file)
--- a/mono/mini/mini-x86.c
+++ b/mono/mini/mini-x86.c
@@ -4984,7 +4984,7 @@ mono_arch_build_imt_thunk (MonoVTable *vtable, MonoDomain *domain, MonoIMTCheckI
        if (fail_tramp)
                code = mono_method_alloc_generic_virtual_thunk (domain, size);
        else
-               code = mono_code_manager_reserve (domain->code_mp, size);
+               code = mono_domain_code_reserve (domain, size);
        start = code;
        for (i = 0; i < count; ++i) {
                MonoIMTCheckItem *item = imt_entries [i];

diff --git a/mono/mini/mini.c b/mono/mini/mini.c
index 42f8524f74ec06a91e384df43967e9039cd14d68..df750e00f40f13e5c3c20f915bd1e1f95586da2d 100644 (file)
--- a/mono/mini/mini.c
+++ b/mono/mini/mini.c
@@ -2494,9 +2494,7 @@ mono_resolve_patch_target (MonoMethod *method, MonoDomain *domain, guint8 *code,
                        if (mono_aot_only) {
                                jump_table = mono_domain_alloc (domain, sizeof (gpointer) * patch_info->data.table->table_size);
                        } else {
-                               mono_domain_lock (domain);
-                               jump_table = mono_code_manager_reserve (domain->code_mp, sizeof (gpointer) * patch_info->data.table->table_size);
-                               mono_domain_unlock (domain);
+                               jump_table = mono_domain_code_reserve (domain, sizeof (gpointer) * patch_info->data.table->table_size);
                        }
                }
 
@@ -2827,9 +2825,7 @@ mono_codegen (MonoCompile *cfg)
 #ifdef MONO_ARCH_HAVE_UNWIND_TABLE
                unwindlen = mono_arch_unwindinfo_get_size (cfg->arch.unwindinfo);
 #endif
-               mono_domain_lock (cfg->domain);
-               code = mono_code_manager_reserve (cfg->domain->code_mp, cfg->code_size + unwindlen);
-               mono_domain_unlock (cfg->domain);
+               code = mono_domain_code_reserve (cfg->domain, cfg->code_size + unwindlen);
        }
 
        memcpy (code, cfg->native_code, cfg->code_len);
@@ -2890,9 +2886,7 @@ mono_codegen (MonoCompile *cfg)
                        if (cfg->method->dynamic) {
                                table = mono_code_manager_reserve (cfg->dynamic_info->code_mp, sizeof (gpointer) * patch_info->data.table->table_size);
                        } else {
-                               mono_domain_lock (cfg->domain);
-                               table = mono_code_manager_reserve (cfg->domain->code_mp, sizeof (gpointer) * patch_info->data.table->table_size);
-                               mono_domain_unlock (cfg->domain);
+                               table = mono_domain_code_reserve (cfg->domain, sizeof (gpointer) * patch_info->data.table->table_size);
                        }
 
                        for (i = 0; i < patch_info->data.table->table_size; i++) {
@@ -2964,9 +2958,7 @@ if (valgrind_register){
        if (cfg->method->dynamic) {
                mono_code_manager_commit (cfg->dynamic_info->code_mp, cfg->native_code, cfg->code_size, cfg->code_len);
        } else {
-               mono_domain_lock (cfg->domain);
-               mono_code_manager_commit (cfg->domain->code_mp, cfg->native_code, cfg->code_size, cfg->code_len);
-               mono_domain_unlock (cfg->domain);
+               mono_domain_code_commit (cfg->domain, cfg->native_code, cfg->code_size, cfg->code_len);
        }
        
        mono_arch_flush_icache (cfg->native_code, cfg->code_len);

diff --git a/mono/mini/tramp-alpha.c b/mono/mini/tramp-alpha.c
index 6cb4adc8b08ffa71aaad4446e3efaae688047a67..03b69988788a998f26912740c36c31c5f8dc122e 100644 (file)
--- a/mono/mini/tramp-alpha.c
+++ b/mono/mini/tramp-alpha.c
@@ -472,14 +472,12 @@ mono_arch_create_specific_trampoline (gpointer arg1,
   alpha_jmp(code, alpha_zero, alpha_at, 0);
   
   g_assert (((char *)code - (char *)buf) <= TRAMPOLINE_SIZE);
-  mono_domain_lock (domain);
   /*
    * FIXME: Changing the size to code - buf causes strange crashes during
    * mcs bootstrap.
    */
-  real_code = mono_code_manager_reserve (domain->code_mp, TRAMPOLINE_SIZE);
+  real_code = mono_domain_code_reserve (domain, TRAMPOLINE_SIZE);
   size = (char *)code - (char *)buf;
-  mono_domain_unlock (domain);
   
   memcpy (real_code, buf, size);
  
@@ -591,9 +589,7 @@ mono_arch_get_unbox_trampoline (MonoGenericSharingContext *gsctx, MonoMethod *m,
   if (MONO_TYPE_ISSTRUCT (mono_method_signature (m)->ret))
     this_reg = 17; //R17
 
-  mono_domain_lock (domain);
-  start_code = code = (unsigned int *)mono_code_manager_reserve (domain->code_mp, 32);
-  mono_domain_unlock (domain);
+  start_code = code = (unsigned int *)mono_domain_code_reserve (domain, 32);
 
   // Adjust this by size of MonoObject
   alpha_addq_(code, this_reg, sizeof(MonoObject), this_reg);  // 0

diff --git a/mono/mini/tramp-amd64.c b/mono/mini/tramp-amd64.c
index a4e9e00a462f7503474ebcc6f8fc6026b13a782f..a792be9c1ececf59bd3525fb0273c05e9404dcff 100644 (file)
--- a/mono/mini/tramp-amd64.c
+++ b/mono/mini/tramp-amd64.c
@@ -49,9 +49,7 @@ mono_arch_get_unbox_trampoline (MonoGenericSharingContext *gsctx, MonoMethod *m,
 
        this_reg = mono_arch_get_this_arg_reg (mono_method_signature (m), gsctx, NULL);
 
-       mono_domain_lock (domain);
-       start = code = mono_code_manager_reserve (domain->code_mp, 20);
-       mono_domain_unlock (domain);
+       start = code = mono_domain_code_reserve (domain, 20);
 
        amd64_alu_reg_imm (code, X86_ADD, this_reg, sizeof (MonoObject));
        /* FIXME: Optimize this */
@@ -543,9 +541,7 @@ mono_arch_create_specific_trampoline (gpointer arg1, MonoTrampolineType tramp_ty
        else
                size = 5 + 1 + 8;
 
-       mono_domain_lock (domain);
-       code = buf = mono_code_manager_reserve_align (domain->code_mp, size, 1);
-       mono_domain_unlock (domain);
+       code = buf = mono_domain_code_reserve_align (domain, size, 1);
 
        amd64_call_code (code, tramp);
        /* The trampoline code will obtain the argument from the instruction stream */

diff --git a/mono/mini/tramp-arm.c b/mono/mini/tramp-arm.c
index 3dd9732f18aac2b150e0efa7fed77d7946353c00..a1a8f699b2d8cf915f5ef4a077b6fb6492507a9e 100644 (file)
--- a/mono/mini/tramp-arm.c
+++ b/mono/mini/tramp-arm.c
@@ -60,9 +60,7 @@ mono_arch_get_unbox_trampoline (MonoGenericSharingContext *gsctx, MonoMethod *m,
        if (MONO_TYPE_ISSTRUCT (mono_method_signature (m)->ret))
                this_pos = 1;
 
-       mono_domain_lock (domain);
-       start = code = mono_code_manager_reserve (domain->code_mp, 16);
-       mono_domain_unlock (domain);
+       start = code = mono_domain_code_reserve (domain, 16);
 
        ARM_LDR_IMM (code, ARMREG_IP, ARMREG_PC, 4);
        ARM_ADD_REG_IMM8 (code, this_pos, this_pos, sizeof (MonoObject));
@@ -414,10 +412,10 @@ mono_arch_create_specific_trampoline (gpointer arg1, MonoTrampolineType tramp_ty
        tramp = mono_get_trampoline_code (tramp_type);
 
        mono_domain_lock (domain);
-       code = buf = mono_code_manager_reserve_align (domain->code_mp, size, 4);
+       code = buf = mono_domain_code_reserve_align (domain, size, 4);
        if ((short_branch = branch_for_target_reachable (code + 8, tramp))) {
                size = 12;
-               mono_code_manager_commit (domain->code_mp, code, SPEC_TRAMP_SIZE, size);
+               mono_domain_code_commit (domain, code, SPEC_TRAMP_SIZE, size);
        }
        mono_domain_unlock (domain);
 

diff --git a/mono/mini/tramp-hppa.c b/mono/mini/tramp-hppa.c
index 6fe57d9eb246a3929fe545f739825da3c175618e..04dc219b651a68d1e433c631417afa264355d36b 100644 (file)
--- a/mono/mini/tramp-hppa.c
+++ b/mono/mini/tramp-hppa.c
@@ -63,9 +63,7 @@ mono_arch_get_unbox_trampoline (MonoGenericSharingContext *gsctx, MonoMethod *m,
        if (MONO_TYPE_ISSTRUCT (mono_method_signature (m)->ret))
                this_pos = hppa_r25;
            
-       mono_domain_lock (domain);
-       start = code = mono_code_manager_reserve (domain->code_mp, 20);
-       mono_domain_unlock (domain);
+       start = code = mono_domain_code_reserve (domain, 20);
 
        hppa_set (code, addr, hppa_r1);
        hppa_ldo (code, sizeof (MonoObject), this_pos, this_pos);
@@ -321,9 +319,7 @@ mono_arch_create_class_init_trampoline (MonoVTable *vtable)
        tramp = mono_get_trampoline_code (MONO_TRAMPOLINE_CLASS_INIT);
        /* This is the method-specific part of the trampoline. Its purpose is
           to provide the generic part with the MonoMethod *method pointer. */
-       mono_domain_lock (vtable->domain);
-       code = buf = mono_code_manager_reserve (vtable->domain->code_mp, METHOD_TRAMPOLINE_SIZE);
-       mono_domain_unlock (vtable->domain);
+       code = buf = mono_domain_code_reserve (vtable->domain, METHOD_TRAMPOLINE_SIZE);
 
        hppa_stw (buf, hppa_r2, -20, hppa_sp);
        hppa_copy (buf, hppa_r3, hppa_r1);
@@ -364,9 +360,7 @@ create_specific_tramp (MonoMethod *method, guint8* tramp, MonoDomain *domain)
        guint8 *code, *buf;
        MonoJitInfo *ji;
 
-       mono_domain_lock (domain);
-       code = buf = mono_code_manager_reserve (domain->code_mp, 20);
-       mono_domain_unlock (domain);
+       code = buf = mono_domain_code_reserve (domain, 20);
 
        /* Call trampoline, with the "method" pointer in r20 */
        hppa_set (buf, tramp, hppa_r1);

diff --git a/mono/mini/tramp-ia64.c b/mono/mini/tramp-ia64.c
index cb962da6251a1190457437f7b6d15d5dd0824ff3..db0bf5d61e46e69eac8e237951897285d6b667cd 100644 (file)
--- a/mono/mini/tramp-ia64.c
+++ b/mono/mini/tramp-ia64.c
@@ -50,9 +50,7 @@ mono_arch_get_unbox_trampoline (MonoGenericSharingContext *gsctx, MonoMethod *m,
        func_addr = ((gpointer*)addr) [0];
        func_gp = ((gpointer*)addr) [1];
 
-       mono_domain_lock (domain);
-       buf = mono_code_manager_reserve (domain->code_mp, 256);
-       mono_domain_unlock (domain);
+       buf = mono_domain_code_reserve (domain, 256);
 
        /* Since the this reg is a stacked register, its a bit hard to access it */
        ia64_codegen_init (code, buf);
@@ -376,9 +374,7 @@ mono_arch_create_specific_trampoline (gpointer arg1, MonoTrampolineType tramp_ty
 
        tramp = mono_get_trampoline_code (tramp_type);
 
-       mono_domain_lock (domain);
-       buf = mono_code_manager_reserve (domain->code_mp, TRAMPOLINE_SIZE);
-       mono_domain_unlock (domain);
+       buf = mono_domain_code_reserve (domain, TRAMPOLINE_SIZE);
 
        /* FIXME: Optimize this */
 

diff --git a/mono/mini/tramp-mips.c b/mono/mini/tramp-mips.c
index 54fa5640ba1a7d0097a8d3147150a9ed008665fa..60cbbbbe70afebc60f8c7ae1f86f7bb62ae73177 100644 (file)
--- a/mono/mini/tramp-mips.c
+++ b/mono/mini/tramp-mips.c
@@ -44,9 +44,7 @@ mono_arch_get_unbox_trampoline (MonoGenericSharingContext *gsctx, MonoMethod *m,
        if (MONO_TYPE_ISSTRUCT (mono_method_signature (m)->ret))
                this_pos = mips_a1;
            
-       mono_domain_lock (domain);
-       start = code = mono_code_manager_reserve (domain->code_mp, 20);
-       mono_domain_unlock (domain);
+       start = code = mono_domain_code_reserve (domain, 20);
 
        mips_load (code, mips_t9, addr);
        mips_addiu (code, this_pos, this_pos, sizeof (MonoObject));
@@ -368,9 +366,7 @@ mono_arch_create_specific_trampoline (gpointer arg1, MonoTrampolineType tramp_ty
 
        tramp = mono_get_trampoline_code (tramp_type);
 
-       mono_domain_lock (domain);
-       code = buf = mono_code_manager_reserve (domain->code_mp, 32);
-       mono_domain_unlock (domain);
+       code = buf = mono_domain_code_reserve (domain, 32);
 
        /* Prepare the jump to the generic trampoline code
         * mono_arch_create_trampoline_code() knows we're putting this in t8

diff --git a/mono/mini/tramp-ppc.c b/mono/mini/tramp-ppc.c
index 001f668b16173d09c262a556625639e84d076e8f..800cbc10c4aec092b224b82f416bf282dd696dc9 100644 (file)
--- a/mono/mini/tramp-ppc.c
+++ b/mono/mini/tramp-ppc.c
@@ -67,11 +67,11 @@ mono_arch_get_unbox_trampoline (MonoGenericSharingContext *gsctx, MonoMethod *m,
                this_pos = 4;
            
        mono_domain_lock (domain);
-       start = code = mono_code_manager_reserve (domain->code_mp, size);
+       start = code = mono_domain_code_reserve (domain, size);
        code = mono_ppc_create_pre_code_ftnptr (code);
        short_branch = branch_for_target_reachable (code + 4, addr);
        if (short_branch)
-               mono_code_manager_commit (domain->code_mp, code, size, 8);
+               mono_domain_code_commit (domain, code, size, 8);
        mono_domain_unlock (domain);
 
        if (short_branch) {
@@ -347,13 +347,13 @@ mono_arch_create_specific_trampoline (gpointer arg1, MonoTrampolineType tramp_ty
        tramp = mono_get_trampoline_code (tramp_type);
 
        mono_domain_lock (domain);
-       code = buf = mono_code_manager_reserve_align (domain->code_mp, TRAMPOLINE_SIZE, 4);
+       code = buf = mono_domain_code_reserve_align (domain, TRAMPOLINE_SIZE, 4);
        short_branch = branch_for_target_reachable (code + MONO_PPC_32_64_CASE (8, 5*4), tramp);
 #ifdef __mono_ppc64__
        /* FIXME: make shorter if possible */
 #else
        if (short_branch)
-               mono_code_manager_commit (domain->code_mp, code, TRAMPOLINE_SIZE, 12);
+               mono_domain_code_commit (domain, code, TRAMPOLINE_SIZE, 12);
 #endif
        mono_domain_unlock (domain);
 

diff --git a/mono/mini/tramp-s390.c b/mono/mini/tramp-s390.c
index 3087c64df258fb3d57976be39fc2940e1c0c97fb..c71dd61108f60d11840214675861cc888bbecfe2 100644 (file)
--- a/mono/mini/tramp-s390.c
+++ b/mono/mini/tramp-s390.c
@@ -99,9 +99,7 @@ mono_arch_get_unbox_trampoline (MonoGenericSharingContext *gsctx, MonoMethod *me
        if (MONO_TYPE_ISSTRUCT (mono_method_signature (method)->ret))
                this_pos = s390_r3;
 
-       mono_domain_lock (domain);
-       start = code = mono_code_manager_reserve (domain->code_mp, 28);
-       mono_domain_unlock (domain);
+       start = code = mono_domain_code_reserve (domain, 28);
     
        s390_basr (code, s390_r13, 0);
        s390_j    (code, 4);
@@ -490,9 +488,7 @@ mono_arch_create_specific_trampoline (gpointer arg1, MonoTrampolineType tramp_ty
        /* purpose is to provide the generic part with the          */
        /* MonoMethod *method pointer. We'll use r1 to keep it.     */
        /*----------------------------------------------------------*/
-       mono_domain_lock (domain);
-       code = buf = mono_code_manager_reserve (domain->code_mp, SPECIFIC_TRAMPOLINE_SIZE);
-       mono_domain_unlock (domain);
+       code = buf = mono_domain_code_reserve (domain, SPECIFIC_TRAMPOLINE_SIZE);
 
        s390_basr (buf, s390_r1, 0);
        s390_j    (buf, 4);

diff --git a/mono/mini/tramp-s390x.c b/mono/mini/tramp-s390x.c
index b382c84a8e0ca6b35b95a58927f2fe23ac5fab54..69c569fef6e57cb78e0960b3847f1b1aadedc515 100644 (file)
--- a/mono/mini/tramp-s390x.c
+++ b/mono/mini/tramp-s390x.c
@@ -99,9 +99,7 @@ mono_arch_get_unbox_trampoline (MonoGenericSharingContext *gsctx, MonoMethod *me
        if (MONO_TYPE_ISSTRUCT (mono_method_signature (method)->ret))
                this_pos = s390_r3;
 
-       mono_domain_lock (domain);
-       start = code = mono_code_manager_reserve (domain->code_mp, 28);
-       mono_domain_unlock (domain);
+       start = code = mono_domain_code_reserve (domain, 28);
 
        s390_basr (code, s390_r1, 0);
        s390_j    (code, 6);
@@ -508,9 +506,7 @@ mono_arch_create_specific_trampoline (gpointer arg1, MonoTrampolineType tramp_ty
        /* purpose is to provide the generic part with the          */
        /* MonoMethod *method pointer. We'll use r1 to keep it.     */
        /*----------------------------------------------------------*/
-       mono_domain_lock (domain);
-       code = buf = mono_code_manager_reserve (domain->code_mp, SPECIFIC_TRAMPOLINE_SIZE);
-       mono_domain_unlock (domain);
+       code = buf = mono_domain_code_reserve (domain, SPECIFIC_TRAMPOLINE_SIZE);
 
        s390_basr (buf, s390_r1, 0);
        s390_j    (buf, 6);

diff --git a/mono/mini/tramp-sparc.c b/mono/mini/tramp-sparc.c
index ecf8579cc9707eebd9a26537872d02c1a273d3e2..b1e129042b879989a770abc419b7f919d5ca35df 100644 (file)
--- a/mono/mini/tramp-sparc.c
+++ b/mono/mini/tramp-sparc.c
@@ -243,9 +243,7 @@ mono_arch_create_specific_trampoline (gpointer arg1, MonoTrampolineType tramp_ty
 
        tramp = mono_get_trampoline_code (tramp_type);
 
-       mono_domain_lock (domain);
-       code = buf = mono_code_manager_reserve (domain->code_mp, TRAMPOLINE_SIZE * 4);
-       mono_domain_unlock (domain);
+       code = buf = mono_domain_code_reserve (domain, TRAMPOLINE_SIZE * 4);
 
        /* We have to use g5 here because there is no other free register */
        sparc_set (code, tramp, sparc_g5);

diff --git a/mono/mini/tramp-x86.c b/mono/mini/tramp-x86.c
index 771e99508f4b1fc6a7f9f4c983f686182452bb8b..a85dd1f88964f700e929a0390b3bc63c8870d52f 100644 (file)
--- a/mono/mini/tramp-x86.c
+++ b/mono/mini/tramp-x86.c
@@ -48,9 +48,7 @@ mono_arch_get_unbox_trampoline (MonoGenericSharingContext *gsctx, MonoMethod *m,
        if (MONO_TYPE_ISSTRUCT (mono_method_signature (m)->ret))
                this_pos = 8;
            
-       mono_domain_lock (domain);
-       start = code = mono_code_manager_reserve (domain->code_mp, 16);
-       mono_domain_unlock (domain);
+       start = code = mono_domain_code_reserve (domain, 16);
 
        x86_alu_membase_imm (code, X86_ADD, X86_ESP, this_pos, sizeof (MonoObject));
        x86_jump_code (code, addr);
@@ -405,9 +403,7 @@ mono_arch_create_specific_trampoline (gpointer arg1, MonoTrampolineType tramp_ty
        
        tramp = mono_get_trampoline_code (tramp_type);
 
-       mono_domain_lock (domain);
-       code = buf = mono_code_manager_reserve_align (domain->code_mp, TRAMPOLINE_SIZE, 4);
-       mono_domain_unlock (domain);
+       code = buf = mono_domain_code_reserve_align (domain, TRAMPOLINE_SIZE, 4);
 
        x86_push_imm (buf, arg1);
        x86_jump_code (buf, tramp);