+Tue Sep 23 15:24:03 CEST 2008 Paolo Molaro <lupus@ximian.com>
+
+ * class.c, domain-internals.h, domain.c, generic-sharing.c, image.c,
+ loader.c, marshal.c, metadata-internals.h, metadata.c,
+ method-builder.c, object.c, reflection.c: introduced specific functions
+ to allocate from the domain and image mempools and cleaned up most of
+ the code to use them (still missing a few in reflection.c).
+ Keep the loader bytes counter updated.
+
Mon Sep 22 17:33:12 CEST 2008 Paolo Molaro <lupus@ximian.com>
* domain.c, monitor.c, boehm-gc.c, gc.c: update some of the GC and
/* Prevent infinite loops if the class references itself */
class->size_inited = 1;
- class->fields = mono_mempool_alloc0 (class->image->mempool, sizeof (MonoClassField) * top);
+ class->fields = mono_image_alloc0 (class->image, sizeof (MonoClassField) * top);
if (class->generic_container) {
container = class->generic_container;
{
MonoMethod *method;
- method = (MonoMethod *) mono_mempool_alloc0 (class->image->mempool, sizeof (MonoMethodPInvoke));
+ method = (MonoMethod *) mono_image_alloc0 (class->image, sizeof (MonoMethodPInvoke));
method->klass = class;
method->flags = METHOD_ATTRIBUTE_PUBLIC;
method->iflags = METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL;
class->method.count += class->interface_count * count_generic;
}
- methods = mono_mempool_alloc0 (class->image->mempool, sizeof (MonoMethod*) * class->method.count);
+ methods = mono_image_alloc0 (class->image, sizeof (MonoMethod*) * class->method.count);
sig = mono_metadata_signature_alloc (class->image, class->rank);
sig->ret = &mono_defaults.void_class->byval_arg;
for (i = 0; i < class->interface_count; i++)
setup_generic_array_ifaces (class, class->interfaces [i], methods, first_generic + i * count_generic);
} else {
- methods = mono_mempool_alloc (class->image->mempool, sizeof (MonoMethod*) * class->method.count);
+ methods = mono_image_alloc (class->image, sizeof (MonoMethod*) * class->method.count);
for (i = 0; i < class->method.count; ++i) {
int idx = mono_metadata_translate_token_index (class->image, MONO_TABLE_METHOD, class->method.first + i + 1);
methods [i] = mono_get_method (class->image, MONO_TOKEN_METHOD_DEF | idx, class);
if (class->property.count)
mono_class_setup_methods (class);
- properties = mono_mempool_alloc0 (class->image->mempool, sizeof (MonoProperty) * class->property.count);
+ properties = mono_image_alloc0 (class->image, sizeof (MonoProperty) * class->property.count);
for (i = class->property.first; i < last; ++i) {
mono_metadata_decode_table_row (class->image, MONO_TABLE_PROPERTY, i, cols, MONO_PROPERTY_SIZE);
properties [i - class->property.first].parent = class;
if (class->event.count)
mono_class_setup_methods (class);
- events = mono_mempool_alloc0 (class->image->mempool, sizeof (MonoEvent) * class->event.count);
+ events = mono_image_alloc0 (class->image, sizeof (MonoEvent) * class->event.count);
for (i = class->event.first; i < last; ++i) {
MonoEvent *event = &events [i - class->event.first];
g_assert (class->interface_offsets_count == interface_offsets_count);
} else {
class->interface_offsets_count = interface_offsets_count;
- class->interfaces_packed = mono_mempool_alloc (class->image->mempool, sizeof (MonoClass*) * interface_offsets_count);
- class->interface_offsets_packed = mono_mempool_alloc (class->image->mempool, sizeof (guint16) * interface_offsets_count);
- class->interface_bitmap = mono_mempool_alloc0 (class->image->mempool, (sizeof (guint8) * ((max_iid + 1) >> 3)) + (((max_iid + 1) & 7)? 1 :0));
+ class->interfaces_packed = mono_image_alloc (class->image, sizeof (MonoClass*) * interface_offsets_count);
+ class->interface_offsets_packed = mono_image_alloc (class->image, sizeof (guint16) * interface_offsets_count);
+ class->interface_bitmap = mono_image_alloc0 (class->image, (sizeof (guint8) * ((max_iid + 1) >> 3)) + (((max_iid + 1) & 7)? 1 :0));
for (interface_offsets_count = 0, i = 0; i <= max_iid; i++) {
if (interface_offsets_full [i] != -1) {
class->interface_bitmap [i >> 3] |= (1 << (i & 7));
mono_memory_barrier ();
class->vtable = class->parent->vtable;
} else {
- MonoMethod **tmp = mono_mempool_alloc0 (class->image->mempool, sizeof (gpointer) * class->vtable_size);
+ MonoMethod **tmp = mono_image_alloc0 (class->image, sizeof (gpointer) * class->vtable_size);
memcpy (tmp, vtable, sizeof (gpointer) * class->vtable_size);
mono_memory_barrier ();
class->vtable = tmp;
g_assert_not_reached ();
}
- name = mono_mempool_alloc (mono_defaults.corlib->mempool, strlen (iname) + strlen (mname) + 1);
+ name = mono_image_alloc (mono_defaults.corlib, strlen (iname) + strlen (mname) + 1);
strcpy (name, iname);
strcpy (name + strlen (iname), mname);
generic_array_method_info [i].name = name;
}
static char*
-concat_two_strings_with_zero (MonoMemPool *pool, const char *s1, const char *s2)
+concat_two_strings_with_zero (MonoImage *image, const char *s1, const char *s2)
{
int len = strlen (s1) + strlen (s2) + 2;
- char *s = mono_mempool_alloc (pool, len);
+ char *s = mono_image_alloc (image, len);
int result;
result = g_snprintf (s, len, "%s%c%s", s1, '\0', s2);
switch (error->exception_type) {
case MONO_EXCEPTION_TYPE_LOAD:
- exception_data = concat_two_strings_with_zero (class->image->mempool, error->class_name, error->assembly_name);
+ exception_data = concat_two_strings_with_zero (class->image, error->class_name, error->assembly_name);
break;
case MONO_EXCEPTION_MISSING_METHOD:
- exception_data = concat_two_strings_with_zero (class->image->mempool, error->class_name, error->member_name);
+ exception_data = concat_two_strings_with_zero (class->image, error->class_name, error->member_name);
break;
case MONO_EXCEPTION_MISSING_FIELD: {
else
class_name = error->klass->name;
- exception_data = concat_two_strings_with_zero (class->image->mempool, class_name, error->member_name);
+ exception_data = concat_two_strings_with_zero (class->image, class_name, error->member_name);
if (name_space)
g_free ((void*)class_name);
else
msg = "Could not load file or assembly '%s' or one of its dependencies.";
- exception_data = concat_two_strings_with_zero (class->image->mempool, msg, error->assembly_name);
+ exception_data = concat_two_strings_with_zero (class->image, msg, error->assembly_name);
break;
}
}
if (mono_verifier_is_enabled_for_class (class) && !mono_verifier_verify_class (class)) {
- mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, concat_two_strings_with_zero (class->image->mempool, class->name, class->image->assembly_name));
+ mono_class_set_failure (class, MONO_EXCEPTION_TYPE_LOAD, concat_two_strings_with_zero (class->image, class->name, class->image->assembly_name));
class_init_ok = FALSE;
}
class->idepth = 1;
ms = MAX (MONO_DEFAULT_SUPERTABLE_SIZE, class->idepth);
- class->supertypes = mono_mempool_alloc0 (class->image->mempool, sizeof (MonoClass *) * ms);
+ class->supertypes = mono_image_alloc0 (class->image, sizeof (MonoClass *) * ms);
if (class->parent) {
class->supertypes [class->idepth - 1] = class;
name = mono_metadata_string_heap (image, cols [MONO_TYPEDEF_NAME]);
nspace = mono_metadata_string_heap (image, cols [MONO_TYPEDEF_NAMESPACE]);
- class = mono_mempool_alloc0 (image->mempool, sizeof (MonoClass));
+ class = mono_image_alloc0 (image, sizeof (MonoClass));
class->name = name;
class->name_space = nspace;
/* FIXME: */
image = mono_defaults.corlib;
- klass = param->pklass = mono_mempool_alloc0 (image->mempool, sizeof (MonoClass));
+ klass = param->pklass = mono_image_alloc0 (image, sizeof (MonoClass));
if (param->name)
klass->name = param->name;
else {
- klass->name = mono_mempool_alloc0 (image->mempool, 16);
+ klass->name = mono_image_alloc0 (image, 16);
sprintf ((char*)klass->name, is_mvar ? "!!%d" : "!%d", param->num);
}
klass->name_space = "";
if (count - pos > 0) {
klass->interface_count = count - pos;
- klass->interfaces = mono_mempool_alloc0 (image->mempool, sizeof (MonoClass *) * (count - pos));
+ klass->interfaces = mono_image_alloc0 (image, sizeof (MonoClass *) * (count - pos));
for (i = pos; i < count; i++)
klass->interfaces [i - pos] = param->constraints [i];
}
mono_loader_unlock ();
return result;
}
- result = mono_mempool_alloc0 (image->mempool, sizeof (MonoClass));
+ result = mono_image_alloc0 (image, sizeof (MonoClass));
result->parent = NULL; /* no parent for PTR types */
result->name_space = el_class->name_space;
name = g_strdup_printf ("%s*", el_class->name);
- result->name = mono_mempool_strdup (image->mempool, name);
+ result->name = mono_image_strdup (image, name);
g_free (name);
mono_profiler_class_event (result, MONO_PROFILE_START_LOAD);
mono_class_init (parent);
}
- class = mono_mempool_alloc0 (image->mempool, sizeof (MonoClass));
+ class = mono_image_alloc0 (image, sizeof (MonoClass));
class->image = image;
class->name_space = eclass->name_space;
name [nsize + rank] = '*';
name [nsize + rank + bounded] = ']';
name [nsize + rank + bounded + 1] = 0;
- class->name = mono_mempool_strdup (image->mempool, name);
+ class->name = mono_image_strdup (image, name);
g_free (name);
mono_profiler_class_event (class, MONO_PROFILE_START_LOAD);
/* generic IList, ICollection, IEnumerable */
class->interface_count = 1;
- class->interfaces = mono_mempool_alloc0 (image->mempool, sizeof (MonoClass*) * class->interface_count);
+ class->interfaces = mono_image_alloc0 (image, sizeof (MonoClass*) * class->interface_count);
args [0] = &eclass->byval_arg;
class->interfaces [0] = mono_class_bind_generic_parameters (
class->element_class = eclass;
if ((rank > 1) || bounded) {
- MonoArrayType *at = mono_mempool_alloc0 (image->mempool, sizeof (MonoArrayType));
+ MonoArrayType *at = mono_image_alloc0 (image, sizeof (MonoArrayType));
class->byval_arg.type = MONO_TYPE_ARRAY;
class->byval_arg.data.array = at;
at->eklass = eclass;
char *
mono_make_shadow_copy (const char *filename);
+gpointer
+mono_domain_alloc (MonoDomain *domain, guint size) MONO_INTERNAL;
+
+gpointer
+mono_domain_alloc0 (MonoDomain *domain, guint size) MONO_INTERNAL;
+
/*
* Installs a new function which is used to return a MonoJitInfo for a method inside
* an AOT module.
mono_mempool_invalidate (domain->mp);
mono_code_manager_invalidate (domain->code_mp);
#else
+ mono_perfcounters->loader_bytes -= mono_mempool_get_allocated (domain->mp);
mono_mempool_destroy (domain->mp);
domain->mp = NULL;
mono_code_manager_destroy (domain->code_mp);
return domain->domain_id;
}
+gpointer
+mono_domain_alloc (MonoDomain *domain, guint size)
+{
+ mono_perfcounters->loader_bytes += size;
+ return mono_mempool_alloc (domain->mp, size);
+}
+
+gpointer
+mono_domain_alloc0 (MonoDomain *domain, guint size)
+{
+ mono_perfcounters->loader_bytes += size;
+ return mono_mempool_alloc0 (domain->mp, size);
+}
+
void
mono_context_set (MonoAppContext * new_context)
{
num_allocted++;
num_bytes += size;
- return mono_mempool_alloc0 (class->image->mempool, size);
+ return mono_image_alloc0 (class->image, size);
}
/*
num_allocted++;
num_bytes += size;
- return mono_mempool_alloc0 (image->mempool, size);
+ return mono_image_alloc0 (image, size);
}
#define MONO_RGCTX_SLOT_USED_MARKER ((gpointer)&mono_defaults.object_class->byval_arg)
static int mrgctx_bytes_alloced = 0;
int size = mono_class_rgctx_get_array_size (n, is_mrgctx) * sizeof (gpointer);
- gpointer array = mono_mempool_alloc0 (domain->mp, size);
+ gpointer array = mono_domain_alloc0 (domain, size);
if (!inited) {
mono_counters_register ("RGCTX num arrays alloced", MONO_COUNTER_GENERICS | MONO_COUNTER_INT, &rgctx_num_alloced);
g_free (image->modules_loaded);
if (image->references)
g_free (image->references);
+ mono_perfcounters->loader_bytes -= mono_mempool_get_allocated (image->mempool);
/*g_print ("destroy image %p (dynamic: %d)\n", image, image->dynamic);*/
if (!image->dynamic) {
if (debug_assembly_unload)
// the Authenticode "pre" (non ASN.1) header is 8 bytes long
return ((de->rva != 0) && (de->size > 8));
}
+
+gpointer
+mono_image_alloc (MonoImage *image, guint size)
+{
+ mono_perfcounters->loader_bytes += size;
+ return mono_mempool_alloc (image->mempool, size);
+}
+
+gpointer
+mono_image_alloc0 (MonoImage *image, guint size)
+{
+ mono_perfcounters->loader_bytes += size;
+ return mono_mempool_alloc0 (image->mempool, size);
+}
+
+char*
+mono_image_strdup (MonoImage *image, const char *s)
+{
+ mono_perfcounters->loader_bytes += strlen (s);
+ return mono_mempool_strdup (image->mempool, s);
+}
+
entry->next = global_dll_map;
global_dll_map = entry;
} else {
- MonoMemPool *mpool = assembly->mempool;
- entry = mono_mempool_alloc0 (mpool, sizeof (MonoDllMap));
- entry->dll = dll? mono_mempool_strdup (mpool, dll): NULL;
- entry->target = tdll? mono_mempool_strdup (mpool, tdll): NULL;
- entry->func = func? mono_mempool_strdup (mpool, func): NULL;
- entry->target_func = tfunc? mono_mempool_strdup (mpool, tfunc): NULL;
+ entry = mono_image_alloc0 (assembly, sizeof (MonoDllMap));
+ entry->dll = dll? mono_image_strdup (assembly, dll): NULL;
+ entry->target = tdll? mono_image_strdup (assembly, tdll): NULL;
+ entry->func = func? mono_image_strdup (assembly, func): NULL;
+ entry->target_func = tfunc? mono_image_strdup (assembly, tfunc): NULL;
entry->next = assembly->dll_map;
assembly->dll_map = entry;
}
if ((cols [2] & METHOD_ATTRIBUTE_PINVOKE_IMPL) ||
(cols [1] & METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL))
- result = (MonoMethod *)mono_mempool_alloc0 (image->mempool, sizeof (MonoMethodPInvoke));
+ result = (MonoMethod *)mono_image_alloc0 (image, sizeof (MonoMethodPInvoke));
else
- result = (MonoMethod *)mono_mempool_alloc0 (image->mempool, sizeof (MonoMethodNormal));
+ result = (MonoMethod *)mono_image_alloc0 (image, sizeof (MonoMethodNormal));
mono_stats.method_count ++;
/* try */
mono_loader_lock ();
- main_clause = mono_mempool_alloc0 (method->klass->image->mempool, sizeof (MonoExceptionClause));
+ main_clause = mono_image_alloc0 (method->klass->image, sizeof (MonoExceptionClause));
mono_loader_unlock ();
main_clause->try_offset = mono_mb_get_label (mb);
pos = mono_mb_emit_branch (mb, CEE_LEAVE);
mono_loader_lock ();
- clause = mono_mempool_alloc0 (target_klass->image->mempool, sizeof (MonoExceptionClause));
+ clause = mono_image_alloc0 (target_klass->image, sizeof (MonoExceptionClause));
mono_loader_unlock ();
clause->flags = MONO_EXCEPTION_CLAUSE_FILTER;
clause->try_len = mono_mb_get_label (mb);
this_local = mono_mb_add_local (mb, &mono_defaults.object_class->byval_arg);
mono_loader_lock ();
- clause = mono_mempool_alloc0 (method->klass->image->mempool, sizeof (MonoExceptionClause));
+ clause = mono_image_alloc0 (method->klass->image, sizeof (MonoExceptionClause));
mono_loader_unlock ();
clause->flags = MONO_EXCEPTION_CLAUSE_FINALLY;
layout = klass->flags & TYPE_ATTRIBUTE_LAYOUT_MASK;
/* The mempool is protected by the loader lock */
- info = mono_mempool_alloc0 (klass->image->mempool, sizeof (MonoMarshalType) + sizeof (MonoMarshalField) * count);
+ info = mono_image_alloc0 (klass->image, sizeof (MonoMarshalType) + sizeof (MonoMarshalField) * count);
info->num_fields = count;
/* Try to find a size for this type in metadata */
if (!ccw_entry) {
int vtable_index = method_count-1+start_slot;
mono_loader_lock ();
- vtable = mono_mempool_alloc0 (klass->image->mempool, sizeof (gpointer)*(method_count+start_slot));
+ vtable = mono_image_alloc0 (klass->image, sizeof (gpointer)*(method_count+start_slot));
mono_loader_unlock ();
memcpy (vtable, iunknown, sizeof (iunknown));
if (start_slot == 7)
/* try */
mono_loader_lock ();
- clause = mono_mempool_alloc0 (image->mempool, sizeof (MonoExceptionClause));
+ clause = mono_image_alloc0 (image, sizeof (MonoExceptionClause));
mono_loader_unlock ();
clause->try_offset = mono_mb_get_label (mb);
void
mono_image_check_for_module_cctor (MonoImage *image) MONO_INTERNAL;
+gpointer
+mono_image_alloc (MonoImage *image, guint size) MONO_INTERNAL;
+
+gpointer
+mono_image_alloc0 (MonoImage *image, guint size) MONO_INTERNAL;
+
+char*
+mono_image_strdup (MonoImage *image, const char *s) MONO_INTERNAL;
+
void
mono_metadata_clean_for_image (MonoImage *image) MONO_INTERNAL;
const char *ptr, const char **rptr)
{
int i;
- MonoArrayType *array = mono_mempool_alloc0 (m->mempool, sizeof (MonoArrayType));
+ MonoArrayType *array = mono_image_alloc0 (m, sizeof (MonoArrayType));
MonoType *etype;
etype = mono_metadata_parse_type_full (m, container, MONO_PARSE_TYPE, 0, ptr, &ptr);
}
if (count) {
- type = mono_mempool_alloc0 (m->mempool, sizeof (MonoType) + ((gint32)count - MONO_ZERO_LEN_ARRAY) * sizeof (MonoCustomMod));
+ type = mono_image_alloc0 (m, sizeof (MonoType) + ((gint32)count - MONO_ZERO_LEN_ARRAY) * sizeof (MonoCustomMod));
type->num_mods = count;
if (count > 64)
g_warning ("got more than 64 modifiers in type");
/* printf ("%x %x %c %s\n", type->attrs, type->num_mods, type->pinned ? 'p' : ' ', mono_type_full_name (type)); */
if (type == &stype) {
- type = mono_mempool_alloc (m->mempool, sizeof (MonoType));
+ type = mono_image_alloc (m, sizeof (MonoType));
memcpy (type, &stype, sizeof (MonoType));
}
mono_loader_unlock ();
MonoMethodSignature *sig;
mono_loader_lock ();
- sig = mono_mempool_alloc0 (m->mempool, sizeof (MonoMethodSignature) + ((gint32)nparams - MONO_ZERO_LEN_ARRAY) * sizeof (MonoType*));
+ sig = mono_image_alloc0 (m, sizeof (MonoMethodSignature) + ((gint32)nparams - MONO_ZERO_LEN_ARRAY) * sizeof (MonoType*));
sig->param_count = nparams;
sig->sentinelpos = -1;
mono_loader_unlock ();
generic_container = select_container (generic_container, type);
if (!generic_container) {
/* Create dummy MonoGenericParam */
- MonoGenericParam *param = mono_mempool_alloc0 (m->mempool, sizeof (MonoGenericParam));
- param->name = mono_mempool_alloc0 (m->mempool, 8);
+ MonoGenericParam *param = mono_image_alloc0 (m, sizeof (MonoGenericParam));
+ param->name = mono_image_alloc0 (m, 8);
sprintf ((char*)param->name, "%d", index);
param->num = index;
param->image = m;
int i;
mh->num_clauses = is_fat ? sect_data_len / 24: sect_data_len / 12;
/* we could just store a pointer if we don't need to byteswap */
- mh->clauses = mono_mempool_alloc0 (m->mempool, sizeof (MonoExceptionClause) * mh->num_clauses);
+ mh->clauses = mono_image_alloc0 (m, sizeof (MonoExceptionClause) * mh->num_clauses);
for (i = 0; i < mh->num_clauses; ++i) {
MonoExceptionClause *ec = &mh->clauses [i];
guint32 tof_value;
mono_loader_lock ();
switch (format) {
case METHOD_HEADER_TINY_FORMAT:
- mh = mono_mempool_alloc0 (m->mempool, sizeof (MonoMethodHeader));
+ mh = mono_image_alloc0 (m, sizeof (MonoMethodHeader));
ptr++;
mh->max_stack = 8;
local_var_sig_tok = 0;
mono_loader_unlock ();
return mh;
case METHOD_HEADER_TINY_FORMAT1:
- mh = mono_mempool_alloc0 (m->mempool, sizeof (MonoMethodHeader));
+ mh = mono_image_alloc0 (m, sizeof (MonoMethodHeader));
ptr++;
mh->max_stack = 8;
local_var_sig_tok = 0;
g_warning ("wrong signature for locals blob");
locals_ptr++;
len = mono_metadata_decode_value (locals_ptr, &locals_ptr);
- mh = mono_mempool_alloc0 (m->mempool, sizeof (MonoMethodHeader) + (len - MONO_ZERO_LEN_ARRAY) * sizeof (MonoType*));
+ mh = mono_image_alloc0 (m, sizeof (MonoMethodHeader) + (len - MONO_ZERO_LEN_ARRAY) * sizeof (MonoType*));
mh->num_locals = len;
for (i = 0; i < len; ++i) {
mh->locals [i] = mono_metadata_parse_type_full (
}
}
} else {
- mh = mono_mempool_alloc0 (m->mempool, sizeof (MonoMethodHeader));
+ mh = mono_image_alloc0 (m, sizeof (MonoMethodHeader));
}
mh->code = code;
mh->code_size = code_size;
}
mono_loader_lock ();
- result = mono_mempool_alloc0 (meta->mempool, sizeof (MonoClass*) * (pos - start));
+ result = mono_image_alloc0 (meta, sizeof (MonoClass*) * (pos - start));
mono_loader_unlock ();
pos = start;
ptr = mono_metadata_blob_heap (image, cols [MONO_TYPESPEC_SIGNATURE]);
len = mono_metadata_decode_value (ptr, &ptr);
- type = mono_mempool_alloc0 (image->mempool, sizeof (MonoType));
+ type = mono_image_alloc0 (image, sizeof (MonoType));
if (*ptr == MONO_TYPE_BYREF) {
type->byref = 1;
mono_metadata_decode_row (tdef, i - 1, cols, MONO_GENERICPARAM_SIZE);
params = NULL;
n = 0;
- container = mono_mempool_alloc0 (image->mempool, sizeof (MonoGenericContainer));
+ container = mono_image_alloc0 (image, sizeof (MonoGenericContainer));
do {
n++;
params = g_realloc (params, sizeof (MonoGenericParam) * n);
} while (cols [MONO_GENERICPARAM_OWNER] == owner);
container->type_argc = n;
- container->type_params = mono_mempool_alloc0 (image->mempool, sizeof (MonoGenericParam) * n);
+ container->type_params = mono_image_alloc0 (image, sizeof (MonoGenericParam) * n);
memcpy (container->type_params, params, sizeof (MonoGenericParam) * n);
g_free (params);
container->parent = parent_container;
{
MonoMethodHeader *header;
MonoMethodWrapper *mw;
- MonoMemPool *mp;
+ MonoImage *image;
MonoMethod *method;
GList *l;
int i;
g_assert (mb != NULL);
- mp = mb->method->klass->image->mempool;
+ image = mb->method->klass->image;
mono_loader_lock ();
if (mb->dynamic) {
} else {
/* Realloc the method info into a mempool */
- method = mono_mempool_alloc0 (mp, sizeof (MonoMethodWrapper));
+ method = mono_image_alloc0 (image, sizeof (MonoMethodWrapper));
memcpy (method, mb->method, sizeof (MonoMethodWrapper));
if (mb->no_dup_name)
method->name = mb->name;
else
- method->name = mono_mempool_strdup (mp, mb->name);
+ method->name = mono_image_strdup (image, mb->name);
((MonoMethodNormal *)method)->header = header = (MonoMethodHeader *)
- mono_mempool_alloc0 (mp, sizeof (MonoMethodHeader) + mb->locals * sizeof (MonoType *));
+ mono_image_alloc0 (image, sizeof (MonoMethodHeader) + mb->locals * sizeof (MonoType *));
- header->code = mono_mempool_alloc (mp, mb->pos);
+ header->code = mono_image_alloc (image, mb->pos);
memcpy ((char*)header->code, mb->code, mb->pos);
for (i = 0, l = mb->locals_list; l; l = l->next, i++) {
if (method->dynamic)
data = g_malloc (sizeof (gpointer) * (i + 1));
else
- data = mono_mempool_alloc (mp, sizeof (gpointer) * (i + 1));
+ data = mono_image_alloc (image, sizeof (gpointer) * (i + 1));
/* store the size in the first element */
data [0] = GUINT_TO_POINTER (i);
i = 1;
mono_stats.used_class_count++;
mono_stats.class_vtable_size += vtable_size;
- interface_offsets = mono_mempool_alloc0 (domain->mp, vtable_size);
+ interface_offsets = mono_domain_alloc0 (domain, vtable_size);
if (ARCH_USE_IMT)
vt = (MonoVTable*) ((char*)interface_offsets + imt_table_bytes);
if (bitmap != default_bitmap)
g_free (bitmap);
} else {
- vt->data = mono_mempool_alloc0 (domain->mp, class_size);
+ vt->data = mono_domain_alloc0 (domain, class_size);
}
mono_stats.class_static_data_size += class_size;
}
/* this is a bounded memory retention issue: may want to
* handle it differently when we'll have a rcu-like system.
*/
- runtime_info = mono_mempool_alloc0 (class->image->mempool, sizeof (MonoClassRuntimeInfo) + new_size * sizeof (gpointer));
+ runtime_info = mono_image_alloc0 (class->image, sizeof (MonoClassRuntimeInfo) + new_size * sizeof (gpointer));
runtime_info->max_domain = new_size - 1;
/* copy the stuff from the older info */
if (old_info) {
mono_stats.class_vtable_size += vtsize + extra_interface_vtsize;
- interface_offsets = mono_mempool_alloc0 (domain->mp, vtsize + extra_interface_vtsize);
+ interface_offsets = mono_domain_alloc0 (domain, vtsize + extra_interface_vtsize);
if (ARCH_USE_IMT)
pvt = (MonoVTable*) (interface_offsets + MONO_IMT_SIZE);
else
}
pvt->max_interface_id = max_interface_id;
- pvt->interface_bitmap = mono_mempool_alloc0 (domain->mp, sizeof (guint8) * (max_interface_id/8 + 1 ));
+ pvt->interface_bitmap = mono_domain_alloc0 (domain, sizeof (guint8) * (max_interface_id/8 + 1 ));
if (! ARCH_USE_IMT) {
/* initialize interface offsets */
/**
* copy_remote_class_key:
*
- * Make a copy of KEY in the mempool MP and return the copy.
+ * Make a copy of KEY in the domain and return the copy.
*/
static gpointer*
-copy_remote_class_key (MonoMemPool *mp, gpointer *key)
+copy_remote_class_key (MonoDomain *domain, gpointer *key)
{
int key_size = (GPOINTER_TO_UINT (key [0]) + 1) * sizeof (gpointer);
- gpointer *mp_key = mono_mempool_alloc (mp, key_size);
+ gpointer *mp_key = mono_domain_alloc (domain, key_size);
memcpy (mp_key, key, key_size);
return rc;
}
- mp_key = copy_remote_class_key (domain->mp, key);
+ mp_key = copy_remote_class_key (domain, key);
g_free (key);
key = mp_key;
if (proxy_class->flags & TYPE_ATTRIBUTE_INTERFACE) {
- rc = mono_mempool_alloc (domain->mp, sizeof(MonoRemoteClass) + sizeof(MonoClass*));
+ rc = mono_domain_alloc (domain, sizeof(MonoRemoteClass) + sizeof(MonoClass*));
rc->interface_count = 1;
rc->interfaces [0] = proxy_class;
rc->proxy_class = mono_defaults.marshalbyrefobject_class;
} else {
- rc = mono_mempool_alloc (domain->mp, sizeof(MonoRemoteClass));
+ rc = mono_domain_alloc (domain, sizeof(MonoRemoteClass));
rc->interface_count = 0;
rc->proxy_class = proxy_class;
}
rc->default_vtable = NULL;
rc->xdomain_vtable = NULL;
rc->proxy_class_name = mono_string_to_utf8_mp (domain->mp, class_name);
+ mono_perfcounters->loader_bytes += mono_string_length (class_name) + 1;
g_hash_table_insert (domain->proxy_vtable_hash, key, rc);
return rc;
}
- mp_key = copy_remote_class_key (domain->mp, key);
+ mp_key = copy_remote_class_key (domain, key);
g_free (key);
key = mp_key;
if (extra_class->flags & TYPE_ATTRIBUTE_INTERFACE) {
int i,j;
- rc = mono_mempool_alloc (domain->mp, sizeof(MonoRemoteClass) + sizeof(MonoClass*) * (remote_class->interface_count + 1));
+ rc = mono_domain_alloc (domain, sizeof(MonoRemoteClass) + sizeof(MonoClass*) * (remote_class->interface_count + 1));
rc->proxy_class = remote_class->proxy_class;
rc->interface_count = remote_class->interface_count + 1;
rc->interfaces [j] = extra_class;
} else {
// Replace the old class. The interface array is the same
- rc = mono_mempool_alloc (domain->mp, sizeof(MonoRemoteClass) + sizeof(MonoClass*) * remote_class->interface_count);
+ rc = mono_domain_alloc (domain, sizeof(MonoRemoteClass) + sizeof(MonoClass*) * remote_class->interface_count);
rc->proxy_class = extra_class;
rc->interface_count = remote_class->interface_count;
if (rc->interface_count > 0)
for (i = 0; i < count; ++i) {
cattr = (MonoReflectionCustomAttr*)mono_array_get (cattrs, gpointer, i);
if (custom_attr_visible (image, cattr)) {
- unsigned char *saved = mono_mempool_alloc (image->mempool, mono_array_length (cattr->data));
+ unsigned char *saved = mono_image_alloc (image, mono_array_length (cattr->data));
memcpy (saved, mono_array_addr (cattr->data, char, 0), mono_array_length (cattr->data));
ainfo->attrs [index].ctor = cattr->ctor->method;
ainfo->attrs [index].data = saved;
return;
}
- klass = mono_mempool_alloc0 (tb->module->dynamic_image->image.mempool, sizeof (MonoClass));
+ klass = mono_image_alloc0 (&tb->module->dynamic_image->image, sizeof (MonoClass));
klass->image = &tb->module->dynamic_image->image;
if (tb->generic_container)
return;
- tb->generic_container = mono_mempool_alloc0 (klass->image->mempool, sizeof (MonoGenericContainer));
+ tb->generic_container = mono_image_alloc0 (klass->image, sizeof (MonoGenericContainer));
tb->generic_container->owner.klass = klass;
}
g_assert (tb->generic_container && (tb->generic_container->owner.klass == klass));
- klass->generic_container = mono_mempool_alloc0 (klass->image->mempool, sizeof (MonoGenericContainer));
+ klass->generic_container = mono_image_alloc0 (klass->image, sizeof (MonoGenericContainer));
klass->generic_container->owner.klass = klass;
klass->generic_container->type_argc = count;
- klass->generic_container->type_params = mono_mempool_alloc0 (klass->image->mempool, sizeof (MonoGenericParam) * count);
+ klass->generic_container->type_params = mono_image_alloc0 (klass->image, sizeof (MonoGenericParam) * count);
for (i = 0; i < count; i++) {
MonoReflectionGenericParam *gparam = mono_array_get (tb->generic_params, gpointer, i);
num = tb->ctors? mono_array_length (tb->ctors): 0;
num += tb->num_methods;
klass->method.count = num;
- klass->methods = mono_mempool_alloc (klass->image->mempool, sizeof (MonoMethod*) * num);
+ klass->methods = mono_image_alloc (klass->image, sizeof (MonoMethod*) * num);
num = tb->ctors? mono_array_length (tb->ctors): 0;
for (i = 0; i < num; ++i)
klass->methods [i] = ctorbuilder_to_mono_method (klass, mono_array_get (tb->ctors, MonoReflectionCtorBuilder*, i));
if (tb->interfaces) {
klass->interface_count = mono_array_length (tb->interfaces);
- klass->interfaces = mono_mempool_alloc (klass->image->mempool, sizeof (MonoClass*) * klass->interface_count);
+ klass->interfaces = mono_image_alloc (klass->image, sizeof (MonoClass*) * klass->interface_count);
for (i = 0; i < klass->interface_count; ++i) {
MonoReflectionType *iface = mono_array_get (tb->interfaces, gpointer, i);
klass->interfaces [i] = mono_class_from_mono_type (iface->type);
if (!gparam->mbuilder->generic_container) {
MonoReflectionTypeBuilder *tb = (MonoReflectionTypeBuilder *)gparam->mbuilder->type;
MonoClass *klass = my_mono_class_from_mono_type (tb->type.type);
- gparam->mbuilder->generic_container = mono_mempool_alloc0 (klass->image->mempool, sizeof (MonoGenericContainer));
+ gparam->mbuilder->generic_container = mono_image_alloc0 (klass->image, sizeof (MonoGenericContainer));
gparam->mbuilder->generic_container->is_method = TRUE;
}
param->owner = gparam->mbuilder->generic_container;
projects / mono.git / commitdiff