X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;f=mono%2Fmetadata%2Freflection.c;h=d7c958f1bd2442d782558548316f59bfe94b7882;hb=0f128ab73f1d67e6847eed513038b338fe780099;hp=16991322821f41d477b41f764e611e3bbdd0bb95;hpb=742a5862d44940e75b3de4853e547066407478d3;p=mono.git diff --git a/mono/metadata/reflection.c b/mono/metadata/reflection.c index 16991322821..d7c958f1bd2 100644 --- a/mono/metadata/reflection.c +++ b/mono/metadata/reflection.c @@ -1,4 +1,3 @@ - /* * reflection.c: Routines for creating an image at runtime. * @@ -138,6 +137,9 @@ static guint32 encode_marshal_blob (MonoDynamicImage *assembly, MonoReflectionMa static char* type_get_qualified_name (MonoType *type, MonoAssembly *ass); static void ensure_runtime_vtable (MonoClass *klass); static gpointer resolve_object (MonoImage *image, MonoObject *obj); +static void encode_type (MonoDynamicImage *assembly, MonoType *type, char *p, char **endbuf); +static guint32 type_get_signature_size (MonoType *type); + static void alloc_table (MonoDynamicTable *table, guint nrows) @@ -396,6 +398,25 @@ my_mono_class_from_mono_type (MonoType *type) { } } +static void +encode_generic_inst (MonoDynamicImage *assembly, MonoGenericInst *ginst, char *p, char **endbuf) +{ + int i; + + if (!ginst) { + g_assert_not_reached (); + return; + } + + mono_metadata_encode_value (MONO_TYPE_GENERICINST, p, &p); + encode_type (assembly, ginst->generic_type, p, &p); + mono_metadata_encode_value (ginst->type_argc, p, &p); + for (i = 0; i < ginst->type_argc; ++i) + encode_type (assembly, ginst->type_argv [i], p, &p); + + *endbuf = p; +} + static void encode_type (MonoDynamicImage *assembly, MonoType *type, char *p, char **endbuf) { @@ -457,16 +478,9 @@ encode_type (MonoDynamicImage *assembly, MonoType *type, char *p, char **endbuf) mono_metadata_encode_value (0, p, &p); /* FIXME: set to 0 for now */ mono_metadata_encode_value (0, p, &p); break; - case MONO_TYPE_GENERICINST: { - int i; - mono_metadata_encode_value (type->type, p, &p); - encode_type (assembly, type->data.generic_inst->generic_type, p, &p); - mono_metadata_encode_value (type->data.generic_inst->type_argc, p, &p); - for (i = 0; i < type->data.generic_inst->type_argc; ++i) { - encode_type (assembly, type->data.generic_inst->type_argv [i], p, &p); - } + case MONO_TYPE_GENERICINST: + encode_generic_inst (assembly, type->data.generic_inst, p, &p); break; - } case MONO_TYPE_VAR: case MONO_TYPE_MVAR: mono_metadata_encode_value (type->type, p, &p); @@ -519,6 +533,95 @@ encode_custom_modifiers (MonoDynamicImage *assembly, MonoArray *modreq, MonoArra *endbuf = p; } +static guint32 +generic_inst_get_signature_size (MonoGenericInst *ginst) +{ + guint32 size = 0; + int i; + + if (!ginst) { + g_assert_not_reached (); + } + + size += 1 + type_get_signature_size (ginst->generic_type); + size += 4; + for (i = 0; i < ginst->type_argc; ++i) + size += type_get_signature_size (ginst->type_argv [i]); + + return size; +} + +static guint32 +type_get_signature_size (MonoType *type) +{ + guint32 size = 0; + + if (!type) { + g_assert_not_reached (); + } + + if (type->byref) + size++; + + switch (type->type){ + case MONO_TYPE_VOID: + case MONO_TYPE_BOOLEAN: + case MONO_TYPE_CHAR: + case MONO_TYPE_I1: + case MONO_TYPE_U1: + case MONO_TYPE_I2: + case MONO_TYPE_U2: + case MONO_TYPE_I4: + case MONO_TYPE_U4: + case MONO_TYPE_I8: + case MONO_TYPE_U8: + case MONO_TYPE_R4: + case MONO_TYPE_R8: + case MONO_TYPE_I: + case MONO_TYPE_U: + case MONO_TYPE_STRING: + case MONO_TYPE_OBJECT: + case MONO_TYPE_TYPEDBYREF: + return size + 1; + case MONO_TYPE_PTR: + return size + 1 + type_get_signature_size (type->data.type); + case MONO_TYPE_SZARRAY: + return size + 1 + type_get_signature_size (&type->data.klass->byval_arg); + + case MONO_TYPE_VALUETYPE: + case MONO_TYPE_CLASS: + return size + 5; + + case MONO_TYPE_ARRAY: + return size + 7 + type_get_signature_size (&type->data.array->eklass->byval_arg); + case MONO_TYPE_GENERICINST: + return size + generic_inst_get_signature_size (type->data.generic_inst); + case MONO_TYPE_VAR: + case MONO_TYPE_MVAR: + return size + 5; + + default: + g_error ("need to encode type %x", type->type); + return size; + } +} + +static guint32 +method_get_signature_size (MonoMethodSignature *sig) +{ + guint32 size; + int i; + + size = type_get_signature_size (sig->ret); + for (i = 0; i < sig->param_count; i++) + size += type_get_signature_size (sig->params [i]); + + if (sig->generic_param_count) + size += 4; + + return size; +} + static guint32 method_encode_signature (MonoDynamicImage *assembly, MonoMethodSignature *sig) { @@ -526,7 +629,7 @@ method_encode_signature (MonoDynamicImage *assembly, MonoMethodSignature *sig) char *p; int i; guint32 nparams = sig->param_count; - guint32 size = 10 + nparams * 10; + guint32 size = 11 + method_get_signature_size (sig); guint32 idx; char blob_size [6]; char *b = blob_size; @@ -635,6 +738,10 @@ encode_locals (MonoDynamicImage *assembly, MonoReflectionILGen *ilgen) mono_metadata_encode_value (nl, p, &p); for (i = 0; i < nl; ++i) { MonoReflectionLocalBuilder *lb = mono_array_get (ilgen->locals, MonoReflectionLocalBuilder*, i); + + if (lb->is_pinned) + mono_metadata_encode_value (MONO_TYPE_PINNED, p, &p); + encode_reflection_type (assembly, lb->type, p, &p); } g_assert (p - buf < size); @@ -747,8 +854,14 @@ method_encode_code (MonoDynamicImage *assembly, ReflectionMethodBuilder *mb) 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")); + if (code == NULL){ + char *name = mono_string_to_utf8 (mb->name); + char *str = g_strdup_printf ("Method %s does not have any IL associated", name); + MonoException *exception = mono_get_exception_argument (NULL, "a method does not have any IL associated"); + g_free (str); + g_free (name); + mono_raise_exception (exception); + } code_size = mono_array_length (code); max_stack = 8; /* we probably need to run a verifier on the code... */ @@ -1269,11 +1382,11 @@ type_get_fully_qualified_name (MonoType *type) { klass = my_mono_class_from_mono_type (type); ta = klass->image->assembly; - /* missing public key */ - result = g_strdup_printf ("%s, %s, Version=%d.%d.%d.%d, Culture=%s", + result = g_strdup_printf ("%s, %s, Version=%d.%d.%d.%d, Culture=%s, PublicKeyToken=%s", name, ta->aname.name, ta->aname.major, ta->aname.minor, ta->aname.build, ta->aname.revision, - ta->aname.culture && *ta->aname.culture? ta->aname.culture: "neutral"); + ta->aname.culture && *ta->aname.culture? ta->aname.culture: "neutral", + ta->aname.public_tok_value ? ta->aname.public_tok_value : "null"); g_free (name); return result; } @@ -1438,7 +1551,16 @@ encode_marshal_blob (MonoDynamicImage *assembly, MonoReflectionMarshal *minfo) { mono_metadata_encode_value (minfo->type, p, &p); mono_metadata_encode_value (minfo->count, p, &p); break; - /* FIXME: handle ARRAY and other unmanaged types that need extra info */ + case MONO_NATIVE_LPARRAY: + mono_metadata_encode_value (minfo->type, p, &p); + if (minfo->eltype || (minfo->count > 0)) { + mono_metadata_encode_value (minfo->eltype, p, &p); + if (minfo->count > 0) { + mono_metadata_encode_value (0, p, &p); + mono_metadata_encode_value (minfo->count, p, &p); + } + } + break; case MONO_NATIVE_CUSTOM: mono_metadata_encode_value (minfo->type, p, &p); if (minfo->guid) { @@ -1550,7 +1672,7 @@ mono_image_get_field_info (MonoReflectionFieldBuilder *fb, MonoDynamicImage *ass values [MONO_CONSTANT_TYPE] = field_type; values [MONO_CONSTANT_PADDING] = 0; } - if (fb->rva_data) { + if (fb->attrs & FIELD_ATTRIBUTE_HAS_FIELD_RVA) { guint32 rva_idx; table = &assembly->tables [MONO_TABLE_FIELDRVA]; table->rows ++; @@ -1560,7 +1682,10 @@ mono_image_get_field_info (MonoReflectionFieldBuilder *fb, MonoDynamicImage *ass /* * We store it in the code section because it's simpler for now. */ - rva_idx = mono_image_add_stream_data (&assembly->code, mono_array_addr (fb->rva_data, char, 0), mono_array_length (fb->rva_data)); + if (fb->rva_data) + rva_idx = mono_image_add_stream_data (&assembly->code, mono_array_addr (fb->rva_data, char, 0), mono_array_length (fb->rva_data)); + else + rva_idx = mono_image_add_stream_zero (&assembly->code, mono_class_value_size (fb->handle->parent, NULL)); values [MONO_FIELD_RVA_RVA] = rva_idx + assembly->text_rva; } if (fb->marshal_info) { @@ -1723,6 +1848,75 @@ mono_image_get_event_info (MonoReflectionEventBuilder *eb, MonoDynamicImage *ass } } +static void +encode_new_constraint (MonoDynamicImage *assembly, guint32 owner) +{ + static MonoClass *NewConstraintAttr; + static MonoMethod *NewConstraintAttr_ctor; + MonoDynamicTable *table; + guint32 *values; + guint32 token, type; + char blob_size [4] = { 0x01, 0x00, 0x00, 0x00 }; + char *buf, *p; + + if (!NewConstraintAttr) + NewConstraintAttr = mono_class_from_name ( + mono_defaults.corlib, "System.Runtime.CompilerServices", + "NewConstraintAttribute"); + g_assert (NewConstraintAttr); + + if (!NewConstraintAttr_ctor) { + int i; + + for (i = 0; i < NewConstraintAttr->method.count; i++) { + MonoMethod *m = NewConstraintAttr->methods [i]; + + if (strcmp (m->name, ".ctor")) + continue; + + NewConstraintAttr_ctor = m; + break; + } + + g_assert (NewConstraintAttr_ctor); + } + + table = &assembly->tables [MONO_TABLE_CUSTOMATTRIBUTE]; + table->rows += 1; + alloc_table (table, table->rows); + + values = table->values + table->next_idx * MONO_CUSTOM_ATTR_SIZE; + owner <<= CUSTOM_ATTR_BITS; + owner |= CUSTOM_ATTR_GENERICPAR; + values [MONO_CUSTOM_ATTR_PARENT] = owner; + + token = mono_image_get_methodref_token (assembly, NewConstraintAttr_ctor); + + type = mono_metadata_token_index (token); + type <<= CUSTOM_ATTR_TYPE_BITS; + switch (mono_metadata_token_table (token)) { + case MONO_TABLE_METHOD: + type |= CUSTOM_ATTR_TYPE_METHODDEF; + break; + case MONO_TABLE_MEMBERREF: + type |= CUSTOM_ATTR_TYPE_MEMBERREF; + break; + default: + g_warning ("got wrong token in custom attr"); + return; + } + values [MONO_CUSTOM_ATTR_TYPE] = type; + + buf = p = g_malloc (1); + mono_metadata_encode_value (4, p, &p); + g_assert (p-buf == 1); + + values [MONO_CUSTOM_ATTR_VALUE] = add_to_blob_cached (assembly, buf, 1, blob_size, 4); + + values += MONO_CUSTOM_ATTR_SIZE; + ++table->next_idx; +} + static void encode_constraints (MonoReflectionGenericParam *gparam, guint32 owner, MonoDynamicImage *assembly) { @@ -1732,19 +1926,36 @@ encode_constraints (MonoReflectionGenericParam *gparam, guint32 owner, MonoDynam guint32 table_idx; table = &assembly->tables [MONO_TABLE_GENERICPARAMCONSTRAINT]; - num_constraints = gparam ? mono_array_length (gparam->constraints) : 0; + num_constraints = gparam->iface_constraints ? + mono_array_length (gparam->iface_constraints) : 0; table->rows += num_constraints; + if (gparam->base_type) + table->rows++; alloc_table (table, table->rows); + if (gparam->base_type) { + table_idx = table->next_idx ++; + values = table->values + table_idx * MONO_GENPARCONSTRAINT_SIZE; + + values [MONO_GENPARCONSTRAINT_GENERICPAR] = owner; + values [MONO_GENPARCONSTRAINT_CONSTRAINT] = mono_image_typedef_or_ref ( + assembly, gparam->base_type->type); + } + for (i = 0; i < num_constraints; i++) { - MonoReflectionType *constraint = mono_array_get (gparam->constraints, gpointer, i); + MonoReflectionType *constraint = mono_array_get ( + gparam->iface_constraints, gpointer, i); table_idx = table->next_idx ++; values = table->values + table_idx * MONO_GENPARCONSTRAINT_SIZE; values [MONO_GENPARCONSTRAINT_GENERICPAR] = owner; - values [MONO_GENPARCONSTRAINT_CONSTRAINT] = mono_image_typedef_or_ref (assembly, constraint->type); + values [MONO_GENPARCONSTRAINT_CONSTRAINT] = mono_image_typedef_or_ref ( + assembly, constraint->type); } + + if (gparam->has_ctor_constraint) + encode_new_constraint (assembly, owner); } static void @@ -1762,14 +1973,17 @@ mono_image_get_generic_param_info (MonoReflectionGenericParam *gparam, guint32 o param = gparam->type.type->data.generic_param; values [MONO_GENERICPARAM_OWNER] = owner; - values [MONO_GENERICPARAM_FLAGS] = param->flags; + if (gparam->has_value_type) + values [MONO_GENERICPARAM_FLAGS] = 0x18; + else if (gparam->has_reference_type) + values [MONO_GENERICPARAM_FLAGS] = 0x04; + else + values [MONO_GENERICPARAM_FLAGS] = 0x00; values [MONO_GENERICPARAM_NUMBER] = param->num; values [MONO_GENERICPARAM_NAME] = string_heap_insert (&assembly->sheap, param->name); values [MONO_GENERICPARAM_KIND] = 0; - values [MONO_GENERICPARAM_DEPRECATED_CONSTRAINT] = 0; - if (gparam->constraints) - encode_constraints (gparam, table_idx, assembly); + encode_constraints (gparam, table_idx, assembly); } static guint32 @@ -1814,10 +2028,7 @@ resolution_scope_from_image (MonoDynamicImage *assembly, MonoImage *image) table->rows ++; alloc_table (table, table->rows); values = table->values + token * MONO_ASSEMBLYREF_SIZE; - if (strcmp ("corlib", image->assembly_name) == 0) - values [MONO_ASSEMBLYREF_NAME] = string_heap_insert (&assembly->sheap, "mscorlib"); - else - values [MONO_ASSEMBLYREF_NAME] = string_heap_insert (&assembly->sheap, image->assembly_name); + values [MONO_ASSEMBLYREF_NAME] = string_heap_insert (&assembly->sheap, image->assembly_name); values [MONO_ASSEMBLYREF_MAJOR_VERSION] = cols [MONO_ASSEMBLY_MAJOR_VERSION]; values [MONO_ASSEMBLYREF_MINOR_VERSION] = cols [MONO_ASSEMBLY_MINOR_VERSION]; values [MONO_ASSEMBLYREF_BUILD_NUMBER] = cols [MONO_ASSEMBLY_BUILD_NUMBER]; @@ -1826,6 +2037,11 @@ resolution_scope_from_image (MonoDynamicImage *assembly, MonoImage *image) values [MONO_ASSEMBLYREF_CULTURE] = 0; values [MONO_ASSEMBLYREF_HASH_VALUE] = 0; + if (strcmp ("", image->assembly->aname.culture)) { + values [MONO_ASSEMBLYREF_CULTURE] = string_heap_insert (&assembly->sheap, + image->assembly->aname.culture); + } + if ((pubkey = mono_image_get_public_key (image, &publen))) { guchar pubtoken [9]; pubtoken [0] = 8; @@ -1840,8 +2056,7 @@ resolution_scope_from_image (MonoDynamicImage *assembly, MonoImage *image) * recognized by ms, yuck! * FIXME: need to add more assembly names, as needed. */ - if (strcmp (image->assembly_name, "corlib") == 0 || - strcmp (image->assembly_name, "mscorlib") == 0 || + if (strcmp (image->assembly_name, "mscorlib") == 0 || strcmp (image->assembly_name, "System") == 0 || strcmp (image->assembly_name, "System.Runtime.Remoting") == 0 || strcmp (image->assembly_name, "System.Xml") == 0 || @@ -1913,7 +2128,7 @@ create_typespec (MonoDynamicImage *assembly, MonoType *type) MonoClass *k = mono_class_from_mono_type (type); if (!k || !k->generic_inst) return 0; - encode_type (assembly, k->generic_inst, p, &p); + encode_generic_inst (assembly, k->generic_inst, p, &p); break; } default: @@ -2092,55 +2307,29 @@ mono_image_get_ctorbuilder_token (MonoDynamicImage *assembly, MonoReflectionCtor } static guint32 -mono_image_get_fieldref_token (MonoDynamicImage *assembly, MonoClassField *field, MonoClass *klass) +mono_image_get_fieldref_token (MonoDynamicImage *assembly, MonoReflectionField *f) { + MonoType *type; guint32 token; - - token = GPOINTER_TO_UINT (g_hash_table_lookup (assembly->handleref, field)); - if (token) - return token; - field->parent = klass; - token = mono_image_get_memberref_token (assembly, &klass->byval_arg, - field->name, fieldref_encode_signature (assembly, field->type)); - g_hash_table_insert (assembly->handleref, field, GUINT_TO_POINTER(token)); - return token; -} - -static guint32 -field_encode_inflated_field (MonoDynamicImage *assembly, MonoReflectionInflatedField *field) -{ - guint32 sig, token; - MonoClass *klass; - const gchar *name; - - klass = field->rfield.klass; - name = field->rfield.field->name; - sig = fieldref_encode_signature (assembly, field->declaring->type); - token = mono_image_get_memberref_token (assembly, &klass->byval_arg, name, sig); - - return token; -} -static guint32 -mono_image_get_inflated_field_token (MonoDynamicImage *assembly, MonoReflectionInflatedField *field) -{ - guint32 token; - - token = GPOINTER_TO_UINT (g_hash_table_lookup (assembly->handleref, field->rfield.field)); + token = GPOINTER_TO_UINT (g_hash_table_lookup (assembly->handleref, f)); if (token) return token; - token = field_encode_inflated_field (assembly, field); - g_hash_table_insert (assembly->handleref, field, GUINT_TO_POINTER(token)); + g_assert (f->field->parent); + type = f->field->generic_type ? f->field->generic_type : f->field->type; + token = mono_image_get_memberref_token (assembly, &f->klass->byval_arg, + f->field->name, fieldref_encode_signature (assembly, type)); + g_hash_table_insert (assembly->handleref, f, GUINT_TO_POINTER(token)); return token; } static guint32 -encode_generic_method_sig (MonoDynamicImage *assembly, MonoGenericInst *ginst) +encode_generic_method_sig (MonoDynamicImage *assembly, MonoGenericMethod *gmethod) { char *buf; char *p; int i; - guint32 nparams = ginst->type_argc; + guint32 nparams = gmethod->mtype_argc; guint32 size = 10 + nparams * 10; guint32 idx; char blob_size [6]; @@ -2157,7 +2346,7 @@ encode_generic_method_sig (MonoDynamicImage *assembly, MonoGenericInst *ginst) mono_metadata_encode_value (nparams, p, &p); for (i = 0; i < nparams; i++) - encode_type (assembly, ginst->type_argv [i], p, &p); + encode_type (assembly, gmethod->mtype_argv [i], p, &p); /* store length */ g_assert (p - buf < size); @@ -2168,27 +2357,26 @@ encode_generic_method_sig (MonoDynamicImage *assembly, MonoGenericInst *ginst) } static guint32 -method_encode_methodspec (MonoDynamicImage *assembly, MonoGenericInst *ginst) +method_encode_methodspec (MonoDynamicImage *assembly, MonoMethod *method) { MonoDynamicTable *table; guint32 *values; guint32 token, mtoken = 0, sig; + MonoMethodInflated *imethod; + MonoMethod *declaring; table = &assembly->tables [MONO_TABLE_METHODSPEC]; - g_assert (ginst); - if (ginst->generic_method) { - MonoMethod *gm = ginst->generic_method; - MonoClass *k = ginst->klass ? ginst->klass : gm->klass; + g_assert (method->signature->is_inflated); + imethod = (MonoMethodInflated *) method; + declaring = imethod->declaring; - sig = method_encode_signature (assembly, gm->signature); - mtoken = mono_image_get_memberref_token (assembly, &k->byval_arg, gm->name, sig); + sig = method_encode_signature (assembly, declaring->signature); + mtoken = mono_image_get_memberref_token (assembly, &method->klass->byval_arg, + declaring->name, sig); - if (!ginst->generic_method->signature->generic_param_count) - return mtoken; - } - else - g_assert_not_reached (); + if (!declaring->signature->generic_param_count) + return mtoken; switch (mono_metadata_token_table (mtoken)) { case MONO_TABLE_MEMBERREF: @@ -2201,7 +2389,7 @@ method_encode_methodspec (MonoDynamicImage *assembly, MonoGenericInst *ginst) g_assert_not_reached (); } - sig = encode_generic_method_sig (assembly, ginst); + sig = encode_generic_method_sig (assembly, imethod->context->gmethod); if (assembly->save) { alloc_table (table, table->rows + 1); @@ -2217,15 +2405,28 @@ method_encode_methodspec (MonoDynamicImage *assembly, MonoGenericInst *ginst) } static guint32 -mono_image_get_methodspec_token (MonoDynamicImage *assembly, MonoMethod *method, MonoGenericInst *ginst) +mono_image_get_methodspec_token (MonoDynamicImage *assembly, MonoMethod *m) { + MonoMethodInflated *imethod; guint32 token; - token = GPOINTER_TO_UINT (g_hash_table_lookup (assembly->handleref, method)); + token = GPOINTER_TO_UINT (g_hash_table_lookup (assembly->handleref, m)); if (token) return token; - token = method_encode_methodspec (assembly, ginst); - g_hash_table_insert (assembly->handleref, method, GUINT_TO_POINTER(token)); + + g_assert (m->signature->is_inflated); + imethod = (MonoMethodInflated *) m; + + if (imethod->declaring->signature->generic_param_count) + token = method_encode_methodspec (assembly, m); + else { + guint32 sig = method_encode_signature ( + assembly, imethod->declaring->signature); + token = mono_image_get_memberref_token ( + assembly, &m->klass->byval_arg, m->name, sig); + } + + g_hash_table_insert (assembly->handleref, m, GUINT_TO_POINTER(token)); return token; } @@ -2242,6 +2443,16 @@ create_generic_typespec (MonoDynamicImage *assembly, MonoReflectionTypeBuilder * char *b = blob_size; int count, i; + /* + * We're creating a TypeSpec for the TypeBuilder of a generic type declaration, + * ie. what we'd normally use as the generic type in a TypeSpec signature. + * Because of this, we must not insert it into the `typeref' hash table. + */ + + token = GPOINTER_TO_UINT (g_hash_table_lookup (assembly->typespec, tb->type.type)); + if (token) + return token; + g_assert (tb->generic_params); klass = mono_class_from_mono_type (tb->type.type); @@ -2269,7 +2480,7 @@ create_generic_typespec (MonoDynamicImage *assembly, MonoReflectionTypeBuilder * } token = TYPEDEFORREF_TYPESPEC | (table->next_idx << TYPEDEFORREF_BITS); - g_hash_table_insert (assembly->typeref, tb->type.type, GUINT_TO_POINTER(token)); + g_hash_table_insert (assembly->typespec, tb->type.type, GUINT_TO_POINTER(token)); table->next_idx ++; return token; } @@ -2283,6 +2494,10 @@ mono_image_get_generic_field_token (MonoDynamicImage *assembly, MonoReflectionFi guint32 token, pclass, parent, sig; gchar *name; + token = GPOINTER_TO_UINT (g_hash_table_lookup (assembly->handleref, fb)); + if (token) + return token; + klass = mono_class_from_mono_type (fb->typeb->type); name = mono_string_to_utf8 (fb->name); @@ -2306,7 +2521,7 @@ mono_image_get_generic_field_token (MonoDynamicImage *assembly, MonoReflectionFi token = MONO_TOKEN_MEMBER_REF | table->next_idx; table->next_idx ++; - + g_hash_table_insert (assembly->handleref, fb, GUINT_TO_POINTER(token)); return token; } @@ -2584,6 +2799,11 @@ mono_image_get_type_info (MonoDomain *domain, MonoReflectionTypeBuilder *tb, Mon mono_image_get_property_info ( mono_array_get (tb->properties, MonoReflectionPropertyBuilder*, i), assembly); } + + mono_image_add_decl_security (assembly, + mono_metadata_make_token (MONO_TABLE_TYPEDEF, tb->table_idx), + tb->permissions); + if (tb->subtypes) { MonoDynamicTable *ntable; @@ -3020,8 +3240,17 @@ build_compressed_metadata (MonoDynamicImage *assembly) int32val = (guint32*)p; *int32val = GUINT32_TO_LE (0); /* reserved */ p += 4; - *p++ = 1; /* version */ - *p++ = 0; + + if ((assembly->tables [MONO_TABLE_GENERICPARAM].rows > 0) || + (assembly->tables [MONO_TABLE_METHODSPEC].rows > 0) || + (assembly->tables [MONO_TABLE_GENERICPARAMCONSTRAINT].rows > 0)) { + *p++ = 1; /* version */ + *p++ = 1; + } else { + *p++ = 1; /* version */ + *p++ = 0; + } + if (meta->idx_string_wide) *p |= 0x01; if (meta->idx_guid_wide) @@ -3166,12 +3395,12 @@ fixup_method (MonoReflectionILGen *ilgen, gpointer value, MonoDynamicImage *asse MonoMethod *m = ((MonoReflectionMethod*)iltoken->member)->method; g_assert (m->klass->generic_inst); continue; - } else if (!strcmp (iltoken->member->vtable->klass->name, "MonoInflatedMethod") || - !strcmp (iltoken->member->vtable->klass->name, "MonoInflatedCtor") || - !strcmp (iltoken->member->vtable->klass->name, "MonoInflatedField")) { - continue; } else if (!strcmp (iltoken->member->vtable->klass->name, "FieldBuilder")) { continue; + } else if (!strcmp (iltoken->member->vtable->klass->name, "MonoField")) { + MonoClassField *f = ((MonoReflectionField*)iltoken->member)->field; + g_assert (f->generic_type); + continue; } else { g_assert_not_reached (); } @@ -3181,9 +3410,6 @@ fixup_method (MonoReflectionILGen *ilgen, gpointer value, MonoDynamicImage *asse MonoMethod *m = ((MonoReflectionMethod*)iltoken->member)->method; g_assert (m->signature->generic_param_count); continue; - } else if (!strcmp (iltoken->member->vtable->klass->name, "MonoInflatedMethod") || - !strcmp (iltoken->member->vtable->klass->name, "MonoInflatedCtor")) { - continue; } else { g_assert_not_reached (); } @@ -3647,7 +3873,12 @@ mono_image_create_token (MonoDynamicImage *assembly, MonoObject *obj) token = tb->table_idx | MONO_TOKEN_TYPE_DEF; } else if (strcmp (klass->name, "MonoType") == 0 || - strcmp (klass->name, "MonoGenericParam") == 0) { + strcmp (klass->name, "GenericTypeParameterBuilder") == 0) { + MonoReflectionType *tb = (MonoReflectionType *)obj; + token = mono_metadata_token_from_dor ( + mono_image_typedef_or_ref (assembly, tb->type)); + } + else if (strcmp (klass->name, "MonoGenericInst") == 0) { MonoReflectionType *tb = (MonoReflectionType *)obj; token = mono_metadata_token_from_dor ( mono_image_typedef_or_ref (assembly, tb->type)); @@ -3655,9 +3886,10 @@ mono_image_create_token (MonoDynamicImage *assembly, MonoObject *obj) else if (strcmp (klass->name, "MonoCMethod") == 0 || strcmp (klass->name, "MonoMethod") == 0) { MonoReflectionMethod *m = (MonoReflectionMethod *)obj; - if (m->method->signature->generic_param_count) { + if (m->method->signature->is_inflated) { + token = mono_image_get_methodspec_token (assembly, m->method); + } else if (m->method->signature->generic_param_count) { g_assert_not_reached (); - token = mono_image_get_methodspec_token (assembly, m->method, NULL); } else if ((m->method->klass->image == &assembly->image) && !m->method->klass->generic_inst) { static guint32 method_table_idx = 0xffffff; @@ -3672,23 +3904,14 @@ mono_image_create_token (MonoDynamicImage *assembly, MonoObject *obj) token = mono_image_get_methodref_token (assembly, m->method); /*g_print ("got token 0x%08x for %s\n", token, m->method->name);*/ } - else if (strcmp (klass->name, "MonoInflatedMethod") == 0 || - strcmp (klass->name, "MonoInflatedCtor") == 0) { - MonoReflectionInflatedMethod *m = (MonoReflectionInflatedMethod *)obj; - token = mono_image_get_methodspec_token (assembly, m->rmethod.method, m->ginst); - } - else if (strcmp (klass->name, "MonoInflatedField") == 0) { - MonoReflectionInflatedField *f = (MonoReflectionInflatedField *)obj; - token = mono_image_get_inflated_field_token (assembly, f); - } else if (strcmp (klass->name, "MonoField") == 0) { MonoReflectionField *f = (MonoReflectionField *)obj; - if (f->klass->image == &assembly->image) { + if ((f->klass->image == &assembly->image) && !f->field->generic_type) { static guint32 field_table_idx = 0xffffff; field_table_idx --; token = MONO_TOKEN_FIELD_DEF | field_table_idx; } else - token = mono_image_get_fieldref_token (assembly, f->field, f->klass); + token = mono_image_get_fieldref_token (assembly, f); /*g_print ("got token 0x%08x for %s\n", token, f->field->name);*/ } else if (strcmp (klass->name, "MonoArrayMethod") == 0) { @@ -3762,6 +3985,7 @@ create_dynamic_mono_image (MonoDynamicAssembly *assembly, image->method_aux_hash = mono_g_hash_table_new (NULL, NULL); image->handleref = g_hash_table_new (NULL, NULL); image->tokens = mono_g_hash_table_new (NULL, NULL); + image->typespec = g_hash_table_new ((GHashFunc)mono_metadata_type_hash, (GCompareFunc)mono_metadata_type_equal); image->typeref = g_hash_table_new ((GHashFunc)mono_metadata_type_hash, (GCompareFunc)mono_metadata_type_equal); image->blob_cache = mono_g_hash_table_new ((GHashFunc)mono_blob_entry_hash, (GCompareFunc)mono_blob_entry_equal); @@ -4714,6 +4938,36 @@ mymono_metadata_type_hash (MonoType *t1) return hash; } +static MonoReflectionGenericInst* +mono_generic_inst_get_object (MonoDomain *domain, MonoType *geninst) +{ + static MonoClass *System_Reflection_MonoGenericInst; + MonoReflectionGenericInst *res; + MonoGenericInst *ginst; + MonoClass *gklass; + + if (!System_Reflection_MonoGenericInst) { + System_Reflection_MonoGenericInst = mono_class_from_name ( + mono_defaults.corlib, "System.Reflection", "MonoGenericInst"); + g_assert (System_Reflection_MonoGenericInst); + } + + ginst = geninst->data.generic_inst; + gklass = mono_class_from_mono_type (ginst->generic_type); + + mono_class_init (ginst->klass); + + res = (MonoReflectionGenericInst *) mono_object_new (domain, System_Reflection_MonoGenericInst); + + res->type.type = geninst; + if (gklass->wastypebuilder && gklass->reflection_info) + res->generic_type = gklass->reflection_info; + else + res->generic_type = mono_type_get_object (domain, ginst->generic_type); + + return res; +} + /* * mono_type_get_object: * @domain: an app domain @@ -4735,6 +4989,12 @@ mono_type_get_object (MonoDomain *domain, MonoType *type) mono_domain_unlock (domain); return res; } + if ((type->type == MONO_TYPE_GENERICINST) && type->data.generic_inst->is_dynamic) { + res = (MonoReflectionType *)mono_generic_inst_get_object (domain, type); + mono_g_hash_table_insert (domain->type_hash, type, res); + mono_domain_unlock (domain); + return res; + } if (klass->reflection_info && !klass->wastypebuilder) { //g_assert_not_reached (); /* should this be considered an error condition? */ @@ -4922,7 +5182,8 @@ assembly_name_to_aname (MonoAssemblyName *assembly, char *p) { memset (assembly, 0, sizeof (MonoAssemblyName)); assembly->name = p; assembly->culture = ""; - + assembly->public_tok_value = NULL; + while (*p && (isalnum (*p) || *p == '.' || *p == '-' || *p == '_' || *p == '$' || *p == '@')) p++; found_sep = 0; @@ -4935,7 +5196,7 @@ assembly_name_to_aname (MonoAssemblyName *assembly, char *p) { if (!found_sep) return 1; while (*p) { - if (*p == 'V' && strncmp (p, "Version=", 8) == 0) { + if (*p == 'V' && g_ascii_strncasecmp (p, "Version=", 8) == 0) { p += 8; assembly->major = strtoul (p, &s, 10); if (s == p || *s != '.') @@ -4952,10 +5213,11 @@ assembly_name_to_aname (MonoAssemblyName *assembly, char *p) { assembly->revision = strtoul (p, &s, 10); if (s == p) return 1; - } else if (*p == 'C' && strncmp (p, "Culture=", 8) == 0) { + p = s; + } else if (*p == 'C' && g_ascii_strncasecmp (p, "Culture=", 8) == 0) { p += 8; - if (strncmp (p, "neutral", 7) == 0) { - assembly->culture = ""; + if (g_ascii_strncasecmp (p, "neutral", 7) == 0) { + assembly->culture = g_strdup (""); p += 7; } else { assembly->culture = p; @@ -4963,26 +5225,16 @@ assembly_name_to_aname (MonoAssemblyName *assembly, char *p) { p++; } } - } else if (*p == 'P' && strncmp (p, "PublicKeyToken=", 15) == 0) { + } else if (*p == 'P' && g_ascii_strncasecmp (p, "PublicKeyToken=", 15) == 0) { p += 15; - s = p; - while (*s && isxdigit (*s)) { - *s = tolower (*s); - s++; - } - assembly->hash_len = s - p; - if (!(s-p) || ((s-p) & 1)) - return 1; - assembly->hash_value = s = p; - while (*s && isxdigit (*s)) { - int val; - val = *s >= '0' && *s <= '9'? *s - '0': *s - 'a' + 10; - s++; - *p = val << 4; - *p |= *s >= '0' && *s <= '9'? *s - '0': *s - 'a' + 10; - p++; + if (strncmp (p, "null", 4) == 0) { + p += 4; + } else { + assembly->public_tok_value = p; + while (*p && *p != ',') { + p++; + } } - p = s; } else { while (*p && *p != ',') p++; @@ -5225,9 +5477,36 @@ mono_reflection_get_type (MonoImage* image, MonoTypeNameParse *info, gboolean ig assembly = mono_domain_try_type_resolve ( mono_domain_get (), fullName->str, NULL); - if (assembly && (!image || (assembly->assembly->image == image))) - type = mono_reflection_get_type_internal (assembly->assembly->image, - info, ignorecase); + if (assembly && (!image || (assembly->assembly->image == image))) { + + if (assembly->assembly->dynamic) { + /* Enumerate all modules */ + MonoReflectionAssemblyBuilder *abuilder = (MonoReflectionAssemblyBuilder*)assembly; + int i; + + type = NULL; + if (abuilder->modules) { + for (i = 0; i < mono_array_length (abuilder->modules); ++i) { + MonoReflectionModuleBuilder *mb = mono_array_get (abuilder->modules, MonoReflectionModuleBuilder*, i); + type = mono_reflection_get_type_internal (&mb->dynamic_image->image, info, ignorecase); + if (type) + break; + } + } + + if (!type && abuilder->loaded_modules) { + for (i = 0; i < mono_array_length (abuilder->loaded_modules); ++i) { + MonoReflectionModule *mod = mono_array_get (abuilder->loaded_modules, MonoReflectionModule*, i); + type = mono_reflection_get_type_internal (mod->image, info, ignorecase); + if (type) + break; + } + } + } + else + type = mono_reflection_get_type_internal (assembly->assembly->image, + info, ignorecase); + } g_string_free (fullName, TRUE); return type; } @@ -5574,10 +5853,17 @@ create_custom_attr (MonoImage *image, MonoMethod *method, MonoObject *attr; void **params; + mono_class_init (method->klass); + + if (len == 0) { + attr = mono_object_new (mono_domain_get (), method->klass); + mono_runtime_invoke (method, attr, NULL, NULL); + return attr; + } + if (len < 2 || read16 (p) != 0x0001) /* Prolog */ return NULL; - mono_class_init (method->klass); /*g_print ("got attr %s\n", method->klass->name);*/ params = g_new (void*, method->signature->param_count); @@ -5820,10 +6106,15 @@ mono_custom_attrs_from_param (MonoMethod *method, guint32 param) guint32 i, idx, method_index; guint32 param_list, param_last, param_pos, found; MonoImage *image; - - /* FIXME: handle dynamic custom attrs for parameters */ - /*if (dynamic_custom_attrs && (cinfo = g_hash_table_lookup (dynamic_custom_attrs, field))) - return cinfo;*/ + MonoReflectionMethodAux *aux; + + if (method->klass->image->dynamic) { + aux = mono_g_hash_table_lookup (((MonoDynamicImage*)method->klass->image)->method_aux_hash, method); + if (!aux || !aux->param_cattr) + return NULL; + return aux->param_cattr [param]; + } + image = method->klass->image; method_index = find_method_index (method); ca = &image->tables [MONO_TABLE_METHOD]; @@ -5888,13 +6179,13 @@ mono_reflection_get_custom_attrs (MonoObject *obj) cinfo = mono_custom_attrs_from_module (module->image); } else if (strcmp ("MonoProperty", klass->name) == 0) { MonoReflectionProperty *rprop = (MonoReflectionProperty*)obj; - cinfo = mono_custom_attrs_from_property (rprop->klass, rprop->property); + cinfo = mono_custom_attrs_from_property (rprop->property->parent, rprop->property); } else if (strcmp ("MonoEvent", klass->name) == 0) { MonoReflectionEvent *revent = (MonoReflectionEvent*)obj; - cinfo = mono_custom_attrs_from_event (revent->klass, revent->event); + cinfo = mono_custom_attrs_from_event (revent->event->parent, revent->event); } else if (strcmp ("MonoField", klass->name) == 0) { MonoReflectionField *rfield = (MonoReflectionField*)obj; - cinfo = mono_custom_attrs_from_field (rfield->klass, rfield->field); + cinfo = mono_custom_attrs_from_field (rfield->field->parent, rfield->field); } else if ((strcmp ("MonoMethod", klass->name) == 0) || (strcmp ("MonoCMethod", klass->name) == 0)) { MonoReflectionMethod *rmethod = (MonoReflectionMethod*)obj; cinfo = mono_custom_attrs_from_method (rmethod->method); @@ -6427,8 +6718,6 @@ mono_reflection_setup_generic_class (MonoReflectionTypeBuilder *tb) MonoReflectionGenericParam *gparam = mono_array_get (tb->generic_params, gpointer, i); klass->gen_params [i] = *gparam->type.type->data.generic_param; } - - ensure_runtime_vtable (klass); } /* @@ -6507,8 +6796,8 @@ mono_marshal_spec_from_builder (MonoAssembly *assembly, static MonoMethod* reflection_methodbuilder_to_mono_method (MonoClass *klass, - ReflectionMethodBuilder *rmb, - MonoMethodSignature *sig) + ReflectionMethodBuilder *rmb, + MonoMethodSignature *sig) { MonoMethod *m; MonoMethodNormal *pm; @@ -6597,8 +6886,20 @@ reflection_methodbuilder_to_mono_method (MonoClass *klass, header->num_clauses = num_clauses; if (num_clauses) { header->clauses = method_encode_clauses ((MonoDynamicImage*)klass->image, - rmb->ilgen, - num_clauses); + rmb->ilgen, + num_clauses); + } + + if (rmb->generic_params) { + int count = mono_array_length (rmb->generic_params); + header->gen_params = g_new0 (MonoGenericParam, count); + for (i = 0; i < count; i++) { + MonoReflectionGenericParam *gp = + mono_array_get (rmb->generic_params, + MonoReflectionGenericParam*, i); + + header->gen_params [i] = *gp->type.type->data.generic_param; + } } pm->header = header; @@ -6617,15 +6918,20 @@ reflection_methodbuilder_to_mono_method (MonoClass *klass, method_aux = NULL; /* Parameter names */ - if (rmb->parameters) { + if (rmb->pinfo) { if (!method_aux) method_aux = g_new0 (MonoReflectionMethodAux, 1); - method_aux->param_names = g_new0 (char *, m->signature->param_count); - for (i = 0; i < m->signature->param_count; ++i) { + method_aux->param_names = g_new0 (char *, m->signature->param_count + 1); + for (i = 0; i <= m->signature->param_count; ++i) { MonoReflectionParamBuilder *pb; - if ((pb = mono_array_get (rmb->parameters, MonoReflectionParamBuilder*, i))) { + if ((pb = mono_array_get (rmb->pinfo, MonoReflectionParamBuilder*, i))) { if (pb->name) method_aux->param_names [i] = mono_string_to_utf8 (pb->name); + if (pb->cattrs) { + if (!method_aux->param_cattr) + method_aux->param_cattr = g_new0 (MonoCustomAttrInfo*, m->signature->param_count + 1); + method_aux->param_cattr [i] = mono_custom_attrs_from_builders (klass->image, pb->cattrs); + } } } } @@ -6741,116 +7047,40 @@ fieldbuilder_to_mono_class_field (MonoClass *klass, MonoReflectionFieldBuilder* return field; } -static MonoReflectionInflatedMethod* -inflated_method_get_object (MonoDomain *domain, MonoMethod *method, MonoReflectionMethod *declaring, - MonoGenericInst *ginst) -{ - const char *cname; - MonoClass *klass, *refclass; - MonoReflectionInflatedMethod *ret; - - refclass = method->klass; - - CHECK_OBJECT (MonoReflectionInflatedMethod *, method, refclass); - if (*method->name == '.' && (strcmp (method->name, ".ctor") == 0 || strcmp (method->name, ".cctor") == 0)) - cname = "MonoInflatedCtor"; - else - cname = "MonoInflatedMethod"; - klass = mono_class_from_name (mono_defaults.corlib, "System.Reflection", cname); - g_assert (klass); - - ret = (MonoReflectionInflatedMethod*)mono_object_new (domain, klass); - ret->rmethod.method = method; - ret->rmethod.name = mono_string_new (domain, method->name); - ret->rmethod.reftype = mono_type_get_object (domain, &refclass->byval_arg); - ret->declaring = declaring; - ret->ginst = ginst; - CACHE_OBJECT (method, ret, refclass); - return ret; -} - -MonoReflectionGenericInst* -mono_reflection_bind_generic_parameters (MonoReflectionType *type, MonoArray *types) +static MonoType* +do_mono_reflection_bind_generic_parameters (MonoReflectionType *type, int type_argc, + MonoType **types) { - static MonoClass *System_Reflection_MonoGenericInst; + MonoClass *klass; + MonoReflectionTypeBuilder *tb = NULL; + MonoGenericInst *ginst; MonoDomain *domain; MonoType *geninst; - MonoGenericInst *ginst; - MonoArray *ifaces = NULL; - MonoReflectionType *ptype = NULL; - MonoClass *klass, *iklass, *pklass = NULL; - MonoReflectionGenericInst *res, *parent = NULL; - MonoReflectionTypeBuilder *tb = NULL; - int i; - - domain = mono_object_domain (type); + int icount, i; klass = mono_class_from_mono_type (type->type); - if (!klass->gen_params && !klass->generic_inst) + if (!klass->gen_params && !klass->generic_inst && + !(klass->nested_in && klass->nested_in->gen_params)) return NULL; - if (!System_Reflection_MonoGenericInst) { - System_Reflection_MonoGenericInst = mono_class_from_name ( - mono_defaults.corlib, "System.Reflection", "MonoGenericInst"); - g_assert (System_Reflection_MonoGenericInst); - } - - if (klass->wastypebuilder && klass->reflection_info) { - tb = klass->reflection_info; + mono_loader_lock (); - ptype = tb->parent; - if (ptype) - pklass = mono_class_from_mono_type (ptype->type); - } else { - pklass = klass->parent; - if (pklass) - ptype = mono_type_get_object (domain, &pklass->byval_arg); - } - - if (pklass && pklass->generic_inst) - parent = mono_reflection_bind_generic_parameters (ptype, types); - else if (!pklass) { - int icount; - - pklass = mono_defaults.object_class; - - icount = klass->interface_count; - ifaces = mono_array_new (domain, System_Reflection_MonoGenericInst, icount); - - for (i = 0; i < icount; i++) { - MonoReflectionGenericInst *iface; - MonoReflectionType *itype; - - if (tb) - itype = mono_array_get (tb->interfaces, gpointer, i); - else - itype = mono_type_get_object (domain, &klass->interfaces [i]->byval_arg); - iface = mono_reflection_bind_generic_parameters (itype, types); - - mono_array_set (ifaces, gpointer, i, iface); - } - } + domain = mono_object_domain (type); - geninst = g_new0 (MonoType, 1); - geninst->type = MONO_TYPE_GENERICINST; - geninst->data.generic_inst = ginst = g_new0 (MonoGenericInst, 1); + ginst = g_new0 (MonoGenericInst, 1); - if (klass->gen_params) { - ginst->type_argc = mono_array_length (types); - ginst->type_argv = g_new0 (MonoType *, ginst->type_argc); + if (!klass->generic_inst) { + ginst->type_argc = type_argc; + ginst->type_argv = types; for (i = 0; i < ginst->type_argc; ++i) { - MonoReflectionType *garg = mono_array_get (types, gpointer, i); - - ginst->type_argv [i] = garg->type; - if (!ginst->is_open) - ginst->is_open = mono_class_is_open_constructed_type (garg->type); + ginst->is_open = mono_class_is_open_constructed_type (types [i]); } ginst->generic_type = &klass->byval_arg; } else { - MonoGenericInst *kginst = klass->generic_inst->data.generic_inst; + MonoGenericInst *kginst = klass->generic_inst; ginst->type_argc = kginst->type_argc; ginst->type_argv = g_new0 (MonoType *, ginst->type_argc); @@ -6858,12 +7088,8 @@ mono_reflection_bind_generic_parameters (MonoReflectionType *type, MonoArray *ty for (i = 0; i < ginst->type_argc; i++) { MonoType *t = kginst->type_argv [i]; - if (t->type == MONO_TYPE_VAR) { - int num = t->data.generic_param->num; - MonoReflectionType *garg = mono_array_get (types, gpointer, num); - - t = garg->type; - } + if (t->type == MONO_TYPE_VAR) + t = types [t->data.generic_param->num]; if (!ginst->is_open) ginst->is_open = mono_class_is_open_constructed_type (t); @@ -6874,28 +7100,106 @@ mono_reflection_bind_generic_parameters (MonoReflectionType *type, MonoArray *ty ginst->generic_type = kginst->generic_type; } - iklass = mono_class_from_generic (geninst, FALSE); + geninst = g_hash_table_lookup (klass->image->generic_inst_cache, ginst); + if (geninst) { + g_free (ginst); + mono_loader_unlock (); + return geninst; + } - mono_class_setup_parent (iklass, parent ? parent->klass : pklass); - mono_class_setup_mono_type (iklass); + ginst->context = g_new0 (MonoGenericContext, 1); + ginst->context->ginst = ginst; - res = (MonoReflectionGenericInst *)mono_object_new (domain, System_Reflection_MonoGenericInst); + geninst = g_new0 (MonoType, 1); + geninst->type = MONO_TYPE_GENERICINST; + geninst->data.generic_inst = ginst; - res->type.type = iklass->generic_inst; - res->klass = iklass; - res->parent = parent; - res->generic_type = type; - res->interfaces = ifaces; + if (!strcmp (((MonoObject *) type)->vtable->klass->name, "TypeBuilder")) { + tb = (MonoReflectionTypeBuilder *) type; - return res; + icount = tb->interfaces ? mono_array_length (tb->interfaces) : 0; + ginst->is_dynamic = TRUE; + } else if (!strcmp (((MonoObject *) type)->vtable->klass->name, "MonoGenericInst")) { + MonoReflectionGenericInst *rgi = (MonoReflectionGenericInst *) type; + MonoReflectionType *rgt = rgi->generic_type; + + g_assert (!strcmp (((MonoObject *) rgt)->vtable->klass->name, "TypeBuilder")); + tb = (MonoReflectionTypeBuilder *) rgt; + + icount = tb->interfaces ? mono_array_length (tb->interfaces) : 0; + ginst->is_dynamic = TRUE; + } else + icount = klass->interface_count; + + ginst->ifaces = g_new0 (MonoType *, icount); + ginst->count_ifaces = icount; + + for (i = 0; i < icount; i++) { + MonoReflectionType *itype; + + if (tb) + itype = mono_array_get (tb->interfaces, MonoReflectionType *, i); + else + itype = mono_type_get_object (domain, &klass->interfaces [i]->byval_arg); + ginst->ifaces [i] = mono_reflection_bind_generic_parameters (itype, type_argc, types); + if (!ginst->ifaces [i]) + ginst->ifaces [i] = itype->type; + } + + mono_class_create_generic (ginst); + + g_hash_table_insert (klass->image->generic_inst_cache, ginst, geninst); + + mono_loader_unlock (); + + return geninst; +} + +MonoType* +mono_reflection_bind_generic_parameters (MonoReflectionType *type, int type_argc, MonoType **types) +{ + MonoClass *klass, *pklass = NULL; + MonoReflectionType *parent = NULL; + MonoType *geninst; + MonoReflectionTypeBuilder *tb = NULL; + MonoGenericInst *ginst; + MonoDomain *domain; + + domain = mono_object_domain (type); + klass = mono_class_from_mono_type (type->type); + + if (!strcmp (((MonoObject *) type)->vtable->klass->name, "TypeBuilder")) { + tb = (MonoReflectionTypeBuilder *) type; + + if (tb->parent) { + parent = tb->parent; + pklass = mono_class_from_mono_type (parent->type); + } + } else { + pklass = klass->parent; + if (pklass) + parent = mono_type_get_object (domain, &pklass->byval_arg); + } + + geninst = do_mono_reflection_bind_generic_parameters (type, type_argc, types); + if (!geninst) + return NULL; + + ginst = geninst->data.generic_inst; + + if (pklass && pklass->generic_inst) + ginst->parent = mono_reflection_bind_generic_parameters (parent, type_argc, types); + + return geninst; } -MonoReflectionInflatedMethod* +MonoReflectionMethod* mono_reflection_bind_generic_method_parameters (MonoReflectionMethod *rmethod, MonoArray *types) { MonoMethod *method, *inflated; MonoReflectionMethodBuilder *mb = NULL; - MonoGenericInst *ginst; + MonoGenericMethod *gmethod; + MonoGenericContext *context; int count, i; MONO_ARCH_SAVE_REGS; @@ -6915,34 +7219,62 @@ mono_reflection_bind_generic_method_parameters (MonoReflectionMethod *rmethod, M if (count != mono_array_length (types)) return NULL; - ginst = g_new0 (MonoGenericInst, 1); - ginst->generic_method = method; - ginst->type_argc = count; - ginst->type_argv = g_new0 (MonoType *, count); + gmethod = g_new0 (MonoGenericMethod, 1); + gmethod->mtype_argc = count; + gmethod->mtype_argv = g_new0 (MonoType *, count); for (i = 0; i < count; i++) { MonoReflectionType *garg = mono_array_get (types, gpointer, i); - ginst->type_argv [i] = garg->type; + gmethod->mtype_argv [i] = garg->type; } - inflated = mono_class_inflate_generic_method (method, ginst); + context = g_new0 (MonoGenericContext, 1); + context->ginst = method->klass->generic_inst; + context->gmethod = gmethod; + + inflated = mono_class_inflate_generic_method (method, context, NULL); - return inflated_method_get_object (mono_object_domain (rmethod), inflated, rmethod, ginst); + return mono_method_get_object ( + mono_object_domain (rmethod), inflated, NULL); } -MonoReflectionInflatedMethod* -mono_reflection_inflate_method_or_ctor (MonoReflectionGenericInst *declaring_type, - MonoReflectionGenericInst *reflected_type, - MonoObject *obj) +static MonoMethod * +inflate_mono_method (MonoReflectionGenericInst *type, MonoMethod *method, MonoObject *obj) { - MonoGenericInst *ginst, *type_ginst; - MonoMethod *method = NULL, *inflated; - MonoReflectionInflatedMethod *res; - MonoClass *klass; + MonoGenericMethod *gmethod; + MonoGenericInst *ginst; + MonoGenericContext *context; + int i; - MONO_ARCH_SAVE_REGS; + ginst = type->type.type->data.generic_inst; + + gmethod = g_new0 (MonoGenericMethod, 1); + gmethod->reflection_info = obj; + + gmethod->mtype_argc = method->signature->generic_param_count; + gmethod->mtype_argv = g_new0 (MonoType *, gmethod->mtype_argc); + + for (i = 0; i < gmethod->mtype_argc; i++) { + MonoMethodNormal *mn = (MonoMethodNormal *) method; + MonoGenericParam *gparam = &mn->header->gen_params [i]; + + g_assert (gparam->pklass); + gmethod->mtype_argv [i] = &gparam->pklass->byval_arg; + } + + context = g_new0 (MonoGenericContext, 1); + context->ginst = ginst; + context->gmethod = gmethod; - klass = mono_class_from_mono_type (reflected_type->type.type); - type_ginst = reflected_type->type.type->data.generic_inst; + return mono_class_inflate_generic_method (method, context, ginst->klass); +} + +static MonoMethod * +inflate_method (MonoReflectionGenericInst *type, MonoObject *obj) +{ + MonoMethod *method; + MonoClass *klass; + + klass = mono_class_from_mono_type (type->type.type); if (!strcmp (obj->vtable->klass->name, "MethodBuilder")) method = methodbuilder_to_mono_method (klass, (MonoReflectionMethodBuilder *) obj); @@ -6951,87 +7283,138 @@ mono_reflection_inflate_method_or_ctor (MonoReflectionGenericInst *declaring_typ else if (!strcmp (obj->vtable->klass->name, "MonoMethod") || !strcmp (obj->vtable->klass->name, "MonoCMethod")) method = ((MonoReflectionMethod *) obj)->method; - else if (!strcmp (obj->vtable->klass->name, "MonoInflatedMethod") || - !strcmp (obj->vtable->klass->name, "MonoInflatedCtor")) - method = ((MonoReflectionInflatedMethod *) obj)->rmethod.method; - else + else { + method = NULL; /* prevent compiler warning */ g_assert_not_reached (); + } - ginst = g_new0 (MonoGenericInst, 1); - ginst->generic_method = method; - ginst->generic_type = reflected_type->type.type; - ginst->type_argc = type_ginst->type_argc; - ginst->type_argv = type_ginst->type_argv; - ginst->is_open = type_ginst->is_open; + return inflate_mono_method (type, method, obj); +} - ginst->klass = mono_class_from_generic (ginst->generic_type, FALSE); +void +mono_reflection_generic_inst_initialize (MonoReflectionGenericInst *type, + MonoArray *methods, MonoArray *ctors, + MonoArray *fields, MonoArray *properties, + MonoArray *events) +{ + MonoGenericInst *ginst; + MonoDynamicGenericInst *dginst; + MonoClass *klass, *gklass, *pklass; + int i; - if (type_ginst->is_open) - inflated = method; + MONO_ARCH_SAVE_REGS; + + klass = mono_class_from_mono_type (type->type.type); + ginst = type->type.type->data.generic_inst; + + if (ginst->initialized) + return; + + dginst = ginst->dynamic_info = g_new0 (MonoDynamicGenericInst, 1); + + gklass = mono_class_from_mono_type (ginst->generic_type); + mono_class_init (gklass); + + if (ginst->parent) + pklass = mono_class_from_mono_type (ginst->parent); else - inflated = mono_class_inflate_generic_method (method, ginst); + pklass = gklass->parent; - res = inflated_method_get_object ( - mono_object_domain (reflected_type), inflated, (MonoReflectionMethod *) obj, ginst); + mono_class_setup_parent (klass, pklass); - res->declaring_type = declaring_type; - res->reflected_type = reflected_type; + dginst->count_methods = methods ? mono_array_length (methods) : 0; + dginst->count_ctors = ctors ? mono_array_length (ctors) : 0; + dginst->count_fields = fields ? mono_array_length (fields) : 0; + dginst->count_properties = properties ? mono_array_length (properties) : 0; + dginst->count_events = events ? mono_array_length (events) : 0; - return res; -} + dginst->methods = g_new0 (MonoMethod *, dginst->count_methods); + dginst->ctors = g_new0 (MonoMethod *, dginst->count_ctors); + dginst->fields = g_new0 (MonoClassField, dginst->count_fields); + dginst->properties = g_new0 (MonoProperty, dginst->count_properties); + dginst->events = g_new0 (MonoEvent, dginst->count_events); -MonoReflectionInflatedField* -mono_reflection_inflate_field (MonoReflectionGenericInst *declaring_type, - MonoReflectionGenericInst *reflected_type, - MonoObject *obj) -{ - static MonoClass *System_Reflection_MonoInflatedField; - MonoGenericInst *ginst, *type_ginst; - MonoClassField *field = NULL, *inflated; - MonoReflectionInflatedField *res; - MonoDomain *domain; - MonoClass *klass; + for (i = 0; i < dginst->count_methods; i++) { + MonoObject *obj = mono_array_get (methods, gpointer, i); - MONO_ARCH_SAVE_REGS; + dginst->methods [i] = inflate_method (type, obj); + } + + for (i = 0; i < dginst->count_ctors; i++) { + MonoObject *obj = mono_array_get (ctors, gpointer, i); - if (!System_Reflection_MonoInflatedField) { - System_Reflection_MonoInflatedField = mono_class_from_name ( - mono_defaults.corlib, "System.Reflection", "MonoInflatedField"); - g_assert (System_Reflection_MonoInflatedField); + dginst->ctors [i] = inflate_method (type, obj); } - klass = mono_class_from_mono_type (reflected_type->type.type); - type_ginst = reflected_type->type.type->data.generic_inst; + for (i = 0; i < dginst->count_fields; i++) { + MonoObject *obj = mono_array_get (fields, gpointer, i); + MonoClassField *field; - if (!strcmp (obj->vtable->klass->name, "FieldBuilder")) { - field = fieldbuilder_to_mono_class_field (klass, (MonoReflectionFieldBuilder *) obj); - } else if (!strcmp (obj->vtable->klass->name, "MonoField")) - field = ((MonoReflectionField *) obj)->field; - else - g_assert_not_reached (); + if (!strcmp (obj->vtable->klass->name, "FieldBuilder")) + field = fieldbuilder_to_mono_class_field (klass, (MonoReflectionFieldBuilder *) obj); + else if (!strcmp (obj->vtable->klass->name, "MonoField")) + field = ((MonoReflectionField *) obj)->field; + else { + field = NULL; /* prevent compiler warning */ + g_assert_not_reached (); + } - ginst = g_new0 (MonoGenericInst, 1); - ginst->generic_type = reflected_type->type.type; - ginst->type_argc = type_ginst->type_argc; - ginst->type_argv = type_ginst->type_argv; - - inflated = g_new0 (MonoClassField, 1); - *inflated = *field; - inflated->type = mono_class_inflate_generic_type (field->type, ginst); - - domain = mono_object_domain (obj); - - res = (MonoReflectionInflatedField *)mono_object_new (domain, System_Reflection_MonoInflatedField); - res->declaring = field; - res->declaring_type = declaring_type; - res->reflected_type = reflected_type; - res->rfield.klass = klass; - res->rfield.field = inflated; - res->rfield.name = mono_string_new (domain, inflated->name); - res->rfield.attrs = inflated->type->attrs; - res->rfield.type = mono_type_get_object (domain, inflated->type); - CACHE_OBJECT (inflated, res, field->parent); - return res; + dginst->fields [i] = *field; + dginst->fields [i].generic_type = field->type; + dginst->fields [i].type = mono_class_inflate_generic_type (field->type, ginst->context); + } + + for (i = 0; i < dginst->count_properties; i++) { + MonoObject *obj = mono_array_get (properties, gpointer, i); + MonoProperty *property = &dginst->properties [i]; + + if (!strcmp (obj->vtable->klass->name, "PropertyBuilder")) { + MonoReflectionPropertyBuilder *pb = (MonoReflectionPropertyBuilder *) obj; + + property->parent = klass; + property->attrs = pb->attrs; + property->name = mono_string_to_utf8 (pb->name); + if (pb->get_method) + property->get = inflate_method (type, (MonoObject *) pb->get_method); + if (pb->set_method) + property->set = inflate_method (type, (MonoObject *) pb->set_method); + } else if (!strcmp (obj->vtable->klass->name, "MonoProperty")) { + *property = *((MonoReflectionProperty *) obj)->property; + + if (property->get) + property->get = inflate_mono_method (type, property->get, NULL); + if (property->set) + property->set = inflate_mono_method (type, property->set, NULL); + } else + g_assert_not_reached (); + } + + for (i = 0; i < dginst->count_events; i++) { + MonoObject *obj = mono_array_get (events, gpointer, i); + MonoEvent *event = &dginst->events [i]; + + if (!strcmp (obj->vtable->klass->name, "EventBuilder")) { + MonoReflectionEventBuilder *eb = (MonoReflectionEventBuilder *) obj; + + event->parent = klass; + event->attrs = eb->attrs; + event->name = mono_string_to_utf8 (eb->name); + if (eb->add_method) + event->add = inflate_method (type, (MonoObject *) eb->add_method); + if (eb->remove_method) + event->remove = inflate_method (type, (MonoObject *) eb->remove_method); + } else if (!strcmp (obj->vtable->klass->name, "MonoEvent")) { + *event = *((MonoReflectionEvent *) obj)->event; + + if (event->add) + event->add = inflate_mono_method (type, event->add, NULL); + if (event->remove) + event->remove = inflate_mono_method (type, event->remove, NULL); + } else + g_assert_not_reached (); + } + + ginst->initialized = TRUE; } static void @@ -7175,6 +7558,7 @@ typebuilder_setup_properties (MonoClass *klass) klass->properties = g_new0 (MonoProperty, klass->property.count); for (i = 0; i < klass->property.count; ++i) { pb = mono_array_get (tb->properties, MonoReflectionPropertyBuilder*, i); + klass->properties [i].parent = klass; klass->properties [i].attrs = pb->attrs; klass->properties [i].name = mono_string_to_utf8 (pb->name); if (pb->get_method) @@ -7184,6 +7568,38 @@ typebuilder_setup_properties (MonoClass *klass) } } +MonoReflectionEvent * +mono_reflection_event_builder_get_event_info (MonoReflectionTypeBuilder *tb, MonoReflectionEventBuilder *eb) +{ + MonoEvent *event = g_new0 (MonoEvent, 1); + MonoClass *klass; + int j; + + klass = my_mono_class_from_mono_type (tb->type.type); + + event->parent = klass; + event->attrs = eb->attrs; + event->name = mono_string_to_utf8 (eb->name); + if (eb->add_method) + event->add = eb->add_method->mhandle; + if (eb->remove_method) + event->remove = eb->remove_method->mhandle; + if (eb->raise_method) + event->raise = eb->raise_method->mhandle; + + if (eb->other_methods) { + event->other = g_new0 (MonoMethod*, mono_array_length (eb->other_methods)); + for (j = 0; j < mono_array_length (eb->other_methods); ++j) { + MonoReflectionMethodBuilder *mb = + mono_array_get (eb->other_methods, + MonoReflectionMethodBuilder*, j); + event->other [j] = mb->mhandle; + } + } + + return mono_event_get_object (mono_object_domain (tb), klass, event); +} + static void typebuilder_setup_events (MonoClass *klass) { @@ -7198,6 +7614,7 @@ typebuilder_setup_events (MonoClass *klass) klass->events = g_new0 (MonoEvent, klass->event.count); for (i = 0; i < klass->event.count; ++i) { eb = mono_array_get (tb->events, MonoReflectionEventBuilder*, i); + klass->events [i].parent = klass; klass->events [i].attrs = eb->attrs; klass->events [i].name = mono_string_to_utf8 (eb->name); if (eb->add_method) @@ -7272,74 +7689,29 @@ mono_reflection_create_runtime_class (MonoReflectionTypeBuilder *tb) return res; } -MonoReflectionGenericParam * -mono_reflection_define_generic_parameter (MonoReflectionTypeBuilder *tb, MonoReflectionMethodBuilder *mb, MonoString *name, guint32 index) -{ - static MonoClass *System_Reflection_MonoGenericParam; - MonoImage *image; - MonoGenericParam *param; - MonoReflectionGenericParam *res; - MonoDomain *domain; - - if (!System_Reflection_MonoGenericParam) { - System_Reflection_MonoGenericParam = mono_class_from_name ( - mono_defaults.corlib, "System.Reflection", "MonoGenericParam"); - g_assert (System_Reflection_MonoGenericParam); - } - - param = g_new0 (MonoGenericParam, 1); - - if (mb) - tb = (MonoReflectionTypeBuilder *) mb->type; - - domain = mono_object_domain (tb); - image = (MonoImage*)tb->module->dynamic_image; - - param->method = NULL; - param->name = mono_string_to_utf8 (name); - param->num = index; - - res = (MonoReflectionGenericParam *)mono_object_new (domain, System_Reflection_MonoGenericParam); - res->type.type = g_new0 (MonoType, 1); - res->type.type->type = mb ? MONO_TYPE_MVAR : MONO_TYPE_VAR; - res->type.type->data.generic_param = param; - - res->refobj = mb ? (MonoObject *) mb : (MonoObject *) tb; - res->index = index; - res->name = name; - - return res; -} - void mono_reflection_initialize_generic_parameter (MonoReflectionGenericParam *gparam) { MonoGenericParam *param; - MonoReflectionMethodBuilder *mb = NULL; - MonoReflectionTypeBuilder *tb; MonoImage *image; - int count, i; - param = gparam->type.type->data.generic_param; - count = gparam->constraints ? mono_array_length (gparam->constraints) : 0; - param->constraints = g_new0 (MonoClass *, count + 1); - for (i = 0; i < count; i++) { - MonoReflectionType *constraint = mono_array_get (gparam->constraints, MonoReflectionType *, i); + MONO_ARCH_SAVE_REGS; - param->constraints [i] = mono_class_from_mono_type (constraint->type); - } + param = g_new0 (MonoGenericParam, 1); - if (!strcmp (gparam->refobj->vtable->klass->name, "MethodBuilder")) { - mb = (MonoReflectionMethodBuilder *) gparam->refobj; - tb = (MonoReflectionTypeBuilder *) mb->type; - } else - tb = (MonoReflectionTypeBuilder *) gparam->refobj; + param->method = NULL; + param->name = mono_string_to_utf8 (gparam->name); + param->num = gparam->index; - image = (MonoImage*)tb->module->dynamic_image; + image = &gparam->tbuilder->module->dynamic_image->image; + mono_class_from_generic_parameter (param, image, gparam->mbuilder != NULL); - param->pklass = mono_class_from_generic_parameter (param, image, mb != NULL); + param->pklass->reflection_info = gparam; - gparam->initialized = TRUE; + gparam->type.type = g_new0 (MonoType, 1); + gparam->type.type->type = gparam->mbuilder ? MONO_TYPE_MVAR : MONO_TYPE_VAR; + gparam->type.type->attrs = TYPE_ATTRIBUTE_PUBLIC; + gparam->type.type->data.generic_param = param; } MonoArray * @@ -7417,7 +7789,7 @@ mono_reflection_create_dynamic_method (MonoReflectionDynamicMethod *mb) rmb.refs = g_new0 (gpointer, mb->nrefs + 1); for (i = 0; i < mb->nrefs; ++i) { gpointer ref = resolve_object (mb->module->image, - mono_array_get (mb->refs, MonoObject*, i)); + mono_array_get (mb->refs, MonoObject*, i)); if (!ref) { g_free (rmb.refs); mono_raise_exception (mono_get_exception_type_load (NULL));