0 /* 0x2A */
};
+/**
+ * These macros can be used to allocate long living atomic data so it won't be
+ * tracked by the garbage collector.
+ */
+#ifdef HAVE_BOEHM_GC
+#define ALLOC_ATOMIC(size) GC_MALLOC_ATOMIC (size)
+#define FREE_ATOMIC(ptr)
+#define REALLOC_ATOMIC(ptr, size) GC_REALLOC ((ptr), (size))
+#else
+#define ALLOC_ATOMIC(size) g_malloc (size)
+#define FREE_ATOMIC(ptr) g_free (ptr)
+#define REALLOC_ATOMIC(ptr, size) g_realloc ((ptr), (size))
+#endif
+
static guint32 mono_image_typedef_or_ref (MonoDynamicAssembly *assembly, MonoType *type);
static guint32 mono_image_get_methodref_token (MonoDynamicAssembly *assembly, MonoMethod *method);
static guint32 mono_image_get_sighelper_token (MonoDynamicAssembly *assembly, MonoReflectionSigHelper *helper);
else
table->alloc_rows *= 2;
- table->values = g_realloc (table->values, (table->alloc_rows) * table->columns * sizeof (guint32));
+ table->values = REALLOC_ATOMIC (table->values, (table->alloc_rows) * table->columns * sizeof (guint32));
}
}
+static void
+make_room_in_stream (MonoDynamicStream *stream, int size)
+{
+ while (stream->alloc_size <= size) {
+ if (stream->alloc_size < 4096)
+ stream->alloc_size = 4096;
+ else
+ stream->alloc_size *= 2;
+ }
+ stream->data = REALLOC_ATOMIC (stream->data, stream->alloc_size);
+}
+
static guint32
string_heap_insert (MonoDynamicStream *sh, const char *str)
{
len = strlen (str) + 1;
idx = sh->index;
- if (idx + len > sh->alloc_size) {
- sh->alloc_size += len + 4096;
- sh->data = g_realloc (sh->data, sh->alloc_size);
- }
+ if (idx + len > sh->alloc_size)
+ make_room_in_stream (sh, idx + len);
+
/*
* We strdup the string even if we already copy them in sh->data
* so that the string pointers in the hash remain valid even if
{
sh->index = 0;
sh->alloc_size = 4096;
- sh->data = g_malloc (4096);
+ sh->data = ALLOC_ATOMIC (4096);
sh->hash = g_hash_table_new (g_str_hash, g_str_equal);
string_heap_insert (sh, "");
}
static void
string_heap_free (MonoDynamicStream *sh)
{
- g_free (sh->data);
+ FREE_ATOMIC (sh->data);
g_hash_table_foreach (sh->hash, (GHFunc)g_free, NULL);
g_hash_table_destroy (sh->hash);
}
mono_image_add_stream_data (MonoDynamicStream *stream, const char *data, guint32 len)
{
guint32 idx;
- if (stream->alloc_size < stream->index + len) {
- stream->alloc_size += len + 4096;
- stream->data = g_realloc (stream->data, stream->alloc_size);
- }
+ if (stream->alloc_size < stream->index + len)
+ make_room_in_stream (stream, stream->index + len);
memcpy (stream->data + stream->index, data, len);
idx = stream->index;
stream->index += len;
mono_image_add_stream_zero (MonoDynamicStream *stream, guint32 len)
{
guint32 idx;
- if (stream->alloc_size < stream->index + len) {
- stream->alloc_size += len + 4096;
- stream->data = g_realloc (stream->data, stream->alloc_size);
- }
+ if (stream->alloc_size < stream->index + len)
+ make_room_in_stream (stream, stream->index + len);
memset (stream->data + stream->index, 0, len);
idx = stream->index;
stream->index += len;
guint32 idx;
char *copy;
gpointer oldkey, oldval;
-
- copy = g_malloc (s1+s2);
+
+ copy = ALLOC_ATOMIC (s1+s2);
memcpy (copy, b1, s1);
memcpy (copy + s1, b2, s2);
- if (g_hash_table_lookup_extended (assembly->blob_cache, copy, &oldkey, &oldval)) {
- g_free (copy);
+ if (mono_g_hash_table_lookup_extended (assembly->blob_cache, copy, &oldkey, &oldval)) {
+ FREE_ATOMIC (copy);
idx = GPOINTER_TO_UINT (oldval);
} else {
idx = mono_image_add_stream_data (&assembly->blob, b1, s1);
mono_image_add_stream_data (&assembly->blob, b2, s2);
- g_hash_table_insert (assembly->blob_cache, copy, GUINT_TO_POINTER (idx));
+ mono_g_hash_table_insert (assembly->blob_cache, copy, GUINT_TO_POINTER (idx));
}
return idx;
}
num_exception = method_count_clauses (mb->ilgen);
} else {
code = mb->code;
+ if (code == NULL)
+ mono_raise_exception (mono_get_exception_argument (NULL, "a method does not have any IL associated"));
+
code_size = mono_array_length (code);
max_stack = 8; /* we probably need to run a verifier on the code... */
}
g_hash_table_insert (dynamic_custom_attrs, obj, ainfo);
}
+void
+mono_custom_attrs_free (MonoCustomAttrInfo *ainfo)
+{
+ /* they are cached, so we don't free them */
+ if (dynamic_custom_attrs && g_hash_table_lookup (dynamic_custom_attrs, ainfo))
+ return;
+ g_free (ainfo);
+}
+
/*
* idx is the table index of the object
* type is one of CUSTOM_ATTR_*
table->rows ++;
alloc_table (table, table->rows);
values = table->values + table->rows * MONO_IMPLMAP_SIZE;
- values [MONO_IMPLMAP_FLAGS] = (mb->native_cc << 8) | mb->charset;
+ /* map CharSet values to on-disk values */
+ values [MONO_IMPLMAP_FLAGS] = (mb->native_cc << 8) | (mb->charset ? (mb->charset - 1) * 2: 1);
values [MONO_IMPLMAP_MEMBER] = (mb->table_idx << 1) | 1; /* memberforwarded: method */
name = mono_string_to_utf8 (mb->dllentry);
values [MONO_IMPLMAP_NAME] = string_heap_insert (&assembly->sheap, name);
MonoReflectionTypeBuilder *type = g_ptr_array_index (types, i);
mono_image_get_type_info (domain, type, assembly);
}
- g_ptr_array_free (types, FALSE);
+ g_ptr_array_free (types, TRUE);
}
/*
image->managed_wrapper_cache = g_hash_table_new (g_direct_hash, g_direct_equal);
image->native_wrapper_cache = g_hash_table_new (g_direct_hash, g_direct_equal);
image->remoting_invoke_cache = g_hash_table_new (g_direct_hash, g_direct_equal);
+ image->synchronized_cache = g_hash_table_new (g_direct_hash, g_direct_equal);
return image;
}
assembly->handleref = g_hash_table_new (g_direct_hash, g_direct_equal);
assembly->tokens = mono_g_hash_table_new (g_direct_hash, g_direct_equal);
assembly->typeref = g_hash_table_new ((GHashFunc)mono_metadata_type_hash, (GCompareFunc)mono_metadata_type_equal);
- assembly->blob_cache = g_hash_table_new ((GHashFunc)mono_blob_entry_hash, (GCompareFunc)mono_blob_entry_equal);
+ assembly->blob_cache = mono_g_hash_table_new ((GHashFunc)mono_blob_entry_hash, (GCompareFunc)mono_blob_entry_equal);
string_heap_init (&assembly->sheap);
mono_image_add_stream_data (&assembly->us, "", 1);
memcpy (pefile->data + text_offset, assembly->assembly.image->raw_metadata, assembly->meta_size);
text_offset += assembly->meta_size;
memcpy (pefile->data + text_offset, assembly->strong_name, assembly->strong_name_size);
+
+ g_free (assembly->assembly.image->raw_metadata);
break;
case MONO_SECTION_RELOC:
rva = (guint32*)(pefile->data + assembly->sections [i].offset);
if (!method->signature->param_count)
return NULL;
- member = mono_method_get_object (domain, method, NULL);
- names = g_new (char *, method->signature->param_count);
- mono_method_get_param_names (method, (const char **) names);
-
/* Note: the cache is based on the address of the signature into the method
* since we already cache MethodInfos with the method as keys.
*/
CHECK_OBJECT (MonoReflectionParameter**, &(method->signature), NULL);
+
+ member = mono_method_get_object (domain, method, NULL);
+ names = g_new (char *, method->signature->param_count);
+ mono_method_get_param_names (method, (const char **) names);
+
oklass = mono_class_from_name (mono_defaults.corlib, "System.Reflection", "ParameterInfo");
#if HAVE_BOEHM_GC
res = GC_MALLOC (sizeof (MonoReflectionParameter*) * method->signature->param_count);
assembly->name = p;
assembly->culture = "";
- while (*p && (isalnum (*p) || *p == '.'))
+ while (*p && (isalnum (*p) || *p == '.' || *p == '-'))
p++;
found_sep = 0;
while (*p == ' ' || *p == ',') {
case MONO_TYPE_CLASS: {
char *n;
MonoType *t;
+ if (*p == (char)0xFF) {
+ *end = p + 1;
+ return NULL;
+ }
handle_type:
slen = mono_metadata_decode_value (p, &p);
n = g_memdup (p, slen + 1);
if (subt == 0x50) {
goto handle_type;
+ } else if (subt == 0x0E) {
+ type = MONO_TYPE_STRING;
+ goto handle_enum;
} else if (subt == 0x55) {
char *n;
MonoType *t;
case MONO_TYPE_SZARRAY:
{
MonoArray *arr;
- guint32 i,alen;
- alen=read32(p);
- p+=4;
- arr=mono_array_new(mono_domain_get(),mono_class_from_mono_type(t->data.type),alen);
+ guint32 i, alen;
+ alen = read32 (p);
+ p += 4;
+ if (alen == 0xffffffff) {
+ *end = p;
+ return NULL;
+ }
+ arr = mono_array_new (mono_domain_get(), mono_class_from_mono_type (t->data.type), alen);
switch (t->data.type->type)
{
case MONO_TYPE_U1:
p+=8;
}
break;
+ case MONO_TYPE_CLASS:
case MONO_TYPE_STRING:
- for (i=0;i<alen;i++)
- {
- if (*p==(char)0xff)
- {
- mono_array_set(arr,gpointer,i,NULL);
- p++;
- }
- else
- {
- slen=mono_metadata_decode_value(p,&p);
- mono_array_set(arr,gpointer,i,mono_string_new_len(mono_domain_get(),p,slen));
- p+=slen;
- }
+ for (i = 0; i < alen; i++) {
+ MonoObject *item = load_cattr_value (image, t->data.type, p, &p);
+ mono_array_set (arr, gpointer, i, item);
}
break;
default:
named += 2;
for (j = 0; j < num_named; j++) {
gint name_len;
- char *name, named_type;
+ char *name, named_type, data_type;
named_type = *named++;
- named++; /* type of data */
+ data_type = *named++; /* type of data */
+ if (data_type == 0x55) {
+ gint type_len;
+ char *type_name;
+ if ((unsigned char) *named == 0x80) /* no idea what this is, but it looks optional */
+ named++;
+ type_len = mono_metadata_decode_blob_size (named, &named);
+ type_name = g_malloc (type_len + 1);
+ memcpy (type_name, named, type_len);
+ type_name [type_len] = 0;
+ named += type_len;
+ /* FIXME: lookup the type and check type consistency */
+ }
name_len = mono_metadata_decode_blob_size (named, &named);
name = g_malloc (name_len + 1);
memcpy (name, named, name_len);
if (!type_is_reference (field->type))
g_free (val);
} else if (named_type == 0x54) {
- MonoProperty *prop = mono_class_get_property_from_name (mono_object_class (attr), name);
+ MonoProperty *prop;
void *pparams [1];
MonoType *prop_type;
+
+ prop = mono_class_get_property_from_name (mono_object_class (attr), name);
/* can we have more that 1 arg in a custom attr named property? */
prop_type = prop->get? prop->get->signature->ret: prop->set->signature->params [prop->set->signature->param_count - 1];
pparams [0] = load_cattr_value (image, prop_type, named, &named);
case MONO_TYPE_CLASS: {
char *str;
guint32 slen;
- MonoClass *k = mono_object_class (arg);
+ MonoClass *k;
+ if (!arg) {
+ *p++ = 0xFF;
+ break;
+ }
+ k = mono_object_class (arg);
if (!mono_object_isinst (arg, mono_defaults.monotype_class) &&
(strcmp (k->name, "TypeBuilder") || strcmp (k->name_space, "System.Reflection.Emit")))
g_error ("only types allowed, not %s.%s", k->name_space, k->name);
g_free (str);
break;
}
+ case MONO_TYPE_SZARRAY: {
+ int len, i;
+ MonoClass *eclass;
+
+ if (!arg) {
+ *p++ = 0xff; *p++ = 0xff; *p++ = 0xff; *p++ = 0xff;
+ break;
+ }
+ len = mono_array_length ((MonoArray*)arg);
+ *p++ = len & 0xff;
+ *p++ = (len >> 8) & 0xff;
+ *p++ = (len >> 16) & 0xff;
+ *p++ = (len >> 24) & 0xff;
+ *retp = p;
+ *retbuffer = buffer;
+ eclass = mono_class_from_mono_type (type)->element_class;
+ for (i = 0; i < len; ++i) {
+ encode_cattr_value (buffer, p, &buffer, &p, buflen, &eclass->byval_arg, mono_array_get ((MonoArray*)arg, MonoObject*, i));
+ }
+ break;
+ }
/* it may be a boxed value or a Type */
case MONO_TYPE_OBJECT: {
MonoClass *klass = mono_object_class (arg);
goto handle_type;
} else if (klass->enumtype) {
*p++ = 0x55;
+ } else if (klass == mono_defaults.string_class) {
+ simple_type = MONO_TYPE_STRING;
+ *p++ = 0x0E;
+ goto handle_enum;
} else if (klass->byval_arg.type >= MONO_TYPE_BOOLEAN && klass->byval_arg.type <= MONO_TYPE_R8) {
*p++ = simple_type = klass->byval_arg.type;
goto handle_enum;
} else {
sig = ((MonoReflectionMethod*)ctor)->method->signature;
}
+ g_assert (mono_array_length (ctorArgs) == sig->param_count);
buflen = 256;
p = buffer = g_malloc (buflen);
/* write the prolog */
*p++ = 1;
*p++ = 0;
for (i = 0; i < sig->param_count; ++i) {
- if (sig->params[i]->type==MONO_TYPE_SZARRAY)
- {
- guint32 alen=mono_array_length(ctorArgs) - i;
- guint32 j;
- if ((p-buffer) + 10 >= buflen) {
- char *newbuf;
- buflen *= 2;
- newbuf = g_realloc (buffer, buflen);
- p = newbuf + (p-buffer);
- buffer = newbuf;
- }
- *p++=alen&0xff;
- *p++=(alen>>8)&0xff;
- *p++=(alen>>16)&0xff;
- *p++=(alen>>24)&0xff;
- for (j=0;j<alen;j++)
- {
- arg=(MonoObject*)mono_array_get(ctorArgs,gpointer,i+j);
- encode_cattr_value(buffer,p,&buffer,&p,&buflen,sig->params[i]->data.type,arg);
- }
- }
- else
- {
- arg = (MonoObject*)mono_array_get (ctorArgs, gpointer, i);
- encode_cattr_value (buffer, p, &buffer, &p, &buflen, sig->params [i], arg);
- }
+ arg = mono_array_get (ctorArgs, MonoObject*, i);
+ encode_cattr_value (buffer, p, &buffer, &p, &buflen, sig->params [i], arg);
}
i = 0;
if (properties)
prop = mono_array_get (properties, gpointer, i);
get_prop_name_and_type (prop, &pname, &ptype);
*p++ = 0x54; /* PROPERTY signature */
- mono_metadata_encode_value (ptype->type, p, &p);
+ if (ptype->type == MONO_TYPE_VALUETYPE && ptype->data.klass->enumtype) {
+ char *str = type_get_qualified_name (ptype, NULL);
+ int slen = strlen (str);
+ if ((p-buffer) + 10 + slen >= buflen) {
+ char *newbuf;
+ buflen *= 2;
+ buflen += slen;
+ newbuf = g_realloc (buffer, buflen);
+ p = newbuf + (p-buffer);
+ buffer = newbuf;
+ }
+ *p++ = 0x55;
+ /*
+ * This seems to be optional...
+ * *p++ = 0x80;
+ */
+ mono_metadata_encode_value (slen, p, &p);
+ memcpy (p, str, slen);
+ p += slen;
+ g_free (str);
+ } else {
+ mono_metadata_encode_value (ptype->type, p, &p);
+ }
len = strlen (pname);
mono_metadata_encode_value (len, p, &p);
memcpy (p, pname, len);
field = mono_array_get (fields, gpointer, i);
get_field_name_and_type (field, &fname, &ftype);
*p++ = 0x53; /* FIELD signature */
- mono_metadata_encode_value (ftype->type, p, &p);
+ if (ftype->type == MONO_TYPE_VALUETYPE && ftype->data.klass->enumtype) {
+ char *str = type_get_qualified_name (ftype, NULL);
+ int slen = strlen (str);
+ if ((p-buffer) + 10 + slen >= buflen) {
+ char *newbuf;
+ buflen *= 2;
+ buflen += slen;
+ newbuf = g_realloc (buffer, buflen);
+ p = newbuf + (p-buffer);
+ buffer = newbuf;
+ }
+ *p++ = 0x55;
+ /*
+ * This seems to be optional...
+ * *p++ = 0x80;
+ */
+ mono_metadata_encode_value (slen, p, &p);
+ memcpy (p, str, slen);
+ p += slen;
+ g_free (str);
+ } else {
+ mono_metadata_encode_value (ftype->type, p, &p);
+ }
len = strlen (fname);
mono_metadata_encode_value (len, p, &p);
memcpy (p, fname, len);
tb->type.type = &klass->byval_arg;
+ if (tb->nesting_type) {
+ g_assert (tb->nesting_type->type);
+ klass->nested_in = mono_class_from_mono_type (tb->nesting_type->type);
+ }
+
/*g_print ("setup %s as %s (%p)\n", klass->name, ((MonoObject*)tb)->vtable->klass->name, tb);*/
}
MonoReflectionTypeBuilder *tb = klass->reflection_info;
MonoReflectionFieldBuilder *fb;
MonoClassField *field;
+ const char *p, *p2;
int i;
+ guint32 len, idx;
klass->field.count = tb->fields? mono_array_length (tb->fields): 0;
klass->field.first = 0;
field->parent = klass;
fb->handle = field;
mono_save_custom_attrs (klass->image, field, fb->cattrs);
+
+ if (fb->def_value) {
+ field->type->attrs |= FIELD_ATTRIBUTE_HAS_DEFAULT;
+ MonoDynamicAssembly *assembly = klass->image->assembly->dynamic;
+ field->def_value = g_new0 (MonoConstant, 1);
+ idx = encode_constant (assembly, fb->def_value, &field->def_value->type);
+ /* Copy the data from the blob since it might get realloc-ed */
+ p = assembly->blob.data + idx;
+ len = mono_metadata_decode_blob_size (p, &p2);
+ len += p2 - p;
+ field->def_value->value = g_malloc (len);
+ memcpy (field->def_value->value, p, len);
+ }
}
mono_class_layout_fields (klass);
}
klass->flags = tb->attrs;
klass->element_class = klass;
+ if (!((MonoDynamicAssembly*)klass->image->assembly->dynamic)->run)
+ /* No need to fully construct the type */
+ return mono_type_get_object (mono_object_domain (tb), &klass->byval_arg);
+
/* enums are done right away */
if (!klass->enumtype)
ensure_runtime_vtable (klass);
klass->min_align = 1;
}
- if (tb->nesting_type) {
- g_assert (tb->nesting_type->type);
- klass->nested_in = mono_class_from_mono_type (tb->nesting_type->type);
- }
-
/* FIXME: handle packing_size and instance_size */
typebuilder_setup_fields (klass);
+