/**
* mono_error_box:
* \param ierror The input error that will be boxed.
* \param image The mempool of this image will hold the boxed error.
* Creates a new boxed error in the given mempool from \c MonoError.
* It does not alter \p ierror, so you still have to clean it up with
* \c mono_error_cleanup or \c mono_error_convert_to_exception or another such function.
* \returns the boxed error, or NULL if the mempool could not allocate.
*/
MonoErrorBoxed*
mono_error_box (const MonoError *ierror, MonoImage *image)
{
MonoErrorInternal *from = (MonoErrorInternal*)ierror;
/* Don't know how to box a gchandle */
g_assert (!is_managed_exception (from));
MonoErrorBoxed* box = (MonoErrorBoxed*)mono_image_alloc (image, sizeof (MonoErrorBoxed));
box->image = image;
mono_error_init_flags (&box->error, MONO_ERROR_MEMPOOL_BOXED);
MonoErrorInternal *to = (MonoErrorInternal*)&box->error;
#define DUP_STR(field) do { \
if (from->field) { \
if (!(to->field = mono_image_strdup (image, from->field))) \
to->flags |= MONO_ERROR_INCOMPLETE; \
} else { \
to->field = NULL; \
} \
} while (0)
to->error_code = from->error_code;
DUP_STR (type_name);
DUP_STR (assembly_name);
DUP_STR (member_name);
DUP_STR (exception_name_space);
DUP_STR (exception_name);
DUP_STR (full_message);
DUP_STR (full_message_with_fields);
DUP_STR (first_argument);
to->exn.klass = from->exn.klass;
#undef DUP_STR
return box;
}
static MonoMethod *
create_method_ilgen (MonoMethodBuilder *mb, MonoMethodSignature *signature, int max_stack)
{
MonoMethodHeader *header;
MonoMethodWrapper *mw;
MonoImage *image;
MonoMethod *method;
GList *l;
int i;
g_assert (mb != NULL);
image = m_class_get_image (mb->method->klass);
if (mb->dynamic) {
method = mb->method;
mw = (MonoMethodWrapper*)method;
method->name = mb->name;
method->dynamic = TRUE;
mw->header = header = (MonoMethodHeader *)
g_malloc0 (MONO_SIZEOF_METHOD_HEADER + mb->locals * sizeof (MonoType *));
header->code = mb->code;
for (i = 0, l = mb->locals_list; l; l = l->next, i++) {
header->locals [i] = (MonoType*)l->data;
}
} else
{
/* Realloc the method info into a mempool */
method = (MonoMethod *)mono_image_alloc0 (image, sizeof (MonoMethodWrapper));
memcpy (method, mb->method, sizeof (MonoMethodWrapper));
mw = (MonoMethodWrapper*) method;
if (mb->no_dup_name)
method->name = mb->name;
else
method->name = mono_image_strdup (image, mb->name);
mw->header = header = (MonoMethodHeader *)
mono_image_alloc0 (image, MONO_SIZEOF_METHOD_HEADER + mb->locals * sizeof (MonoType *));
header->code = (const unsigned char *)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++) {
header->locals [i] = (MonoType*)l->data;
}
}
/* Free the locals list so mono_mb_free () doesn't free the types twice */
g_list_free (mb->locals_list);
mb->locals_list = NULL;
method->signature = signature;
if (!signature->hasthis)
method->flags |= METHOD_ATTRIBUTE_STATIC;
if (max_stack < 8)
max_stack = 8;
header->max_stack = max_stack;
header->code_size = mb->pos;
header->num_locals = mb->locals;
header->init_locals = mb->init_locals;
header->volatile_args = mb->volatile_args;
header->volatile_locals = mb->volatile_locals;
mb->volatile_args = NULL;
mb->volatile_locals = NULL;
header->num_clauses = mb->num_clauses;
header->clauses = mb->clauses;
method->skip_visibility = mb->skip_visibility;
i = g_list_length ((GList *)mw->method_data);
if (i) {
GList *tmp;
void **data;
l = g_list_reverse ((GList *)mw->method_data);
if (method_is_dynamic (method))
data = (void **)g_malloc (sizeof (gpointer) * (i + 1));
else
data = (void **)mono_image_alloc (image, sizeof (gpointer) * (i + 1));
/* store the size in the first element */
data [0] = GUINT_TO_POINTER (i);
i = 1;
for (tmp = l; tmp; tmp = tmp->next) {
data [i++] = tmp->data;
}
g_list_free (l);
mw->method_data = data;
}
/*{
static int total_code = 0;
static int total_alloc = 0;
total_code += mb->pos;
total_alloc += mb->code_size;
g_print ("code size: %d of %d (allocated: %d)\n", mb->pos, total_code, total_alloc);
}*/
#ifdef DEBUG_RUNTIME_CODE
printf ("RUNTIME CODE FOR %s\n", mono_method_full_name (method, TRUE));
printf ("%s\n", mono_disasm_code (&marshal_dh, method, mb->code, mb->code + mb->pos));
#endif
if (mb->param_names) {
char **param_names = (char **)mono_image_alloc0 (image, signature->param_count * sizeof (gpointer));
for (i = 0; i < signature->param_count; ++i)
param_names [i] = mono_image_strdup (image, mb->param_names [i]);
mono_image_lock (image);
if (!image->wrapper_param_names)
image->wrapper_param_names = g_hash_table_new (NULL, NULL);
g_hash_table_insert (image->wrapper_param_names, method, param_names);
mono_image_unlock (image);
}
return method;
}
