From a0ad8154f7cdca706802aa196d95686e0f8d3b7b Mon Sep 17 00:00:00 2001 From: Zoltan Varga Date: Thu, 29 Sep 2016 23:53:22 -0400 Subject: [PATCH] Sre cleanup9 (#3661) * [SRE] Assign pseudo tokens to SRE objects in the BCL instead of doing it in the runtime. Real tokens are assigned after the dynamic types they depend on have been created, by creating the corresponding finished reflection object (i.e. a MonoMethod for a MethodOnTypeBuilderInst etc.) and obtaining its token. In Save mode, this is done in ModuleBuilder.Save (). In Run mode, this is done on-demand when the JIT tries to resolve a token into its corresponding metadata object, by the runtime calling the RuntimeResolve () method on the builder object. * [SRE] Remove dead code. * [SRE] Remove the MonoGenericMethod/MonoGenericCMethod classes, they have not needed. * [SRE] Delay the creation of MonoClass-es for MonoGenericClass/GenericTypeParameterBuilder/SymbolType until its needed. * [SRE] Small code cleanup. * [SRE] Remove the TypeBuilder.IsGenericParameter () icall, it should return false. * [SRE] Unify the calling of the various RuntimeResolve () methods by adding a RuntimeResolve () method to ModuleBuilder, and calling that from native code. * [SRE] Remove unused TypeBuilder::get_event_info () icall. * [SRE] Remove more unused/empty icalls. --- mcs/class/corlib/ReferenceSources/Type.cs | 6 + .../ConstructorBuilder.cs | 11 +- .../ConstructorOnTypeBuilderInst.cs | 23 +- .../System.Reflection.Emit/DerivedTypes.cs | 9 +- .../System.Reflection.Emit/FieldBuilder.cs | 4 + .../FieldOnTypeBuilderInst.cs | 6 + .../GenericTypeParameterBuilder.cs | 11 +- .../System.Reflection.Emit/ILGenerator.cs | 28 +- .../System.Reflection.Emit/MethodBuilder.cs | 15 + .../MethodOnTypeBuilderInst.cs | 13 + .../System.Reflection.Emit/ModuleBuilder.cs | 155 +++ .../System.Reflection.Emit/TypeBuilder.cs | 75 +- .../System.Reflection/MonoGenericClass.cs | 48 +- .../System.Reflection/MonoGenericMethod.cs | 60 - .../ModuleBuilderTest.cs | 6 + .../System.Reflection.Emit/TypeBuilderTest.cs | 27 + mcs/class/corlib/corlib-net_4_x.csproj | 1 - mcs/class/corlib/corlib.dll.sources | 1 - mcs/tools/linker/Descriptors/mscorlib.xml | 3 +- mono/metadata/custom-attrs.c | 23 +- mono/metadata/icall-def.h | 13 +- mono/metadata/object-internals.h | 23 +- mono/metadata/reflection.c | 33 +- mono/metadata/sre-internals.h | 3 - mono/metadata/sre-save.c | 46 +- mono/metadata/sre.c | 1103 ++--------------- 26 files changed, 477 insertions(+), 1269 deletions(-) delete mode 100644 mcs/class/corlib/System.Reflection/MonoGenericMethod.cs diff --git a/mcs/class/corlib/ReferenceSources/Type.cs b/mcs/class/corlib/ReferenceSources/Type.cs index 370beffb237..a77d734c366 100644 --- a/mcs/class/corlib/ReferenceSources/Type.cs +++ b/mcs/class/corlib/ReferenceSources/Type.cs @@ -102,6 +102,12 @@ namespace System return UnderlyingSystemType; } + // Called from the runtime to return the corresponding finished Type object + internal virtual Type RuntimeResolve () + { + throw new NotImplementedException (); + } + internal virtual bool IsUserType { get { return true; diff --git a/mcs/class/corlib/System.Reflection.Emit/ConstructorBuilder.cs b/mcs/class/corlib/System.Reflection.Emit/ConstructorBuilder.cs index 793e36fd2a0..55a392d3844 100644 --- a/mcs/class/corlib/System.Reflection.Emit/ConstructorBuilder.cs +++ b/mcs/class/corlib/System.Reflection.Emit/ConstructorBuilder.cs @@ -145,7 +145,11 @@ namespace System.Reflection.Emit { internal override Type GetParameterType (int pos) { return parameters [pos]; } - + + internal MethodBase RuntimeResolve () { + return type.RuntimeResolve ().GetConstructor (this); + } + public override Object Invoke (Object obj, BindingFlags invokeAttr, Binder binder, Object[] parameters, CultureInfo culture) { throw not_supported (); @@ -372,6 +376,11 @@ namespace System.Reflection.Emit { TypeBuilder.ResolveUserTypes (types); } } + + internal void FixupTokens (Dictionary token_map, Dictionary member_map) { + if (ilgen != null) + ilgen.FixupTokens (token_map, member_map); + } internal void GenerateDebugInfo (ISymbolWriter symbolWriter) { diff --git a/mcs/class/corlib/System.Reflection.Emit/ConstructorOnTypeBuilderInst.cs b/mcs/class/corlib/System.Reflection.Emit/ConstructorOnTypeBuilderInst.cs index 149e5dbd663..b7909463971 100644 --- a/mcs/class/corlib/System.Reflection.Emit/ConstructorOnTypeBuilderInst.cs +++ b/mcs/class/corlib/System.Reflection.Emit/ConstructorOnTypeBuilderInst.cs @@ -42,8 +42,8 @@ namespace System.Reflection.Emit internal class ConstructorOnTypeBuilderInst : ConstructorInfo { #region Keep in sync with object-internals.h - MonoGenericClass instantiation; - ConstructorInfo cb; + internal MonoGenericClass instantiation; + internal ConstructorInfo cb; #endregion public ConstructorOnTypeBuilderInst (MonoGenericClass instantiation, ConstructorInfo cb) @@ -134,6 +134,25 @@ namespace System.Reflection.Emit return res; } + internal override Type[] GetParameterTypes () { + if (cb is ConstructorBuilder) { + return (cb as ConstructorBuilder).parameters; + } else { + ParameterInfo[] parms = cb.GetParameters (); + var res = new Type [parms.Length]; + for (int i = 0; i < parms.Length; i++) { + res [i] = parms [i].ParameterType; + } + return res; + } + } + + // Called from the runtime to return the corresponding finished ConstructorInfo object + internal ConstructorInfo RuntimeResolve () { + var type = instantiation.InternalResolve (); + return type.GetConstructor (cb); + } + public override int MetadataToken { get { return base.MetadataToken; diff --git a/mcs/class/corlib/System.Reflection.Emit/DerivedTypes.cs b/mcs/class/corlib/System.Reflection.Emit/DerivedTypes.cs index b7ce6e0410a..771942f7beb 100644 --- a/mcs/class/corlib/System.Reflection.Emit/DerivedTypes.cs +++ b/mcs/class/corlib/System.Reflection.Emit/DerivedTypes.cs @@ -45,9 +45,6 @@ namespace System.Reflection.Emit { internal Type m_baseType; - [MethodImplAttribute(MethodImplOptions.InternalCall)] - static extern void create_unmanaged_type (Type type); - internal SymbolType (Type elementType) { this.m_baseType = elementType; @@ -121,7 +118,6 @@ namespace System.Reflection.Emit public override Type UnderlyingSystemType { get { - create_unmanaged_type (this); return this; } } @@ -131,6 +127,11 @@ namespace System.Reflection.Emit return m_baseType.IsUserType; } } + + // Called from the runtime to return the corresponding finished Type object + internal override Type RuntimeResolve () { + return InternalResolve (); + } } [StructLayout (LayoutKind.Sequential)] diff --git a/mcs/class/corlib/System.Reflection.Emit/FieldBuilder.cs b/mcs/class/corlib/System.Reflection.Emit/FieldBuilder.cs index f2fff7d7aa1..f8522ebe862 100644 --- a/mcs/class/corlib/System.Reflection.Emit/FieldBuilder.cs +++ b/mcs/class/corlib/System.Reflection.Emit/FieldBuilder.cs @@ -228,6 +228,10 @@ namespace System.Reflection.Emit { marshal_info.marshaltyperef = TypeBuilder.ResolveUserType (marshal_info.marshaltyperef); } + internal FieldInfo RuntimeResolve () { + return typeb.CreateType ().GetField (this); + } + public override Module Module { get { return base.Module; diff --git a/mcs/class/corlib/System.Reflection.Emit/FieldOnTypeBuilderInst.cs b/mcs/class/corlib/System.Reflection.Emit/FieldOnTypeBuilderInst.cs index ca3d43d85f9..f498040741d 100644 --- a/mcs/class/corlib/System.Reflection.Emit/FieldOnTypeBuilderInst.cs +++ b/mcs/class/corlib/System.Reflection.Emit/FieldOnTypeBuilderInst.cs @@ -127,6 +127,12 @@ namespace System.Reflection.Emit public override void SetValue (object obj, object value, BindingFlags invokeAttr, Binder binder, CultureInfo culture) { throw new NotSupportedException (); } + + // Called from the runtime to return the corresponding finished FieldInfo object + internal FieldInfo RuntimeResolve () { + var type = instantiation.RuntimeResolve (); + return type.GetField (fb); + } } } #endif diff --git a/mcs/class/corlib/System.Reflection.Emit/GenericTypeParameterBuilder.cs b/mcs/class/corlib/System.Reflection.Emit/GenericTypeParameterBuilder.cs index 037d36fdc3e..4dbda5d0aca 100644 --- a/mcs/class/corlib/System.Reflection.Emit/GenericTypeParameterBuilder.cs +++ b/mcs/class/corlib/System.Reflection.Emit/GenericTypeParameterBuilder.cs @@ -88,7 +88,16 @@ namespace System.Reflection.Emit internal override Type InternalResolve () { - return tbuilder.InternalResolve ().GetGenericArguments () [index]; + if (mbuilder != null) + return MethodBase.GetMethodFromHandle (mbuilder.MethodHandleInternal).GetGenericArguments () [index]; + return tbuilder.InternalResolve ().GetGenericArguments () [index]; + } + + internal override Type RuntimeResolve () + { + if (mbuilder != null) + return MethodBase.GetMethodFromHandle (mbuilder.MethodHandleInternal, mbuilder.TypeBuilder.RuntimeResolve ().TypeHandle).GetGenericArguments () [index]; + return tbuilder.RuntimeResolve ().GetGenericArguments () [index]; } [MethodImplAttribute(MethodImplOptions.InternalCall)] diff --git a/mcs/class/corlib/System.Reflection.Emit/ILGenerator.cs b/mcs/class/corlib/System.Reflection.Emit/ILGenerator.cs index ac4fda04472..66d5d951e9d 100644 --- a/mcs/class/corlib/System.Reflection.Emit/ILGenerator.cs +++ b/mcs/class/corlib/System.Reflection.Emit/ILGenerator.cs @@ -521,7 +521,7 @@ namespace System.Reflection.Emit { int token = token_gen.GetToken (con, true); make_room (6); ll_emit (opcode); - if (con.DeclaringType.Module == module) + if (con.DeclaringType.Module == module || (con is ConstructorOnTypeBuilderInst) || (con is ConstructorBuilder)) add_token_fixup (con); emit_int (token); @@ -554,7 +554,7 @@ namespace System.Reflection.Emit { int token = token_gen.GetToken (field, true); make_room (6); ll_emit (opcode); - if (field.DeclaringType.Module == module) + if (field.DeclaringType.Module == module || (field is FieldOnTypeBuilderInst) || (field is FieldBuilder)) add_token_fixup (field); emit_int (token); } @@ -737,7 +737,7 @@ namespace System.Reflection.Emit { Type declaringType = meth.DeclaringType; // Might be a DynamicMethod with no declaring type if (declaringType != null) { - if (declaringType.Module == module) + if (declaringType.Module == module || meth is MethodOnTypeBuilderInst || meth is MethodBuilder) add_token_fixup (meth); } emit_int (token); @@ -755,7 +755,7 @@ namespace System.Reflection.Emit { // Might be a DynamicMethod with no declaring type Type declaringType = method.DeclaringType; if (declaringType != null) { - if (declaringType.Module == module) + if (declaringType.Module == module || method is MethodBuilder) add_token_fixup (method); } emit_int (token); @@ -813,7 +813,10 @@ namespace System.Reflection.Emit { make_room (6); ll_emit (opcode); - emit_int (token_gen.GetToken (cls, opcode != OpCodes.Ldtoken)); + int token = token_gen.GetToken (cls, opcode != OpCodes.Ldtoken); + if (cls is MonoGenericClass || cls is SymbolType || cls is TypeBuilder || cls is GenericTypeParameterBuilder) + add_token_fixup (cls); + emit_int (token); } [MonoLimitation ("vararg methods are not supported")] @@ -1007,6 +1010,21 @@ namespace System.Reflection.Emit { } } + internal void FixupTokens (Dictionary token_map, Dictionary member_map) { + for (int i = 0; i < num_token_fixups; ++i) { + int pos = token_fixups [i].code_pos; + int old_token = code [pos] | (code [pos + 1] << 8) | (code [pos + 2] << 16) | (code [pos + 3] << 24); + int new_token; + if (token_map.TryGetValue (old_token, out new_token)) { + token_fixups [i].member = member_map [old_token]; + int old_cl = code_len; + code_len = pos; + emit_int (new_token); + code_len = old_cl; + } + } + } + // Used by MethodBuilder.SetMethodBody internal void SetExceptionHandlers (ILExceptionInfo[] exHandlers) { this.ex_handlers = exHandlers; diff --git a/mcs/class/corlib/System.Reflection.Emit/MethodBuilder.cs b/mcs/class/corlib/System.Reflection.Emit/MethodBuilder.cs index 5545adca276..8748f20aba2 100644 --- a/mcs/class/corlib/System.Reflection.Emit/MethodBuilder.cs +++ b/mcs/class/corlib/System.Reflection.Emit/MethodBuilder.cs @@ -138,6 +138,12 @@ namespace System.Reflection.Emit } } + internal RuntimeMethodHandle MethodHandleInternal { + get { + return mhandle; + } + } + public override Type ReturnType { get { return rtype; } } @@ -248,6 +254,10 @@ namespace System.Reflection.Emit return parameters [pos]; } + internal MethodBase RuntimeResolve () { + return type.RuntimeResolve ().GetMethod (this); + } + public Module GetModule () { return type.Module; @@ -380,6 +390,11 @@ namespace System.Reflection.Emit } } + internal void FixupTokens (Dictionary token_map, Dictionary member_map) { + if (ilgen != null) + ilgen.FixupTokens (token_map, member_map); + } + internal void GenerateDebugInfo (ISymbolWriter symbolWriter) { if (ilgen != null && ilgen.HasDebugInfo) { diff --git a/mcs/class/corlib/System.Reflection.Emit/MethodOnTypeBuilderInst.cs b/mcs/class/corlib/System.Reflection.Emit/MethodOnTypeBuilderInst.cs index 9bc0b8a5994..0c6a12b81a7 100644 --- a/mcs/class/corlib/System.Reflection.Emit/MethodOnTypeBuilderInst.cs +++ b/mcs/class/corlib/System.Reflection.Emit/MethodOnTypeBuilderInst.cs @@ -100,6 +100,19 @@ namespace System.Reflection.Emit return instantiation.GetGenericArguments (); } + // Called from the runtime to return the corresponding finished MethodInfo object + internal MethodInfo RuntimeResolve () { + var type = instantiation.InternalResolve (); + var m = type.GetMethod (base_method); + if (method_arguments != null) { + var args = new Type [method_arguments.Length]; + for (int i = 0; i < method_arguments.Length; ++i) + args [i] = method_arguments [i].InternalResolve (); + m = m.MakeGenericMethod (args); + } + return m; + } + // // MemberInfo members // diff --git a/mcs/class/corlib/System.Reflection.Emit/ModuleBuilder.cs b/mcs/class/corlib/System.Reflection.Emit/ModuleBuilder.cs index 8d485153e38..c8ad4c4d57b 100644 --- a/mcs/class/corlib/System.Reflection.Emit/ModuleBuilder.cs +++ b/mcs/class/corlib/System.Reflection.Emit/ModuleBuilder.cs @@ -681,15 +681,90 @@ namespace System.Reflection.Emit { return result; } + static int typeref_tokengen = 0x01ffffff; + static int typedef_tokengen = 0x02ffffff; + static int typespec_tokengen = 0x1bffffff; + static int memberref_tokengen = 0x0affffff; + static int methoddef_tokengen = 0x06ffffff; + Dictionary inst_tokens = new Dictionary (); + Dictionary inst_tokens_open = new Dictionary (); + + // + // Assign a pseudo token to the various TypeBuilderInst objects, so the runtime + // doesn't have to deal with them. + // For Save assemblies, the tokens will be fixed up later during Save (). + // For Run assemblies, the tokens will not be fixed up, so the runtime will + // still encounter these objects, it will resolve them by calling their + // RuntimeResolve () methods. + // + int GetPseudoToken (MemberInfo member, bool create_open_instance) { + int token; + + if (create_open_instance) { + if (inst_tokens_open.TryGetValue (member, out token)) + return token; + } else { + if (inst_tokens.TryGetValue (member, out token)) + return token; + } + // Count backwards to avoid collisions with the tokens + // allocated by the runtime + if (member is MonoGenericClass || member is SymbolType) + token = typespec_tokengen --; + else if (member is FieldOnTypeBuilderInst) + token = memberref_tokengen --; + else if (member is ConstructorOnTypeBuilderInst) + token = memberref_tokengen --; + else if (member is MethodOnTypeBuilderInst) + token = memberref_tokengen --; + else if (member is FieldBuilder) + token = memberref_tokengen --; + else if (member is TypeBuilder) { + if (create_open_instance && (member as TypeBuilder).ContainsGenericParameters) + token = typespec_tokengen --; + else if (member.Module == this) + token = typedef_tokengen --; + else + token = typeref_tokengen --; + } else if (member is ConstructorBuilder) { + if (member.Module == this && !(member as ConstructorBuilder).TypeBuilder.ContainsGenericParameters) + token = methoddef_tokengen --; + else + token = memberref_tokengen --; + } else if (member is MethodBuilder) { + var mb = member as MethodBuilder; + if (member.Module == this && !mb.TypeBuilder.ContainsGenericParameters && !mb.IsGenericMethodDefinition) + token = methoddef_tokengen --; + else + token = memberref_tokengen --; + } else if (member is GenericTypeParameterBuilder) { + token = typespec_tokengen --; + } else + throw new NotImplementedException (); + if (create_open_instance) + inst_tokens_open [member] = token; + else + inst_tokens [member] = token; + RegisterToken (member, token); + return token; + } + internal int GetToken (MemberInfo member) { + if (member is ConstructorBuilder || member is MethodBuilder) + return GetPseudoToken (member, false); return getToken (this, member, true); } internal int GetToken (MemberInfo member, bool create_open_instance) { + if (member is MonoGenericClass || member is FieldOnTypeBuilderInst || member is ConstructorOnTypeBuilderInst || member is MethodOnTypeBuilderInst || member is SymbolType || member is FieldBuilder || member is TypeBuilder || member is ConstructorBuilder || member is MethodBuilder || member is GenericTypeParameterBuilder) + return GetPseudoToken (member, create_open_instance); return getToken (this, member, create_open_instance); } internal int GetToken (MethodBase method, IEnumerable opt_param_types) { + if (method is ConstructorBuilder || method is MethodBuilder) + return GetPseudoToken (method, false); + if (opt_param_types == null) return getToken (this, method, true); @@ -698,6 +773,8 @@ namespace System.Reflection.Emit { } internal int GetToken (MethodBase method, Type[] opt_param_types) { + if (method is ConstructorBuilder || method is MethodBuilder) + return GetPseudoToken (method, false); return getMethodToken (this, method, opt_param_types); } @@ -724,12 +801,88 @@ namespace System.Reflection.Emit { return token_gen; } + // Called from the runtime to return the corresponding finished reflection object + internal static object RuntimeResolve (object obj) { + if (obj is MethodBuilder) + return (obj as MethodBuilder).RuntimeResolve (); + if (obj is ConstructorBuilder) + return (obj as ConstructorBuilder).RuntimeResolve (); + if (obj is FieldBuilder) + return (obj as FieldBuilder).RuntimeResolve (); + if (obj is GenericTypeParameterBuilder) + return (obj as GenericTypeParameterBuilder).RuntimeResolve (); + if (obj is FieldOnTypeBuilderInst) + return (obj as FieldOnTypeBuilderInst).RuntimeResolve (); + if (obj is MethodOnTypeBuilderInst) + return (obj as MethodOnTypeBuilderInst).RuntimeResolve (); + if (obj is ConstructorOnTypeBuilderInst) + return (obj as ConstructorOnTypeBuilderInst).RuntimeResolve (); + if (obj is Type) + return (obj as Type).RuntimeResolve (); + throw new NotImplementedException (obj.GetType ().FullName); + } + [MethodImplAttribute(MethodImplOptions.InternalCall)] private static extern void build_metadata (ModuleBuilder mb); [MethodImplAttribute(MethodImplOptions.InternalCall)] private extern void WriteToFile (IntPtr handle); + void FixupTokens (Dictionary token_map, Dictionary member_map, Dictionary inst_tokens, + bool open) { + foreach (var v in inst_tokens) { + var member = v.Key; + var old_token = v.Value; + MemberInfo finished = null; + + // Construct the concrete reflection object corresponding to the + // TypeBuilderInst object, and request a token for it instead. + if (member is MonoGenericClass || member is SymbolType) { + finished = (member as Type).RuntimeResolve (); + } else if (member is FieldOnTypeBuilderInst) { + finished = (member as FieldOnTypeBuilderInst).RuntimeResolve (); + } else if (member is ConstructorOnTypeBuilderInst) { + finished = (member as ConstructorOnTypeBuilderInst).RuntimeResolve (); + } else if (member is MethodOnTypeBuilderInst) { + finished = (member as MethodOnTypeBuilderInst).RuntimeResolve (); + } else if (member is FieldBuilder) { + finished = (member as FieldBuilder).RuntimeResolve (); + } else if (member is TypeBuilder) { + finished = (member as TypeBuilder).RuntimeResolve (); + } else if (member is ConstructorBuilder) { + finished = (member as ConstructorBuilder).RuntimeResolve (); + } else if (member is MethodBuilder) { + finished = (member as MethodBuilder).RuntimeResolve (); + } else if (member is GenericTypeParameterBuilder) { + finished = (member as GenericTypeParameterBuilder).RuntimeResolve (); + } else { + throw new NotImplementedException (); + } + + int new_token = GetToken (finished, open); + token_map [old_token] = new_token; + member_map [old_token] = finished; + // Replace the token mapping in the runtime so it points to the new object + RegisterToken (finished, old_token); + } + } + + // + // Fixup the pseudo tokens assigned to the various SRE objects + // + void FixupTokens () { + var token_map = new Dictionary (); + var member_map = new Dictionary (); + FixupTokens (token_map, member_map, inst_tokens, false); + FixupTokens (token_map, member_map, inst_tokens_open, true); + + // Replace the tokens in the IL stream + if (types != null) { + for (int i = 0; i < num_types; ++i) + types [i].FixupTokens (token_map, member_map); + } + } + internal void Save () { if (transient && !is_main) @@ -741,6 +894,8 @@ namespace System.Reflection.Emit { throw new NotSupportedException ("Type '" + types [i].FullName + "' was not completed."); } + FixupTokens (); + if ((global_type != null) && (global_type_created == null)) global_type_created = global_type.CreateType (); diff --git a/mcs/class/corlib/System.Reflection.Emit/TypeBuilder.cs b/mcs/class/corlib/System.Reflection.Emit/TypeBuilder.cs index 3972192308d..ef60cb1df28 100644 --- a/mcs/class/corlib/System.Reflection.Emit/TypeBuilder.cs +++ b/mcs/class/corlib/System.Reflection.Emit/TypeBuilder.cs @@ -40,6 +40,7 @@ using System.Runtime.CompilerServices; using System.Runtime.InteropServices; using System.Globalization; using System.Collections; +using System.Collections.Generic; using System.Security; using System.Security.Permissions; using System.Diagnostics.SymbolStore; @@ -98,9 +99,6 @@ namespace System.Reflection.Emit [MethodImplAttribute(MethodImplOptions.InternalCall)] private extern void create_generic_class (); - [MethodImplAttribute(MethodImplOptions.InternalCall)] - private extern EventInfo get_event_info (EventBuilder eb); - internal TypeBuilder (ModuleBuilder mb, TypeAttributes attr, int table_idx) { this.parent = null; @@ -873,6 +871,17 @@ namespace System.Reflection.Emit } } + internal void FixupTokens (Dictionary token_map, Dictionary member_map) { + if (methods != null) { + for (int i = 0; i < num_methods; ++i) + methods[i].FixupTokens (token_map, member_map); + } + if (ctors != null) { + foreach (var cb in ctors) + cb.FixupTokens (token_map, member_map); + } + } + internal void GenerateDebugInfo (ISymbolWriter symbolWriter) { symbolWriter.OpenNamespace (this.Namespace); @@ -968,53 +977,6 @@ namespace System.Reflection.Emit throw new NotSupportedException (); } - // This is only used from MonoGenericInst.initialize(). - internal EventInfo[] GetEvents_internal (BindingFlags bindingAttr) - { - if (events == null) - return new EventInfo [0]; - ArrayList l = new ArrayList (); - bool match; - MethodAttributes mattrs; - MethodInfo accessor; - - foreach (EventBuilder eb in events) { - if (eb == null) - continue; - EventInfo c = get_event_info (eb); - match = false; - accessor = c.GetAddMethod (true); - if (accessor == null) - accessor = c.GetRemoveMethod (true); - if (accessor == null) - continue; - mattrs = accessor.Attributes; - if ((mattrs & MethodAttributes.MemberAccessMask) == MethodAttributes.Public) { - if ((bindingAttr & BindingFlags.Public) != 0) - match = true; - } else { - if ((bindingAttr & BindingFlags.NonPublic) != 0) - match = true; - } - if (!match) - continue; - match = false; - if ((mattrs & MethodAttributes.Static) != 0) { - if ((bindingAttr & BindingFlags.Static) != 0) - match = true; - } else { - if ((bindingAttr & BindingFlags.Instance) != 0) - match = true; - } - if (!match) - continue; - l.Add (c); - } - EventInfo[] result = new EventInfo [l.Count]; - l.CopyTo (result); - return result; - } - public override FieldInfo GetField (string name, BindingFlags bindingAttr) { if (created != null) @@ -1666,6 +1628,12 @@ namespace System.Reflection.Emit return created; } + internal override Type RuntimeResolve () + { + check_created (); + return created; + } + internal bool is_created { get { return createTypeCalled; @@ -1764,9 +1732,10 @@ namespace System.Reflection.Emit } } - public extern override bool IsGenericParameter { - [MethodImplAttribute(MethodImplOptions.InternalCall)] - get; + public override bool IsGenericParameter { + get { + return false; + } } public override GenericParameterAttributes GenericParameterAttributes { diff --git a/mcs/class/corlib/System.Reflection/MonoGenericClass.cs b/mcs/class/corlib/System.Reflection/MonoGenericClass.cs index 51a1a50522b..fdbea175ec9 100644 --- a/mcs/class/corlib/System.Reflection/MonoGenericClass.cs +++ b/mcs/class/corlib/System.Reflection/MonoGenericClass.cs @@ -57,7 +57,6 @@ namespace System.Reflection #pragma warning disable 649 internal Type generic_type; Type[] type_arguments; - bool initialized; #pragma warning restore 649 #endregion @@ -73,17 +72,6 @@ namespace System.Reflection { this.generic_type = tb; this.type_arguments = args; - /* - This is a temporary hack until we can fix the rest of the runtime - to properly handle this class to be a complete UT. - - We must not regisrer this with the runtime after the type is created - otherwise created_type.MakeGenericType will return an instance of MonoGenericClass, - which is very very broken. - */ - if (tb is TypeBuilder && !(tb as TypeBuilder).is_created) - register_with_runtime (this); - } internal override Type InternalResolve () @@ -95,11 +83,18 @@ namespace System.Reflection return gtd.MakeGenericType (args); } - [MethodImplAttribute(MethodImplOptions.InternalCall)] - extern void initialize (FieldInfo[] fields); - - [MethodImplAttribute(MethodImplOptions.InternalCall)] - internal static extern void register_with_runtime (Type type); + // Called from the runtime to return the corresponding finished Type object + internal override Type RuntimeResolve () + { + if (generic_type is TypeBuilder && !(generic_type as TypeBuilder).IsCreated ()) + AppDomain.CurrentDomain.DoTypeResolve (generic_type); + for (int i = 0; i < type_arguments.Length; ++i) { + var t = type_arguments [i]; + if (t is TypeBuilder && !(t as TypeBuilder).IsCreated ()) + AppDomain.CurrentDomain.DoTypeResolve (t); + } + return InternalResolve (); + } internal bool IsCreated { get { @@ -111,20 +106,6 @@ namespace System.Reflection private const BindingFlags flags = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.Instance | BindingFlags.DeclaredOnly; - void initialize () - { - if (initialized) - return; - - MonoGenericClass parent = GetParentType () as MonoGenericClass; - if (parent != null) - parent.initialize (); - - initialize (generic_type.GetFields (flags)); - - initialized = true; - } - Type GetParentType () { return InflateType (generic_type.BaseType); @@ -188,8 +169,6 @@ namespace System.Reflection internal override MethodInfo GetMethod (MethodInfo fromNoninstanciated) { - initialize (); - if (methods == null) methods = new Hashtable (); if (!methods.ContainsKey (fromNoninstanciated)) @@ -199,8 +178,6 @@ namespace System.Reflection internal override ConstructorInfo GetConstructor (ConstructorInfo fromNoninstanciated) { - initialize (); - if (ctors == null) ctors = new Hashtable (); if (!ctors.ContainsKey (fromNoninstanciated)) @@ -210,7 +187,6 @@ namespace System.Reflection internal override FieldInfo GetField (FieldInfo fromNoninstanciated) { - initialize (); if (fields == null) fields = new Hashtable (); if (!fields.ContainsKey (fromNoninstanciated)) diff --git a/mcs/class/corlib/System.Reflection/MonoGenericMethod.cs b/mcs/class/corlib/System.Reflection/MonoGenericMethod.cs deleted file mode 100644 index 48ef423cf4e..00000000000 --- a/mcs/class/corlib/System.Reflection/MonoGenericMethod.cs +++ /dev/null @@ -1,60 +0,0 @@ -// -// System.Reflection.MonoGenericMethod -// -// Martin Baulig (martin@ximian.com) -// -// (C) 2004 Novell, Inc. -// - -// -// Copyright (C) 2004 Novell, Inc (http://www.novell.com) -// -// Permission is hereby granted, free of charge, to any person obtaining -// a copy of this software and associated documentation files (the -// "Software"), to deal in the Software without restriction, including -// without limitation the rights to use, copy, modify, merge, publish, -// distribute, sublicense, and/or sell copies of the Software, and to -// permit persons to whom the Software is furnished to do so, subject to -// the following conditions: -// -// The above copyright notice and this permission notice shall be -// included in all copies or substantial portions of the Software. -// -// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, -// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF -// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND -// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE -// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION -// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION -// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. -// - -using System.Reflection; -using System.Runtime.CompilerServices; -using System.Runtime.InteropServices; - -namespace System.Reflection -{ - [Serializable] - [StructLayout (LayoutKind.Sequential)] - internal class MonoGenericMethod : MonoMethod - { - internal MonoGenericMethod () - { - // this should not be used - throw new InvalidOperationException (); - } - - } - - [Serializable] - [StructLayout (LayoutKind.Sequential)] - internal class MonoGenericCMethod : MonoCMethod - { - internal MonoGenericCMethod () - { - // this should not be used - throw new InvalidOperationException (); - } - } -} diff --git a/mcs/class/corlib/Test/System.Reflection.Emit/ModuleBuilderTest.cs b/mcs/class/corlib/Test/System.Reflection.Emit/ModuleBuilderTest.cs index 88ae954687a..7f5e1ee5000 100644 --- a/mcs/class/corlib/Test/System.Reflection.Emit/ModuleBuilderTest.cs +++ b/mcs/class/corlib/Test/System.Reflection.Emit/ModuleBuilderTest.cs @@ -506,6 +506,8 @@ namespace MonoTests.System.Reflection.Emit } [Test] + // The token is not guaranteed to be 0x0a000001 + [Category ("NotWorking")] public void ResolveFieldMemberRefWithGenericArguments () { var assembly = genAssembly (); @@ -533,6 +535,8 @@ namespace MonoTests.System.Reflection.Emit } [Test] + // The token is not guaranteed to be 0x0a000002 + [Category ("NotWorking")] public void ResolveMethodMemberRefWithGenericArguments () { var assembly = genAssembly (); @@ -566,6 +570,8 @@ namespace MonoTests.System.Reflection.Emit } [Test] + // The token is not guaranteed to be 0x2b000001 + [Category("NotWorking")] public void ResolveMethodSpecWithGenericArguments () { var assembly = genAssembly (); diff --git a/mcs/class/corlib/Test/System.Reflection.Emit/TypeBuilderTest.cs b/mcs/class/corlib/Test/System.Reflection.Emit/TypeBuilderTest.cs index 43f32cfa595..be5f2168b83 100644 --- a/mcs/class/corlib/Test/System.Reflection.Emit/TypeBuilderTest.cs +++ b/mcs/class/corlib/Test/System.Reflection.Emit/TypeBuilderTest.cs @@ -9748,6 +9748,33 @@ namespace MonoTests.System.Reflection.Emit //Console.WriteLine (res[0]); } + [Test] + public void FieldWithInitializedDataWorksWithCompilerRuntimeHelpers2 () + { + TypeBuilder tb = module.DefineType ("Type1", TypeAttributes.Public); + var garg = tb.DefineGenericParameters ("T") [0]; + FieldBuilder fb = tb.DefineInitializedData ("Foo", new byte [] {1,2,3,4}, FieldAttributes.Static|FieldAttributes.Public); + tb.CreateType (); + + assembly = Thread.GetDomain ().DefineDynamicAssembly (new AssemblyName (ASSEMBLY_NAME+"2"), AssemblyBuilderAccess.RunAndSave, Path.GetTempPath ()); + module = assembly.DefineDynamicModule ("Instance.exe"); + + TypeBuilder tb2 = module.DefineType ("Type2", TypeAttributes.Public); + MethodBuilder mb = tb2.DefineMethod ("Test", MethodAttributes.Public | MethodAttributes.Static, typeof (object), new Type [0]); + ILGenerator il = mb.GetILGenerator (); + + il.Emit (OpCodes.Ldc_I4_1); + il.Emit (OpCodes.Newarr, typeof (int)); + il.Emit (OpCodes.Dup); + il.Emit (OpCodes.Ldtoken, fb); + il.Emit (OpCodes.Call, typeof (RuntimeHelpers).GetMethod ("InitializeArray")); + il.Emit (OpCodes.Ret); + + Type t = tb2.CreateType (); + int[] res = (int[])t.GetMethod ("Test").Invoke (null, new object[0]); + //Console.WriteLine (res[0]); + } + public interface IDelegateFactory { Delegate Create (Delegate del); diff --git a/mcs/class/corlib/corlib-net_4_x.csproj b/mcs/class/corlib/corlib-net_4_x.csproj index 95f0db7329c..80bce2dd720 100644 --- a/mcs/class/corlib/corlib-net_4_x.csproj +++ b/mcs/class/corlib/corlib-net_4_x.csproj @@ -982,7 +982,6 @@ - diff --git a/mcs/class/corlib/corlib.dll.sources b/mcs/class/corlib/corlib.dll.sources index 3716291a268..4eca0acc743 100644 --- a/mcs/class/corlib/corlib.dll.sources +++ b/mcs/class/corlib/corlib.dll.sources @@ -246,7 +246,6 @@ System.Reflection/Module.cs System.Reflection/ModuleResolveEventHandler.cs System.Reflection/MonoAssembly.cs System.Reflection/MonoGenericClass.cs -System.Reflection/MonoGenericMethod.cs System.Reflection/MonoEvent.cs System.Reflection/MonoField.cs System.Reflection/MonoMethod.cs diff --git a/mcs/tools/linker/Descriptors/mscorlib.xml b/mcs/tools/linker/Descriptors/mscorlib.xml index 396acc5a69e..31764d0efac 100644 --- a/mcs/tools/linker/Descriptors/mscorlib.xml +++ b/mcs/tools/linker/Descriptors/mscorlib.xml @@ -219,8 +219,6 @@ - - @@ -262,6 +260,7 @@ + diff --git a/mono/metadata/custom-attrs.c b/mono/metadata/custom-attrs.c index a1d48eb3d44..d76c0376adc 100644 --- a/mono/metadata/custom-attrs.c +++ b/mono/metadata/custom-attrs.c @@ -1545,10 +1545,6 @@ mono_reflection_get_custom_attrs_info_checked (MonoObject *obj, MonoError *error MonoReflectionMethod *rmethod = (MonoReflectionMethod*)obj; cinfo = mono_custom_attrs_from_method_checked (rmethod->method, error); return_val_if_nok (error, NULL); - } else if ((strcmp ("MonoGenericMethod", klass->name) == 0) || (strcmp ("MonoGenericCMethod", klass->name) == 0)) { - MonoReflectionMethod *rmethod = (MonoReflectionMethod*)obj; - cinfo = mono_custom_attrs_from_method_checked (rmethod->method, error); - return_val_if_nok (error, NULL); } else if (strcmp ("ParameterInfo", klass->name) == 0 || strcmp ("MonoParameterInfo", klass->name) == 0) { MonoReflectionParameter *param = (MonoReflectionParameter*)obj; MonoClass *member_class = mono_object_class (param->MemberImpl); @@ -1568,22 +1564,11 @@ mono_reflection_get_custom_attrs_info_checked (MonoObject *obj, MonoError *error } #ifndef DISABLE_REFLECTION_EMIT else if (mono_is_sre_method_on_tb_inst (member_class)) {/*XXX This is a workaround for Compiler Context*/ - MonoMethod *method = mono_reflection_method_on_tb_inst_get_handle ((MonoReflectionMethodOnTypeBuilderInst*)param->MemberImpl, error); - return_val_if_nok (error, NULL); - cinfo = mono_custom_attrs_from_param_checked (method, param->PositionImpl + 1, error); - return_val_if_nok (error, NULL); + // FIXME: Is this still needed ? + g_assert_not_reached (); } else if (mono_is_sre_ctor_on_tb_inst (member_class)) { /*XX This is a workaround for Compiler Context*/ - MonoReflectionCtorOnTypeBuilderInst *c = (MonoReflectionCtorOnTypeBuilderInst*)param->MemberImpl; - MonoMethod *method = NULL; - if (mono_is_sre_ctor_builder (mono_object_class (c->cb))) - method = ((MonoReflectionCtorBuilder *)c->cb)->mhandle; - else if (mono_is_sr_mono_cmethod (mono_object_class (c->cb))) - method = ((MonoReflectionMethod *)c->cb)->method; - else - g_error ("mono_reflection_get_custom_attrs_info:: can't handle a CTBI with base_method of type %s", mono_type_get_full_name (member_class)); - - cinfo = mono_custom_attrs_from_param_checked (method, param->PositionImpl + 1, error); - return_val_if_nok (error, NULL); + // FIXME: Is this still needed ? + g_assert_not_reached (); } #endif else { diff --git a/mono/metadata/icall-def.h b/mono/metadata/icall-def.h index 507c67244a7..5ef925009ac 100644 --- a/mono/metadata/icall-def.h +++ b/mono/metadata/icall-def.h @@ -545,7 +545,7 @@ ICALL_TYPE(ENUMB, "System.Reflection.Emit.EnumBuilder", ENUMB_1) ICALL(ENUMB_1, "setup_enum_type", ves_icall_EnumBuilder_setup_enum_type) ICALL_TYPE(GPARB, "System.Reflection.Emit.GenericTypeParameterBuilder", GPARB_1) -ICALL(GPARB_1, "initialize", ves_icall_GenericTypeParameterBuilder_initialize_generic_parameter) +ICALL(GPARB_1, "initialize", ves_icall_GenericTypeParameterBuilder_initialize) ICALL_TYPE(METHODB, "System.Reflection.Emit.MethodBuilder", METHODB_1) ICALL(METHODB_1, "MakeGenericMethod", ves_icall_MethodBuilder_MakeGenericMethod) @@ -565,16 +565,9 @@ ICALL_TYPE(SIGH, "System.Reflection.Emit.SignatureHelper", SIGH_1) ICALL(SIGH_1, "get_signature_field", ves_icall_SignatureHelper_get_signature_field) ICALL(SIGH_2, "get_signature_local", ves_icall_SignatureHelper_get_signature_local) -#ifndef DISABLE_REFLECTION_EMIT -ICALL_TYPE(SYMBOLTYPE, "System.Reflection.Emit.SymbolType", SYMBOLTYPE_1) -ICALL(SYMBOLTYPE_1, "create_unmanaged_type", ves_icall_SymbolType_create_unmanaged_type) -#endif - ICALL_TYPE(TYPEB, "System.Reflection.Emit.TypeBuilder", TYPEB_1) ICALL(TYPEB_1, "create_generic_class", ves_icall_TypeBuilder_create_generic_class) ICALL(TYPEB_3, "create_runtime_class", ves_icall_TypeBuilder_create_runtime_class) -ICALL(TYPEB_4, "get_IsGenericParameter", ves_icall_TypeBuilder_get_IsGenericParameter) -ICALL(TYPEB_5, "get_event_info", ves_icall_TypeBuilder_get_event_info) ICALL(TYPEB_7, "setup_internal_class", ves_icall_TypeBuilder_setup_internal_class) ICALL_TYPE(EVENTI, "System.Reflection.EventInfo", EVENTI_1) @@ -626,10 +619,6 @@ ICALL(MFIELD_6, "ResolveType", ves_icall_MonoField_ResolveType) ICALL(MFIELD_4, "SetValueInternal", ves_icall_MonoField_SetValueInternal) ICALL(MFIELD_7, "get_core_clr_security_level", ves_icall_MonoField_get_core_clr_security_level) -ICALL_TYPE(MGENCL, "System.Reflection.MonoGenericClass", MGENCL_5) -ICALL(MGENCL_5, "initialize", mono_reflection_generic_class_initialize) -ICALL(MGENCL_6, "register_with_runtime", mono_reflection_register_with_runtime) - ICALL_TYPE(MMETH, "System.Reflection.MonoMethod", MMETH_2) ICALL(MMETH_2, "GetGenericArguments", ves_icall_MonoMethod_GetGenericArguments) ICALL(MMETH_3, "GetGenericMethodDefinition_impl", ves_icall_MonoMethod_GetGenericMethodDefinition) diff --git a/mono/metadata/object-internals.h b/mono/metadata/object-internals.h index d643b57206a..83257bda806 100644 --- a/mono/metadata/object-internals.h +++ b/mono/metadata/object-internals.h @@ -1185,7 +1185,6 @@ struct _MonoReflectionGenericClass { MonoReflectionType type; MonoReflectionType *generic_type; /*Can be either a MonoType or a TypeBuilder*/ MonoArray *type_arguments; - guint32 initialized; }; typedef struct { @@ -1282,26 +1281,6 @@ typedef struct { MonoArray *modopts; } MonoReflectionSigHelper; -typedef struct { - MonoObject object; - MonoReflectionGenericClass *inst; - MonoObject *fb; /*can be either a MonoField or a FieldBuilder*/ -} MonoReflectionFieldOnTypeBuilderInst; - -typedef struct { - MonoObject object; - MonoReflectionGenericClass *inst; - MonoObject *cb; /*can be either a MonoCMethod or ConstructorBuilder*/ -} MonoReflectionCtorOnTypeBuilderInst; - -typedef struct { - MonoObject object; - MonoReflectionType *inst; - MonoObject *mb; /*can be either a MonoMethod or MethodBuilder*/ - MonoArray *method_args; - MonoReflectionMethodBuilder *generic_method_definition; -} MonoReflectionMethodOnTypeBuilderInst; - typedef struct { MonoObject object; MonoBoolean visible; @@ -1811,7 +1790,7 @@ void ves_icall_ModuleBuilder_set_wrappers_type (MonoReflectionModuleBuilder *moduleb, MonoReflectionType *type); void -ves_icall_GenericTypeParameterBuilder_initialize_generic_parameter (MonoReflectionGenericParam *gparam); +ves_icall_GenericTypeParameterBuilder_initialize (MonoReflectionGenericParam *gparam); MonoReflectionMethod* ves_icall_MethodBuilder_MakeGenericMethod (MonoReflectionMethod *rmethod, MonoArray *types); diff --git a/mono/metadata/reflection.c b/mono/metadata/reflection.c index 0a5ea615a03..45d1cd830a8 100644 --- a/mono/metadata/reflection.c +++ b/mono/metadata/reflection.c @@ -53,8 +53,6 @@ static MonoType* mono_reflection_get_type_with_rootimage (MonoImage *rootimage, /* Class lazy loading functions */ static GENERATE_GET_CLASS_WITH_CACHE (mono_assembly, System.Reflection, MonoAssembly) static GENERATE_GET_CLASS_WITH_CACHE (mono_module, System.Reflection, MonoModule) -static GENERATE_GET_CLASS_WITH_CACHE (mono_generic_method, System.Reflection, MonoGenericMethod); -static GENERATE_GET_CLASS_WITH_CACHE (mono_generic_cmethod, System.Reflection, MonoGenericCMethod); static GENERATE_GET_CLASS_WITH_CACHE (mono_method, System.Reflection, MonoMethod); static GENERATE_GET_CLASS_WITH_CACHE (mono_cmethod, System.Reflection, MonoCMethod); static GENERATE_GET_CLASS_WITH_CACHE (mono_field, System.Reflection, MonoField); @@ -575,33 +573,6 @@ mono_method_get_object_checked (MonoDomain *domain, MonoMethod *method, MonoClas mono_error_init (error); - if (method->is_inflated) { - MonoReflectionGenericMethod *gret; - - if (!refclass) - refclass = method->klass; - CHECK_OBJECT (MonoReflectionMethod *, method, refclass); - if ((*method->name == '.') && (!strcmp (method->name, ".ctor") || !strcmp (method->name, ".cctor"))) { - klass = mono_class_get_mono_generic_cmethod_class (); - } else { - klass = mono_class_get_mono_generic_method_class (); - } - gret = (MonoReflectionGenericMethod*)mono_object_new_checked (domain, klass, error); - if (!mono_error_ok (error)) - goto leave; - gret->method.method = method; - - MONO_OBJECT_SETREF (gret, method.name, mono_string_new (domain, method->name)); - - rt = mono_type_get_object_checked (domain, &refclass->byval_arg, error); - if (!mono_error_ok (error)) - goto leave; - - MONO_OBJECT_SETREF (gret, method.reftype, rt); - - CACHE_OBJECT (MonoReflectionMethod *, method, (MonoReflectionMethod*)gret, refclass); - } - if (!refclass) refclass = method->klass; @@ -2149,9 +2120,7 @@ mono_reflection_get_token_checked (MonoObject *obj, MonoError *error) token = mc->type_token; } else if (strcmp (klass->name, "MonoCMethod") == 0 || - strcmp (klass->name, "MonoMethod") == 0 || - strcmp (klass->name, "MonoGenericMethod") == 0 || - strcmp (klass->name, "MonoGenericCMethod") == 0) { + strcmp (klass->name, "MonoMethod") == 0) { MonoReflectionMethod *m = (MonoReflectionMethod *)obj; if (m->method->is_inflated) { MonoMethodInflated *inflated = (MonoMethodInflated *) m->method; diff --git a/mono/metadata/sre-internals.h b/mono/metadata/sre-internals.h index 87d823a22e0..e1564e5350d 100644 --- a/mono/metadata/sre-internals.h +++ b/mono/metadata/sre-internals.h @@ -80,9 +80,6 @@ mono_reflection_create_generic_class (MonoReflectionTypeBuilder *tb, MonoError * MonoMethod* mono_reflection_method_builder_to_mono_method (MonoReflectionMethodBuilder *mb, MonoError *error); -MonoMethod* -mono_reflection_method_on_tb_inst_get_handle (MonoReflectionMethodOnTypeBuilderInst *m, MonoError *error); - gpointer mono_reflection_resolve_object (MonoImage *image, MonoObject *obj, MonoClass **handle_class, MonoGenericContext *context, MonoError *error); diff --git a/mono/metadata/sre-save.c b/mono/metadata/sre-save.c index ff2f93a767b..38cd13f0cc7 100644 --- a/mono/metadata/sre-save.c +++ b/mono/metadata/sre-save.c @@ -1691,9 +1691,6 @@ fixup_method (MonoReflectionILGen *ilgen, gpointer value, MonoDynamicImage *asse { guint32 code_idx = GPOINTER_TO_UINT (value); MonoReflectionILTokenInfo *iltoken; - MonoReflectionFieldBuilder *field; - MonoReflectionCtorBuilder *ctor; - MonoReflectionMethodBuilder *method; MonoReflectionTypeBuilder *tb; MonoReflectionArrayMethod *am; guint32 i, idx = 0; @@ -1705,8 +1702,7 @@ fixup_method (MonoReflectionILGen *ilgen, gpointer value, MonoDynamicImage *asse switch (target [3]) { case MONO_TABLE_FIELD: if (!strcmp (iltoken->member->vtable->klass->name, "FieldBuilder")) { - field = (MonoReflectionFieldBuilder *)iltoken->member; - idx = field->table_idx; + g_assert_not_reached (); } else if (!strcmp (iltoken->member->vtable->klass->name, "MonoField")) { MonoClassField *f = ((MonoReflectionField*)iltoken->member)->field; idx = GPOINTER_TO_UINT (g_hash_table_lookup (assembly->field_to_table_idx, f)); @@ -1716,11 +1712,9 @@ fixup_method (MonoReflectionILGen *ilgen, gpointer value, MonoDynamicImage *asse break; case MONO_TABLE_METHOD: if (!strcmp (iltoken->member->vtable->klass->name, "MethodBuilder")) { - method = (MonoReflectionMethodBuilder *)iltoken->member; - idx = method->table_idx; + g_assert_not_reached (); } else if (!strcmp (iltoken->member->vtable->klass->name, "ConstructorBuilder")) { - ctor = (MonoReflectionCtorBuilder *)iltoken->member; - idx = ctor->table_idx; + g_assert_not_reached (); } else if (!strcmp (iltoken->member->vtable->klass->name, "MonoMethod") || !strcmp (iltoken->member->vtable->klass->name, "MonoCMethod")) { MonoMethod *m = ((MonoReflectionMethod*)iltoken->member)->method; @@ -1730,47 +1724,67 @@ fixup_method (MonoReflectionILGen *ilgen, gpointer value, MonoDynamicImage *asse } break; case MONO_TABLE_TYPEDEF: - if (strcmp (iltoken->member->vtable->klass->name, "TypeBuilder")) + if (!strcmp (iltoken->member->vtable->klass->name, "TypeBuilder")) { + g_assert_not_reached (); + } else if (!strcmp (iltoken->member->vtable->klass->name, "RuntimeType")) { + MonoClass *k = mono_class_from_mono_type (((MonoReflectionType*)iltoken->member)->type); + MonoObject *obj = mono_class_get_ref_info (k); + g_assert (obj); + g_assert (!strcmp (obj->vtable->klass->name, "TypeBuilder")); + tb = (MonoReflectionTypeBuilder*)obj; + idx = tb->table_idx; + } else { g_assert_not_reached (); - tb = (MonoReflectionTypeBuilder *)iltoken->member; - idx = tb->table_idx; + } break; case MONO_TABLE_MEMBERREF: if (!strcmp (iltoken->member->vtable->klass->name, "MonoArrayMethod")) { am = (MonoReflectionArrayMethod*)iltoken->member; idx = am->table_idx; } else if (!strcmp (iltoken->member->vtable->klass->name, "MonoMethod") || - !strcmp (iltoken->member->vtable->klass->name, "MonoCMethod") || - !strcmp (iltoken->member->vtable->klass->name, "MonoGenericMethod") || - !strcmp (iltoken->member->vtable->klass->name, "MonoGenericCMethod")) { + !strcmp (iltoken->member->vtable->klass->name, "MonoCMethod")) { MonoMethod *m = ((MonoReflectionMethod*)iltoken->member)->method; g_assert (m->klass->generic_class || m->klass->generic_container); continue; } else if (!strcmp (iltoken->member->vtable->klass->name, "FieldBuilder")) { + g_assert_not_reached (); continue; } else if (!strcmp (iltoken->member->vtable->klass->name, "MonoField")) { continue; } else if (!strcmp (iltoken->member->vtable->klass->name, "MethodBuilder") || !strcmp (iltoken->member->vtable->klass->name, "ConstructorBuilder")) { + g_assert_not_reached (); continue; } else if (!strcmp (iltoken->member->vtable->klass->name, "FieldOnTypeBuilderInst")) { + g_assert_not_reached (); continue; } else if (!strcmp (iltoken->member->vtable->klass->name, "MethodOnTypeBuilderInst")) { + g_assert_not_reached (); continue; } else if (!strcmp (iltoken->member->vtable->klass->name, "ConstructorOnTypeBuilderInst")) { + g_assert_not_reached (); continue; } else { g_assert_not_reached (); } break; case MONO_TABLE_METHODSPEC: - if (!strcmp (iltoken->member->vtable->klass->name, "MonoGenericMethod")) { + if (!strcmp (iltoken->member->vtable->klass->name, "MonoMethod")) { MonoMethod *m = ((MonoReflectionMethod*)iltoken->member)->method; g_assert (mono_method_signature (m)->generic_param_count); continue; } else if (!strcmp (iltoken->member->vtable->klass->name, "MethodBuilder")) { + g_assert_not_reached (); continue; } else if (!strcmp (iltoken->member->vtable->klass->name, "MethodOnTypeBuilderInst")) { + g_assert_not_reached (); + continue; + } else { + g_assert_not_reached (); + } + break; + case MONO_TABLE_TYPESPEC: + if (!strcmp (iltoken->member->vtable->klass->name, "RuntimeType")) { continue; } else { g_assert_not_reached (); diff --git a/mono/metadata/sre.c b/mono/metadata/sre.c index 6e800f39139..947f9a416fb 100644 --- a/mono/metadata/sre.c +++ b/mono/metadata/sre.c @@ -43,11 +43,10 @@ mono_sre_generic_param_table_entry_free (GenericParamTableEntry *entry) } static GENERATE_GET_CLASS_WITH_CACHE (marshal_as_attribute, System.Runtime.InteropServices, MarshalAsAttribute); +static GENERATE_GET_CLASS_WITH_CACHE (module_builder, System.Reflection.Emit, ModuleBuilder); #ifndef DISABLE_REFLECTION_EMIT static guint32 mono_image_get_methodref_token (MonoDynamicImage *assembly, MonoMethod *method, gboolean create_typespec); -static guint32 mono_image_get_methodbuilder_token (MonoDynamicImage *assembly, MonoReflectionMethodBuilder *mb, gboolean create_open_instance, MonoError *error); -static guint32 mono_image_get_ctorbuilder_token (MonoDynamicImage *assembly, MonoReflectionCtorBuilder *cb, MonoError *error); static guint32 mono_image_get_sighelper_token (MonoDynamicImage *assembly, MonoReflectionSigHelper *helper, MonoError *error); static gboolean ensure_runtime_vtable (MonoClass *klass, MonoError *error); static guint32 mono_image_get_methodref_token_for_methodbuilder (MonoDynamicImage *assembly, MonoReflectionMethodBuilder *method, MonoError *error); @@ -61,17 +60,16 @@ static MonoReflectionType *mono_reflection_type_get_underlying_system_type (Mono static gboolean is_sre_array (MonoClass *klass); static gboolean is_sre_byref (MonoClass *klass); static gboolean is_sre_pointer (MonoClass *klass); +static gboolean is_sre_generic_instance (MonoClass *klass); static gboolean is_sre_type_builder (MonoClass *klass); static gboolean is_sre_method_builder (MonoClass *klass); static gboolean is_sre_field_builder (MonoClass *klass); +static gboolean is_sre_gparam_builder (MonoClass *klass); static gboolean is_sr_mono_method (MonoClass *klass); -static gboolean is_sr_mono_generic_method (MonoClass *klass); -static gboolean is_sr_mono_generic_cmethod (MonoClass *klass); static gboolean is_sr_mono_field (MonoClass *klass); static guint32 mono_image_get_methodspec_token (MonoDynamicImage *assembly, MonoMethod *method); static guint32 mono_image_get_inflated_method_token (MonoDynamicImage *assembly, MonoMethod *m); -static MonoMethod * inflate_method (MonoReflectionType *type, MonoObject *obj, MonoError *error); #define mono_type_array_get_and_resolve(array, index, error) mono_reflection_type_get_handle ((MonoReflectionType*)mono_array_get (array, gpointer, index), error) @@ -796,65 +794,6 @@ mono_image_get_methodspec_token_for_generic_method_definition (MonoDynamicImage mono_g_hash_table_insert (assembly->methodspec, mb, GUINT_TO_POINTER(token)); return token; } - -static guint32 -mono_image_get_methodbuilder_token (MonoDynamicImage *assembly, MonoReflectionMethodBuilder *mb, gboolean create_methodspec, MonoError *error) -{ - guint32 token; - - mono_error_init (error); - - if (mb->generic_params && create_methodspec) - return mono_image_get_methodspec_token_for_generic_method_definition (assembly, mb, error); - - token = GPOINTER_TO_UINT (mono_g_hash_table_lookup (assembly->handleref_managed, mb)); - if (token) - return token; - - token = mono_image_get_methodref_token_for_methodbuilder (assembly, mb, error); - if (!mono_error_ok (error)) - return 0; - mono_g_hash_table_insert (assembly->handleref_managed, mb, GUINT_TO_POINTER(token)); - return token; -} - -static guint32 -mono_image_get_ctorbuilder_token (MonoDynamicImage *assembly, MonoReflectionCtorBuilder *mb, MonoError *error) -{ - guint32 token, parent, sig; - ReflectionMethodBuilder rmb; - char *name; - MonoReflectionTypeBuilder *tb = (MonoReflectionTypeBuilder *)mb->type; - - mono_error_init (error); - - token = GPOINTER_TO_UINT (mono_g_hash_table_lookup (assembly->handleref_managed, mb)); - if (token) - return token; - - if (!mono_reflection_methodbuilder_from_ctor_builder (&rmb, mb, error)) - return 0; - - if (tb->generic_params) { - parent = mono_dynimage_encode_generic_typespec (assembly, tb, error); - return_val_if_nok (error, 0); - } else { - MonoType * type = mono_reflection_type_get_handle ((MonoReflectionType*)tb, error); - return_val_if_nok (error, 0); - parent = mono_image_typedef_or_ref (assembly, type); - } - - name = mono_string_to_utf8_checked (rmb.name, error); - return_val_if_nok (error, 0); - sig = mono_dynimage_encode_method_builder_signature (assembly, &rmb, error); - return_val_if_nok (error, 0); - - token = mono_image_add_memberef_row (assembly, parent, name, sig); - - g_free (name); - mono_g_hash_table_insert (assembly->handleref_managed, mb, GUINT_TO_POINTER(token)); - return token; -} #endif static gboolean @@ -890,221 +829,6 @@ mono_image_get_fieldref_token (MonoDynamicImage *assembly, MonoObject *f, MonoCl return token; } -static guint32 -mono_image_get_field_on_inst_token (MonoDynamicImage *assembly, MonoReflectionFieldOnTypeBuilderInst *f, MonoError *error) -{ - guint32 token; - MonoClass *klass; - MonoGenericClass *gclass; - MonoType *type; - char *name; - - token = GPOINTER_TO_UINT (mono_g_hash_table_lookup (assembly->handleref_managed, f)); - if (token) - return token; - if (is_sre_field_builder (mono_object_class (f->fb))) { - MonoReflectionFieldBuilder *fb = (MonoReflectionFieldBuilder *)f->fb; - type = mono_reflection_type_get_handle ((MonoReflectionType*)f->inst, error); - return_val_if_nok (error, 0); - klass = mono_class_from_mono_type (type); - gclass = type->data.generic_class; - g_assert (gclass->is_dynamic); - - guint32 sig_token = mono_dynimage_encode_field_signature (assembly, fb, error); - return_val_if_nok (error, 0); - name = mono_string_to_utf8_checked (fb->name, error); - return_val_if_nok (error, 0); - token = mono_image_get_memberref_token (assembly, &klass->byval_arg, name, sig_token); - g_free (name); - } else if (is_sr_mono_field (mono_object_class (f->fb))) { - guint32 sig; - MonoClassField *field = ((MonoReflectionField *)f->fb)->field; - - type = mono_reflection_type_get_handle ((MonoReflectionType*)f->inst, error); - return_val_if_nok (error, 0); - klass = mono_class_from_mono_type (type); - - sig = mono_dynimage_encode_fieldref_signature (assembly, field->parent->image, field->type); - token = mono_image_get_memberref_token (assembly, &klass->byval_arg, field->name, sig); - } else { - char *name = mono_type_get_full_name (mono_object_class (f->fb)); - g_error ("mono_image_get_field_on_inst_token: don't know how to handle %s", name); - } - - mono_g_hash_table_insert (assembly->handleref_managed, f, GUINT_TO_POINTER (token)); - return token; -} - -static guint32 -mono_image_get_ctor_on_inst_token (MonoDynamicImage *assembly, MonoReflectionCtorOnTypeBuilderInst *c, gboolean create_methodspec, MonoError *error) -{ - guint32 sig, token; - MonoClass *klass; - MonoGenericClass *gclass; - MonoType *type; - - mono_error_init (error); - - /* A ctor cannot be a generic method, so we can ignore create_methodspec */ - - token = GPOINTER_TO_UINT (mono_g_hash_table_lookup (assembly->handleref_managed, c)); - if (token) - return token; - - if (mono_is_sre_ctor_builder (mono_object_class (c->cb))) { - MonoReflectionCtorBuilder *cb = (MonoReflectionCtorBuilder *)c->cb; - ReflectionMethodBuilder rmb; - char *name; - - type = mono_reflection_type_get_handle ((MonoReflectionType*)c->inst, error); - return_val_if_nok (error, 0); - klass = mono_class_from_mono_type (type); - - gclass = type->data.generic_class; - g_assert (gclass->is_dynamic); - - if (!mono_reflection_methodbuilder_from_ctor_builder (&rmb, cb, error)) - return 0; - - sig = mono_dynimage_encode_method_builder_signature (assembly, &rmb, error); - return_val_if_nok (error, 0); - - name = mono_string_to_utf8_checked (rmb.name, error); - return_val_if_nok (error, 0); - - token = mono_image_get_memberref_token (assembly, &klass->byval_arg, name, sig); - g_free (name); - } else if (mono_is_sr_mono_cmethod (mono_object_class (c->cb))) { - MonoMethod *mm = ((MonoReflectionMethod *)c->cb)->method; - - type = mono_reflection_type_get_handle ((MonoReflectionType*)c->inst, error); - return_val_if_nok (error, 0); - klass = mono_class_from_mono_type (type); - - sig = mono_dynimage_encode_method_signature (assembly, mono_method_signature (mm)); - token = mono_image_get_memberref_token (assembly, &klass->byval_arg, mm->name, sig); - } else { - char *name = mono_type_get_full_name (mono_object_class (c->cb)); - g_error ("mono_image_get_method_on_inst_token: don't know how to handle %s", name); - } - - - mono_g_hash_table_insert (assembly->handleref_managed, c, GUINT_TO_POINTER (token)); - return token; -} - -MonoMethod* -mono_reflection_method_on_tb_inst_get_handle (MonoReflectionMethodOnTypeBuilderInst *m, MonoError *error) -{ - MonoClass *klass; - MonoGenericContext tmp_context; - MonoType **type_argv; - MonoGenericInst *ginst; - MonoMethod *method, *inflated; - int count, i; - - mono_error_init (error); - - mono_reflection_init_type_builder_generics ((MonoObject*)m->inst, error); - return_val_if_nok (error, NULL); - - method = inflate_method (m->inst, (MonoObject*)m->mb, error); - return_val_if_nok (error, NULL); - - klass = method->klass; - - if (m->method_args == NULL) - return method; - - if (method->is_inflated) - method = ((MonoMethodInflated *) method)->declaring; - - count = mono_array_length (m->method_args); - - type_argv = g_new0 (MonoType *, count); - for (i = 0; i < count; i++) { - MonoReflectionType *garg = (MonoReflectionType *)mono_array_get (m->method_args, gpointer, i); - type_argv [i] = mono_reflection_type_get_handle (garg, error); - return_val_if_nok (error, NULL); - } - ginst = mono_metadata_get_generic_inst (count, type_argv); - g_free (type_argv); - - tmp_context.class_inst = klass->generic_class ? klass->generic_class->context.class_inst : NULL; - tmp_context.method_inst = ginst; - - inflated = mono_class_inflate_generic_method_checked (method, &tmp_context, error); - mono_error_assert_ok (error); - return inflated; -} - -static guint32 -mono_image_get_method_on_inst_token (MonoDynamicImage *assembly, MonoReflectionMethodOnTypeBuilderInst *m, gboolean create_methodspec, MonoError *error) -{ - guint32 sig, token = 0; - MonoType *type; - MonoClass *klass; - - mono_error_init (error); - - if (m->method_args) { - MonoMethod *inflated; - - inflated = mono_reflection_method_on_tb_inst_get_handle (m, error); - return_val_if_nok (error, 0); - - if (create_methodspec) - token = mono_image_get_methodspec_token (assembly, inflated); - else - token = mono_image_get_inflated_method_token (assembly, inflated); - return token; - } - - token = GPOINTER_TO_UINT (mono_g_hash_table_lookup (assembly->handleref_managed, m)); - if (token) - return token; - - if (is_sre_method_builder (mono_object_class (m->mb))) { - MonoReflectionMethodBuilder *mb = (MonoReflectionMethodBuilder *)m->mb; - MonoGenericClass *gclass; - ReflectionMethodBuilder rmb; - char *name; - - type = mono_reflection_type_get_handle ((MonoReflectionType*)m->inst, error); - return_val_if_nok (error, 0); - klass = mono_class_from_mono_type (type); - gclass = type->data.generic_class; - g_assert (gclass->is_dynamic); - - if (!mono_reflection_methodbuilder_from_method_builder (&rmb, mb, error)) - return 0; - - sig = mono_dynimage_encode_method_builder_signature (assembly, &rmb, error); - return_val_if_nok (error, 0); - - name = mono_string_to_utf8_checked (rmb.name, error); - return_val_if_nok (error, 0); - - token = mono_image_get_memberref_token (assembly, &klass->byval_arg, name, sig); - g_free (name); - } else if (is_sr_mono_method (mono_object_class (m->mb))) { - MonoMethod *mm = ((MonoReflectionMethod *)m->mb)->method; - - type = mono_reflection_type_get_handle ((MonoReflectionType*)m->inst, error); - return_val_if_nok (error, 0); - klass = mono_class_from_mono_type (type); - - sig = mono_dynimage_encode_method_signature (assembly, mono_method_signature (mm)); - token = mono_image_get_memberref_token (assembly, &klass->byval_arg, mm->name, sig); - } else { - char *name = mono_type_get_full_name (mono_object_class (m->mb)); - g_error ("mono_image_get_method_on_inst_token: don't know how to handle %s", name); - } - - mono_g_hash_table_insert (assembly->handleref_managed, m, GUINT_TO_POINTER (token)); - return token; -} - static guint32 method_encode_methodspec (MonoDynamicImage *assembly, MonoMethod *method) { @@ -1191,59 +915,6 @@ mono_image_get_inflated_method_token (MonoDynamicImage *assembly, MonoMethod *m) return token; } -/* - * Return a copy of TYPE, adding the custom modifiers in MODREQ and MODOPT. - */ -static MonoType* -add_custom_modifiers (MonoDynamicImage *assembly, MonoType *type, MonoArray *modreq, MonoArray *modopt, MonoError *error) -{ - int i, count, len, pos; - MonoType *t; - - mono_error_init (error); - - count = 0; - if (modreq) - count += mono_array_length (modreq); - if (modopt) - count += mono_array_length (modopt); - - if (count == 0) - return mono_metadata_type_dup (NULL, type); - - len = MONO_SIZEOF_TYPE + ((gint32)count) * sizeof (MonoCustomMod); - t = (MonoType *)g_malloc (len); - memcpy (t, type, MONO_SIZEOF_TYPE); - - t->num_mods = count; - pos = 0; - if (modreq) { - for (i = 0; i < mono_array_length (modreq); ++i) { - MonoType *mod = mono_type_array_get_and_resolve (modreq, i, error); - if (!is_ok (error)) - goto fail; - t->modifiers [pos].required = 1; - t->modifiers [pos].token = mono_image_typedef_or_ref (assembly, mod); - pos ++; - } - } - if (modopt) { - for (i = 0; i < mono_array_length (modopt); ++i) { - MonoType *mod = mono_type_array_get_and_resolve (modopt, i, error); - if (!is_ok (error)) - goto fail; - t->modifiers [pos].required = 0; - t->modifiers [pos].token = mono_image_typedef_or_ref (assembly, mod); - pos ++; - } - } - - return t; -fail: - g_free (t); - return NULL; -} - void mono_reflection_init_type_builder_generics (MonoObject *type, MonoError *error) { @@ -1259,70 +930,6 @@ mono_reflection_init_type_builder_generics (MonoObject *type, MonoError *error) mono_reflection_create_generic_class (tb, error); } -static guint32 -mono_image_get_generic_field_token (MonoDynamicImage *assembly, MonoReflectionFieldBuilder *fb, MonoError *error) -{ - MonoDynamicTable *table; - MonoType *custom = NULL, *type; - guint32 *values; - guint32 token, pclass, parent, sig; - gchar *name; - - mono_error_init (error); - - token = GPOINTER_TO_UINT (mono_g_hash_table_lookup (assembly->handleref_managed, fb)); - if (token) - return token; - - MonoType *typeb = mono_reflection_type_get_handle (fb->typeb, error); - return_val_if_nok (error, 0); - /* FIXME: is this call necessary? */ - mono_class_from_mono_type (typeb); - - /*FIXME this is one more layer of ugliness due how types are created.*/ - mono_reflection_init_type_builder_generics (fb->type, error); - return_val_if_nok (error, 0); - - /* fb->type does not include the custom modifiers */ - /* FIXME: We should do this in one place when a fieldbuilder is created */ - type = mono_reflection_type_get_handle ((MonoReflectionType*)fb->type, error); - return_val_if_nok (error, 0); - - if (fb->modreq || fb->modopt) { - type = custom = add_custom_modifiers (assembly, type, fb->modreq, fb->modopt, error); - return_val_if_nok (error, 0); - } - - sig = mono_dynimage_encode_fieldref_signature (assembly, NULL, type); - g_free (custom); - - parent = mono_dynimage_encode_generic_typespec (assembly, (MonoReflectionTypeBuilder *) fb->typeb, error); - return_val_if_nok (error, 0); - g_assert ((parent & MONO_TYPEDEFORREF_MASK) == MONO_TYPEDEFORREF_TYPESPEC); - - pclass = MONO_MEMBERREF_PARENT_TYPESPEC; - parent >>= MONO_TYPEDEFORREF_BITS; - - table = &assembly->tables [MONO_TABLE_MEMBERREF]; - - name = mono_string_to_utf8_checked (fb->name, error); - return_val_if_nok (error, 0); - - if (assembly->save) { - alloc_table (table, table->rows + 1); - values = table->values + table->next_idx * MONO_MEMBERREF_SIZE; - values [MONO_MEMBERREF_CLASS] = pclass | (parent << MONO_MEMBERREF_PARENT_BITS); - values [MONO_MEMBERREF_NAME] = string_heap_insert (&assembly->sheap, name); - values [MONO_MEMBERREF_SIGNATURE] = sig; - } - - token = MONO_TOKEN_MEMBER_REF | table->next_idx; - table->next_idx ++; - mono_g_hash_table_insert (assembly->handleref_managed, fb, GUINT_TO_POINTER(token)); - g_free (name); - return token; -} - static guint32 mono_image_get_sighelper_token (MonoDynamicImage *assembly, MonoReflectionSigHelper *helper, MonoError *error) { @@ -1573,6 +1180,10 @@ mono_image_create_method_token (MonoDynamicImage *assembly, MonoObject *obj, Mon if (!is_ok (error)) goto fail; } + // FIXME: This doesn't work, we don't use 'sig' for anything + // The token fixup doesn't work either + g_assert_not_reached (); + sig_token = mono_dynimage_encode_method_builder_signature (assembly, &rmb, error); if (!is_ok (error)) goto fail; @@ -1633,60 +1244,17 @@ mono_image_create_token (MonoDynamicImage *assembly, MonoObject *obj, } if (strcmp (klass->name, "MethodBuilder") == 0) { - MonoReflectionMethodBuilder *mb = (MonoReflectionMethodBuilder *)obj; - MonoReflectionTypeBuilder *tb = (MonoReflectionTypeBuilder*)mb->type; - - if (tb->module->dynamic_image == assembly && !tb->generic_params && !mb->generic_params) - token = mb->table_idx | MONO_TOKEN_METHOD_DEF; - else { - token = mono_image_get_methodbuilder_token (assembly, mb, create_open_instance, error); - if (!mono_error_ok (error)) - return 0; - } - /*g_print ("got token 0x%08x for %s\n", token, mono_string_to_utf8 (mb->name));*/ + /* These are handled in managed code */ + g_assert_not_reached (); } else if (strcmp (klass->name, "ConstructorBuilder") == 0) { - MonoReflectionCtorBuilder *mb = (MonoReflectionCtorBuilder *)obj; - MonoReflectionTypeBuilder *tb = (MonoReflectionTypeBuilder*)mb->type; - - if (tb->module->dynamic_image == assembly && !tb->generic_params) - token = mb->table_idx | MONO_TOKEN_METHOD_DEF; - else { - token = mono_image_get_ctorbuilder_token (assembly, mb, error); - if (!mono_error_ok (error)) - return 0; - } - /*g_print ("got token 0x%08x for %s\n", token, mono_string_to_utf8 (mb->name));*/ + /* These are handled in managed code */ + g_assert_not_reached (); } else if (strcmp (klass->name, "FieldBuilder") == 0) { - MonoReflectionFieldBuilder *fb = (MonoReflectionFieldBuilder *)obj; - MonoReflectionTypeBuilder *tb = (MonoReflectionTypeBuilder *)fb->typeb; - if (tb->generic_params) { - token = mono_image_get_generic_field_token (assembly, fb, error); - return_val_if_nok (error, 0); - } else { - if (tb->module->dynamic_image == assembly) { - token = fb->table_idx | MONO_TOKEN_FIELD_DEF; - } else { - token = mono_image_get_fieldref_token (assembly, (MonoObject*)fb, fb->handle); - } - } + /* These are handled in managed code */ + g_assert_not_reached (); } else if (strcmp (klass->name, "TypeBuilder") == 0) { - MonoReflectionTypeBuilder *tb = (MonoReflectionTypeBuilder *)obj; - if (create_open_instance && tb->generic_params) { - MonoType *type; - mono_reflection_init_type_builder_generics (obj, error); - return_val_if_nok (error, 0); - type = mono_reflection_type_get_handle ((MonoReflectionType *)obj, error); - return_val_if_nok (error, 0); - token = mono_dynimage_encode_typedef_or_ref_full (assembly, type, TRUE); - token = mono_metadata_token_from_dor (token); - } else if (tb->module->dynamic_image == assembly) { - token = tb->table_idx | MONO_TOKEN_TYPE_DEF; - } else { - MonoType *type; - type = mono_reflection_type_get_handle ((MonoReflectionType *)obj, error); - return_val_if_nok (error, 0); - token = mono_metadata_token_from_dor (mono_image_typedef_or_ref (assembly, type)); - } + /* These are handled in managed code */ + g_assert_not_reached (); } else if (strcmp (klass->name, "RuntimeType") == 0) { MonoType *type = mono_reflection_type_get_handle ((MonoReflectionType *)obj, error); return_val_if_nok (error, 0); @@ -1694,19 +1262,10 @@ mono_image_create_token (MonoDynamicImage *assembly, MonoObject *obj, token = mono_metadata_token_from_dor ( mono_dynimage_encode_typedef_or_ref_full (assembly, type, mc->generic_container == NULL || create_open_instance)); } else if (strcmp (klass->name, "GenericTypeParameterBuilder") == 0) { - MonoType *type = mono_reflection_type_get_handle ((MonoReflectionType *)obj, error); - return_val_if_nok (error, 0); - token = mono_metadata_token_from_dor ( - mono_image_typedef_or_ref (assembly, type)); - } else if (strcmp (klass->name, "MonoGenericClass") == 0) { - MonoType *type = mono_reflection_type_get_handle ((MonoReflectionType *)obj, error); - return_val_if_nok (error, 0); - token = mono_metadata_token_from_dor ( - mono_image_typedef_or_ref (assembly, type)); + /* These are handled in managed code */ + g_assert_not_reached (); } else if (strcmp (klass->name, "MonoCMethod") == 0 || - strcmp (klass->name, "MonoMethod") == 0 || - strcmp (klass->name, "MonoGenericMethod") == 0 || - strcmp (klass->name, "MonoGenericCMethod") == 0) { + strcmp (klass->name, "MonoMethod") == 0) { MonoReflectionMethod *m = (MonoReflectionMethod *)obj; if (m->method->is_inflated) { if (create_open_instance) @@ -1758,25 +1317,18 @@ mono_image_create_token (MonoDynamicImage *assembly, MonoObject *obj, return_val_if_nok (error, 0); token = mono_metadata_token_from_dor ( mono_image_typedef_or_ref (assembly, type)); + } else if (is_sre_generic_instance (klass) || is_sre_array (klass) || is_sre_byref (klass) || is_sre_pointer (klass)) { + /* These are handled in managed code */ + g_assert_not_reached (); } else if (strcmp (klass->name, "FieldOnTypeBuilderInst") == 0) { - MonoReflectionFieldOnTypeBuilderInst *f = (MonoReflectionFieldOnTypeBuilderInst*)obj; - token = mono_image_get_field_on_inst_token (assembly, f, error); - return_val_if_nok (error, 0); + /* These are handled in managed code */ + g_assert_not_reached (); } else if (strcmp (klass->name, "ConstructorOnTypeBuilderInst") == 0) { - MonoReflectionCtorOnTypeBuilderInst *c = (MonoReflectionCtorOnTypeBuilderInst*)obj; - token = mono_image_get_ctor_on_inst_token (assembly, c, create_open_instance, error); - if (!mono_error_ok (error)) - return 0; + /* These are handled in managed code */ + g_assert_not_reached (); } else if (strcmp (klass->name, "MethodOnTypeBuilderInst") == 0) { - MonoReflectionMethodOnTypeBuilderInst *m = (MonoReflectionMethodOnTypeBuilderInst*)obj; - token = mono_image_get_method_on_inst_token (assembly, m, create_open_instance, error); - if (!mono_error_ok (error)) - return 0; - } else if (is_sre_array (klass) || is_sre_byref (klass) || is_sre_pointer (klass)) { - MonoType *type = mono_reflection_type_get_handle ((MonoReflectionType *)obj, error); - return_val_if_nok (error, 0); - token = mono_metadata_token_from_dor ( - mono_image_typedef_or_ref (assembly, type)); + /* These are handled in managed code */ + g_assert_not_reached (); } else { g_error ("requested token for %s\n", klass->name); } @@ -2023,6 +1575,12 @@ is_sre_field_builder (MonoClass *klass) check_corlib_type_cached (klass, "System.Reflection.Emit", "FieldBuilder"); } +static gboolean +is_sre_gparam_builder (MonoClass *klass) +{ + check_corlib_type_cached (klass, "System.Reflection.Emit", "GenericTypeParameterBuilder"); +} + gboolean mono_is_sre_method_on_tb_inst (MonoClass *klass) { @@ -2121,65 +1679,45 @@ mono_reflection_type_get_handle (MonoReflectionType* ref, MonoError *error) } } - res = mono_reflection_bind_generic_parameters (gclass->generic_type, count, types, error); - g_free (types); - g_assert (res); - gclass->type.type = res; - return res; - } - - g_error ("Cannot handle corlib user type %s", mono_type_full_name (&mono_object_class(ref)->byval_arg)); - return NULL; -} - -void -ves_icall_SymbolType_create_unmanaged_type (MonoReflectionType *type) -{ - MonoError error; - mono_reflection_type_get_handle (type, &error); - mono_error_set_pending_exception (&error); -} + res = mono_reflection_bind_generic_parameters (gclass->generic_type, count, types, error); + g_free (types); + g_assert (res); + gclass->type.type = res; + return res; + } else if (is_sre_gparam_builder (klass)) { + MonoReflectionGenericParam *gparam = (MonoReflectionGenericParam *)ref; + MonoGenericParamFull *param; + MonoImage *image; + MonoClass *pklass; -static gboolean -reflection_register_with_runtime (MonoReflectionType *type, MonoError *error) -{ - MonoDomain *domain = mono_object_domain ((MonoObject*)type); - MonoClass *klass; + image = &gparam->tbuilder->module->dynamic_image->image; - mono_error_init (error); + param = mono_image_new0 (image, MonoGenericParamFull, 1); - MonoType *res = mono_reflection_type_get_handle (type, error); + param->info.name = mono_string_to_utf8_image (image, gparam->name, error); + mono_error_assert_ok (error); + param->param.num = gparam->index; + + if (gparam->mbuilder) { + g_assert (gparam->mbuilder->generic_container); + param->param.owner = gparam->mbuilder->generic_container; + } else if (gparam->tbuilder) { + g_assert (gparam->tbuilder->generic_container); + param->param.owner = gparam->tbuilder->generic_container; + } - if (!res && is_ok (error)) { - mono_error_set_argument (error, NULL, "Invalid generic instantiation, one or more arguments are not proper user types"); - } - return_val_if_nok (error, FALSE); + pklass = mono_class_from_generic_parameter_internal ((MonoGenericParam *) param); - klass = mono_class_from_mono_type (res); + gparam->type.type = &pklass->byval_arg; - mono_loader_lock (); /*same locking as mono_type_get_object_checked */ - mono_domain_lock (domain); + mono_class_set_ref_info (pklass, gparam); + mono_image_append_class_to_reflection_info_set (pklass); - if (!image_is_dynamic (klass->image)) { - mono_class_setup_supertypes (klass); - } else { - if (!domain->type_hash) - domain->type_hash = mono_g_hash_table_new_type ((GHashFunc)mono_metadata_type_hash, - (GCompareFunc)mono_metadata_type_equal, MONO_HASH_VALUE_GC, MONO_ROOT_SOURCE_DOMAIN, "domain reflection types table"); - mono_g_hash_table_insert (domain->type_hash, res, type); + return &pklass->byval_arg; } - mono_domain_unlock (domain); - mono_loader_unlock (); - - return TRUE; -} -void -mono_reflection_register_with_runtime (MonoReflectionType *type) -{ - MonoError error; - (void) reflection_register_with_runtime (type, &error); - mono_error_set_pending_exception (&error); + g_error ("Cannot handle corlib user type %s", mono_type_full_name (&mono_object_class(ref)->byval_arg)); + return NULL; } /** @@ -2309,12 +1847,6 @@ get_field_name_and_type (MonoObject *field, char **name, MonoType **type, MonoEr #else /* DISABLE_REFLECTION_EMIT */ -void -mono_reflection_register_with_runtime (MonoReflectionType *type) -{ - /* This is empty */ -} - static gboolean is_sre_type_builder (MonoClass *klass) { @@ -2378,22 +1910,10 @@ mono_is_sr_mono_cmethod (MonoClass *klass) check_corlib_type_cached (klass, "System.Reflection", "MonoCMethod"); } -static gboolean -is_sr_mono_generic_method (MonoClass *klass) -{ - check_corlib_type_cached (klass, "System.Reflection", "MonoGenericMethod"); -} - -static gboolean -is_sr_mono_generic_cmethod (MonoClass *klass) -{ - check_corlib_type_cached (klass, "System.Reflection", "MonoGenericCMethod"); -} - gboolean mono_class_is_reflection_method_or_constructor (MonoClass *klass) { - return is_sr_mono_method (klass) || mono_is_sr_mono_cmethod (klass) || is_sr_mono_generic_method (klass) || is_sr_mono_generic_cmethod (klass); + return is_sr_mono_method (klass) || mono_is_sr_mono_cmethod (klass); } gboolean @@ -3454,8 +2974,7 @@ ctorbuilder_to_mono_method (MonoClass *klass, MonoReflectionCtorBuilder* mb, Mon return_val_if_nok (error, NULL); mono_save_custom_attrs (klass->image, mb->mhandle, mb->cattrs); - /* If we are in a generic class, we might be called multiple times from inflate_method */ - if (!((MonoDynamicImage*)(MonoDynamicImage*)klass->image)->save && !klass->generic_container) { + if (!((MonoDynamicImage*)(MonoDynamicImage*)klass->image)->save) { /* ilgen is no longer needed */ mb->ilgen = NULL; } @@ -3484,142 +3003,15 @@ methodbuilder_to_mono_method (MonoClass *klass, MonoReflectionMethodBuilder* mb, return_val_if_nok (error, NULL); mono_save_custom_attrs (klass->image, mb->mhandle, mb->cattrs); - /* If we are in a generic class, we might be called multiple times from inflate_method */ - if (!((MonoDynamicImage*)(MonoDynamicImage*)klass->image)->save && !klass->generic_container) { + if (!((MonoDynamicImage*)(MonoDynamicImage*)klass->image)->save) /* ilgen is no longer needed */ mb->ilgen = NULL; - } return mb->mhandle; } #endif #ifndef DISABLE_REFLECTION_EMIT -static MonoMethod * -inflate_mono_method (MonoClass *klass, MonoMethod *method, MonoObject *obj) -{ - MonoMethodInflated *imethod; - MonoGenericContext *context; - int i; - - /* - * With generic code sharing the klass might not be inflated. - * This can happen because classes inflated with their own - * type arguments are "normalized" to the uninflated class. - */ - if (!klass->generic_class) - return method; - - context = mono_class_get_context (klass); - - if (klass->method.count && klass->methods) { - /* Find the already created inflated method */ - for (i = 0; i < klass->method.count; ++i) { - g_assert (klass->methods [i]->is_inflated); - if (((MonoMethodInflated*)klass->methods [i])->declaring == method) - break; - } - g_assert (i < klass->method.count); - imethod = (MonoMethodInflated*)klass->methods [i]; - } else { - MonoError error; - imethod = (MonoMethodInflated *) mono_class_inflate_generic_method_full_checked (method, klass, context, &error); - mono_error_assert_ok (&error); - } - - if (method->is_generic && image_is_dynamic (method->klass->image)) { - MonoDynamicImage *image = (MonoDynamicImage*)method->klass->image; - - mono_image_lock ((MonoImage*)image); - mono_g_hash_table_insert (image->generic_def_objects, imethod, obj); - mono_image_unlock ((MonoImage*)image); - } - return (MonoMethod *) imethod; -} - -static MonoMethod * -inflate_method (MonoReflectionType *type, MonoObject *obj, MonoError *error) -{ - MonoMethod *method; - MonoClass *gklass; - - mono_error_init (error); - - MonoClass *type_class = mono_object_class (type); - - if (is_sre_generic_instance (type_class)) { - MonoReflectionGenericClass *mgc = (MonoReflectionGenericClass*)type; - MonoType *generic_type = mono_reflection_type_get_handle ((MonoReflectionType*)mgc->generic_type, error); - return_val_if_nok (error, NULL); - gklass = mono_class_from_mono_type (generic_type); - } else if (is_sre_type_builder (type_class)) { - MonoType *t = mono_reflection_type_get_handle (type, error); - return_val_if_nok (error, NULL); - gklass = mono_class_from_mono_type (t); - } else if (type->type) { - gklass = mono_class_from_mono_type (type->type); - gklass = mono_class_get_generic_type_definition (gklass); - } else { - g_error ("Can't handle type %s", mono_type_get_full_name (mono_object_class (type))); - } - - if (!strcmp (obj->vtable->klass->name, "MethodBuilder")) - if (((MonoReflectionMethodBuilder*)obj)->mhandle) - method = ((MonoReflectionMethodBuilder*)obj)->mhandle; - else { - method = methodbuilder_to_mono_method (gklass, (MonoReflectionMethodBuilder *) obj, error); - if (!method) - return NULL; - } - else if (!strcmp (obj->vtable->klass->name, "ConstructorBuilder")) { - method = ctorbuilder_to_mono_method (gklass, (MonoReflectionCtorBuilder *) obj, error); - if (!method) - return NULL; - } else if (!strcmp (obj->vtable->klass->name, "MonoMethod") || !strcmp (obj->vtable->klass->name, "MonoCMethod")) - method = ((MonoReflectionMethod *) obj)->method; - else { - method = NULL; /* prevent compiler warning */ - g_error ("can't handle type %s", obj->vtable->klass->name); - } - - MonoType *t = mono_reflection_type_get_handle (type, error); - return_val_if_nok (error, NULL); - return inflate_mono_method (mono_class_from_mono_type (t), method, obj); -} - -static void -reflection_generic_class_initialize (MonoReflectionGenericClass *type, MonoError *error) -{ - MonoGenericClass *gclass; - MonoClass *klass, *gklass; - MonoType *gtype; - - mono_error_init (error); - - gtype = mono_reflection_type_get_handle ((MonoReflectionType*)type, error); - return_if_nok (error); - klass = mono_class_from_mono_type (gtype); - g_assert (gtype->type == MONO_TYPE_GENERICINST); - gclass = gtype->data.generic_class; - - if (!gclass->is_dynamic) - return; - - gklass = gclass->container_class; - mono_class_init (gklass); - - /* Mark this as needing synchronization with its generic container */ - gclass->need_sync = TRUE; -} - -void -mono_reflection_generic_class_initialize (MonoReflectionGenericClass *type, MonoArray *fields) -{ - MonoError error; - reflection_generic_class_initialize (type, &error); - mono_error_set_pending_exception (&error); -} - /** * fix_partial_generic_class: * @klass: a generic instantiation MonoClass @@ -3825,7 +3217,7 @@ mono_reflection_method_get_handle (MonoObject *method, MonoError *error) { mono_error_init (error); MonoClass *klass = mono_object_class (method); - if (is_sr_mono_method (klass) || is_sr_mono_generic_method (klass)) { + if (is_sr_mono_method (klass)) { MonoReflectionMethod *sr_method = (MonoReflectionMethod*)method; return sr_method->method; } @@ -3834,26 +3226,11 @@ mono_reflection_method_get_handle (MonoObject *method, MonoError *error) return mb->mhandle; } if (mono_is_sre_method_on_tb_inst (klass)) { - MonoReflectionMethodOnTypeBuilderInst *m = (MonoReflectionMethodOnTypeBuilderInst*)method; - MonoMethod *result; - /*FIXME move this to a proper method and unify with resolve_object*/ - if (m->method_args) { - result = mono_reflection_method_on_tb_inst_get_handle (m, error); - } else { - MonoType *type = mono_reflection_type_get_handle ((MonoReflectionType*)m->inst, error); - return_val_if_nok (error, NULL); - MonoClass *inflated_klass = mono_class_from_mono_type (type); - MonoMethod *mono_method; + MonoClass *handle_class; - if (is_sre_method_builder (mono_object_class (m->mb))) - mono_method = ((MonoReflectionMethodBuilder *)m->mb)->mhandle; - else if (is_sr_mono_method (mono_object_class (m->mb))) - mono_method = ((MonoReflectionMethod *)m->mb)->method; - else - g_error ("resolve_object:: can't handle a MTBI with base_method of type %s", mono_type_get_full_name (mono_object_class (m->mb))); + MonoMethod *result = mono_reflection_resolve_object (NULL, method, &handle_class, NULL, error); + return_val_if_nok (error, NULL); - result = inflate_mono_method (inflated_klass, mono_method, (MonoObject*)m->mb); - } return result; } @@ -4060,68 +3437,6 @@ typebuilder_setup_properties (MonoClass *klass, MonoError *error) } } -static MonoReflectionEvent * -reflection_event_builder_get_event_info (MonoReflectionTypeBuilder *tb, MonoReflectionEventBuilder *eb, MonoError *error) -{ - mono_error_init (error); - - MonoEvent *event = g_new0 (MonoEvent, 1); - MonoClass *klass; - - MonoType *type = mono_reflection_type_get_handle ((MonoReflectionType*)tb, error); - if (!is_ok (error)) { - g_free (event); - return NULL; - } - klass = mono_class_from_mono_type (type); - - event->parent = klass; - event->attrs = eb->attrs; - event->name = mono_string_to_utf8_checked (eb->name, error); - if (!is_ok (error)) { - g_free (event); - return NULL; - } - 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; - -#ifndef MONO_SMALL_CONFIG - if (eb->other_methods) { - int j; - event->other = g_new0 (MonoMethod*, mono_array_length (eb->other_methods) + 1); - 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; - } - } -#endif - - MonoReflectionEvent *ev_obj = mono_event_get_object_checked (mono_object_domain (tb), klass, event, error); - if (!is_ok (error)) { -#ifndef MONO_SMALL_CONFIG - g_free (event->other); -#endif - g_free (event); - return NULL; - } - return ev_obj; -} - -MonoReflectionEvent * -ves_icall_TypeBuilder_get_event_info (MonoReflectionTypeBuilder *tb, MonoReflectionEventBuilder *eb) -{ - MonoError error; - MonoReflectionEvent *result = reflection_event_builder_get_event_info (tb, eb, &error); - mono_error_set_pending_exception (&error); - return result; -} - static void typebuilder_setup_events (MonoClass *klass, MonoError *error) { @@ -4248,22 +3563,6 @@ ves_icall_TypeBuilder_create_runtime_class (MonoReflectionTypeBuilder *tb) mono_class_setup_supertypes (klass); mono_class_setup_mono_type (klass); -#if 0 - if (!((MonoDynamicImage*)klass->image)->run) { - if (klass->generic_container) { - /* FIXME: The code below can't handle generic classes */ - klass->wastypebuilder = TRUE; - mono_loader_unlock (); - mono_domain_unlock (domain); - - res = mono_type_get_object_checked (mono_object_domain (tb), &klass->byval_arg, &error); - mono_error_set_pending_exception (&error); - - return res; - } - } -#endif - /* enums are done right away */ if (!klass->enumtype) if (!ensure_runtime_vtable (klass, &error)) @@ -4358,20 +3657,12 @@ failure_unlocked: static gboolean reflection_initialize_generic_parameter (MonoReflectionGenericParam *gparam, MonoError *error) { - MonoGenericParamFull *param; MonoImage *image; - MonoClass *pklass; mono_error_init (error); image = &gparam->tbuilder->module->dynamic_image->image; - param = mono_image_new0 (image, MonoGenericParamFull, 1); - - param->info.name = mono_string_to_utf8_image (image, gparam->name, error); - mono_error_assert_ok (error); - param->param.num = gparam->index; - if (gparam->mbuilder) { if (!gparam->mbuilder->generic_container) { MonoType *tb = mono_reflection_type_get_handle ((MonoReflectionType*)gparam->mbuilder->type, error); @@ -4387,7 +3678,6 @@ reflection_initialize_generic_parameter (MonoReflectionGenericParam *gparam, Mon gparam->mbuilder->generic_container->is_anonymous = TRUE; gparam->mbuilder->generic_container->owner.image = klass->image; } - param->param.owner = gparam->mbuilder->generic_container; } else if (gparam->tbuilder) { if (!gparam->tbuilder->generic_container) { MonoType *tb = mono_reflection_type_get_handle ((MonoReflectionType*)gparam->tbuilder, error); @@ -4396,21 +3686,13 @@ reflection_initialize_generic_parameter (MonoReflectionGenericParam *gparam, Mon gparam->tbuilder->generic_container = (MonoGenericContainer *)mono_image_alloc0 (klass->image, sizeof (MonoGenericContainer)); gparam->tbuilder->generic_container->owner.klass = klass; } - param->param.owner = gparam->tbuilder->generic_container; } - pklass = mono_class_from_generic_parameter_internal ((MonoGenericParam *) param); - - gparam->type.type = &pklass->byval_arg; - - mono_class_set_ref_info (pklass, gparam); - mono_image_append_class_to_reflection_info_set (pklass); - return TRUE; } void -ves_icall_GenericTypeParameterBuilder_initialize_generic_parameter (MonoReflectionGenericParam *gparam) +ves_icall_GenericTypeParameterBuilder_initialize (MonoReflectionGenericParam *gparam) { MonoError error; (void) reflection_initialize_generic_parameter (gparam, &error); @@ -4646,16 +3928,17 @@ ensure_complete_type (MonoClass *klass, MonoError *error) gpointer mono_reflection_resolve_object (MonoImage *image, MonoObject *obj, MonoClass **handle_class, MonoGenericContext *context, MonoError *error) { + MonoClass *oklass = obj->vtable->klass; gpointer result = NULL; mono_error_init (error); - if (strcmp (obj->vtable->klass->name, "String") == 0) { + if (strcmp (oklass->name, "String") == 0) { result = mono_string_intern_checked ((MonoString*)obj, error); return_val_if_nok (error, NULL); *handle_class = mono_defaults.string_class; g_assert (result); - } else if (strcmp (obj->vtable->klass->name, "RuntimeType") == 0) { + } else if (strcmp (oklass->name, "RuntimeType") == 0) { MonoType *type = mono_reflection_type_get_handle ((MonoReflectionType*)obj, error); return_val_if_nok (error, NULL); MonoClass *mc = mono_class_from_mono_type (type); @@ -4675,10 +3958,8 @@ mono_reflection_resolve_object (MonoImage *image, MonoObject *obj, MonoClass **h } *handle_class = mono_defaults.typehandle_class; g_assert (result); - } else if (strcmp (obj->vtable->klass->name, "MonoMethod") == 0 || - strcmp (obj->vtable->klass->name, "MonoCMethod") == 0 || - strcmp (obj->vtable->klass->name, "MonoGenericCMethod") == 0 || - strcmp (obj->vtable->klass->name, "MonoGenericMethod") == 0) { + } else if (strcmp (oklass->name, "MonoMethod") == 0 || + strcmp (oklass->name, "MonoCMethod") == 0) { result = ((MonoReflectionMethod*)obj)->method; if (context) { result = mono_class_inflate_generic_method_checked ((MonoMethod *)result, context, error); @@ -4686,48 +3967,7 @@ mono_reflection_resolve_object (MonoImage *image, MonoObject *obj, MonoClass **h } *handle_class = mono_defaults.methodhandle_class; g_assert (result); - } else if (strcmp (obj->vtable->klass->name, "MethodBuilder") == 0) { - MonoReflectionMethodBuilder *mb = (MonoReflectionMethodBuilder*)obj; - result = mb->mhandle; - if (!result) { - /* Type is not yet created */ - MonoReflectionTypeBuilder *tb = (MonoReflectionTypeBuilder*)mb->type; - - mono_domain_try_type_resolve_checked (mono_domain_get (), NULL, (MonoObject*)tb, error); - return_val_if_nok (error, NULL); - - /* - * Hopefully this has been filled in by calling CreateType() on the - * TypeBuilder. - */ - /* - * TODO: This won't work if the application finishes another - * TypeBuilder instance instead of this one. - */ - result = mb->mhandle; - } - if (context) { - result = mono_class_inflate_generic_method_checked ((MonoMethod *)result, context, error); - mono_error_assert_ok (error); - } - *handle_class = mono_defaults.methodhandle_class; - } else if (strcmp (obj->vtable->klass->name, "ConstructorBuilder") == 0) { - MonoReflectionCtorBuilder *cb = (MonoReflectionCtorBuilder*)obj; - - result = cb->mhandle; - if (!result) { - MonoReflectionTypeBuilder *tb = (MonoReflectionTypeBuilder*)cb->type; - - mono_domain_try_type_resolve_checked (mono_domain_get (), NULL, (MonoObject*)tb, error); - return_val_if_nok (error, NULL); - result = cb->mhandle; - } - if (context) { - result = mono_class_inflate_generic_method_checked ((MonoMethod *)result, context, error); - mono_error_assert_ok (error); - } - *handle_class = mono_defaults.methodhandle_class; - } else if (strcmp (obj->vtable->klass->name, "MonoField") == 0) { + } else if (strcmp (oklass->name, "MonoField") == 0) { MonoClassField *field = ((MonoReflectionField*)obj)->field; ensure_complete_type (field->parent, error); @@ -4752,31 +3992,7 @@ mono_reflection_resolve_object (MonoImage *image, MonoObject *obj, MonoClass **h } *handle_class = mono_defaults.fieldhandle_class; g_assert (result); - } else if (strcmp (obj->vtable->klass->name, "FieldBuilder") == 0) { - MonoReflectionFieldBuilder *fb = (MonoReflectionFieldBuilder*)obj; - result = fb->handle; - - if (!result) { - MonoReflectionTypeBuilder *tb = (MonoReflectionTypeBuilder*)fb->typeb; - - mono_domain_try_type_resolve_checked (mono_domain_get (), NULL, (MonoObject*)tb, error); - return_val_if_nok (error, NULL); - result = fb->handle; - } - - if (fb->handle && fb->handle->parent->generic_container) { - MonoClass *klass = fb->handle->parent; - MonoType *type = mono_class_inflate_generic_type_checked (&klass->byval_arg, context, error); - return_val_if_nok (error, NULL); - - MonoClass *inflated = mono_class_from_mono_type (type); - - result = mono_class_get_field_from_name (inflated, mono_field_get_name (fb->handle)); - g_assert (result); - mono_metadata_free_type (type); - } - *handle_class = mono_defaults.fieldhandle_class; - } else if (strcmp (obj->vtable->klass->name, "TypeBuilder") == 0) { + } else if (strcmp (oklass->name, "TypeBuilder") == 0) { MonoReflectionTypeBuilder *tb = (MonoReflectionTypeBuilder*)obj; MonoType *type = mono_reflection_type_get_handle ((MonoReflectionType*)tb, error); return_val_if_nok (error, NULL); @@ -4794,7 +4010,7 @@ mono_reflection_resolve_object (MonoImage *image, MonoObject *obj, MonoClass **h g_assert (result); } *handle_class = mono_defaults.typehandle_class; - } else if (strcmp (obj->vtable->klass->name, "SignatureHelper") == 0) { + } else if (strcmp (oklass->name, "SignatureHelper") == 0) { MonoReflectionSigHelper *helper = (MonoReflectionSigHelper*)obj; MonoMethodSignature *sig; int nargs, i; @@ -4830,112 +4046,13 @@ mono_reflection_resolve_object (MonoImage *image, MonoObject *obj, MonoClass **h result = sig; *handle_class = NULL; - } else if (strcmp (obj->vtable->klass->name, "DynamicMethod") == 0) { + } else if (strcmp (oklass->name, "DynamicMethod") == 0) { MonoReflectionDynamicMethod *method = (MonoReflectionDynamicMethod*)obj; /* Already created by the managed code */ g_assert (method->mhandle); result = method->mhandle; *handle_class = mono_defaults.methodhandle_class; - } else if (strcmp (obj->vtable->klass->name, "GenericTypeParameterBuilder") == 0) { - MonoType *type = mono_reflection_type_get_handle ((MonoReflectionType*)obj, error); - return_val_if_nok (error, NULL); - type = mono_class_inflate_generic_type_checked (type, context, error); - return_val_if_nok (error, NULL); - - result = mono_class_from_mono_type (type); - *handle_class = mono_defaults.typehandle_class; - g_assert (result); - mono_metadata_free_type (type); - } else if (strcmp (obj->vtable->klass->name, "MonoGenericClass") == 0) { - MonoType *type = mono_reflection_type_get_handle ((MonoReflectionType*)obj, error); - return_val_if_nok (error, NULL); - type = mono_class_inflate_generic_type_checked (type, context, error); - return_val_if_nok (error, NULL); - - result = mono_class_from_mono_type (type); - *handle_class = mono_defaults.typehandle_class; - g_assert (result); - mono_metadata_free_type (type); - } else if (strcmp (obj->vtable->klass->name, "FieldOnTypeBuilderInst") == 0) { - MonoReflectionFieldOnTypeBuilderInst *f = (MonoReflectionFieldOnTypeBuilderInst*)obj; - MonoClass *inflated; - MonoType *type; - MonoClassField *field; - - if (is_sre_field_builder (mono_object_class (f->fb))) - field = ((MonoReflectionFieldBuilder*)f->fb)->handle; - else if (is_sr_mono_field (mono_object_class (f->fb))) - field = ((MonoReflectionField*)f->fb)->field; - else - g_error ("resolve_object:: can't handle a FTBI with base_method of type %s", mono_type_get_full_name (mono_object_class (f->fb))); - - MonoType *finst = mono_reflection_type_get_handle ((MonoReflectionType*)f->inst, error); - return_val_if_nok (error, NULL); - type = mono_class_inflate_generic_type_checked (finst, context, error); - return_val_if_nok (error, NULL); - - inflated = mono_class_from_mono_type (type); - - result = field = mono_class_get_field_from_name (inflated, mono_field_get_name (field)); - ensure_complete_type (field->parent, error); - if (!is_ok (error)) { - mono_metadata_free_type (type); - return NULL; - } - - g_assert (result); - mono_metadata_free_type (type); - *handle_class = mono_defaults.fieldhandle_class; - } else if (strcmp (obj->vtable->klass->name, "ConstructorOnTypeBuilderInst") == 0) { - MonoReflectionCtorOnTypeBuilderInst *c = (MonoReflectionCtorOnTypeBuilderInst*)obj; - MonoType *cinst = mono_reflection_type_get_handle ((MonoReflectionType*)c->inst, error); - return_val_if_nok (error, NULL); - MonoType *type = mono_class_inflate_generic_type_checked (cinst, context, error); - return_val_if_nok (error, NULL); - - MonoClass *inflated_klass = mono_class_from_mono_type (type); - MonoMethod *method; - - if (mono_is_sre_ctor_builder (mono_object_class (c->cb))) - method = ((MonoReflectionCtorBuilder *)c->cb)->mhandle; - else if (mono_is_sr_mono_cmethod (mono_object_class (c->cb))) - method = ((MonoReflectionMethod *)c->cb)->method; - else - g_error ("resolve_object:: can't handle a CTBI with base_method of type %s", mono_type_get_full_name (mono_object_class (c->cb))); - - result = inflate_mono_method (inflated_klass, method, (MonoObject*)c->cb); - *handle_class = mono_defaults.methodhandle_class; - mono_metadata_free_type (type); - } else if (strcmp (obj->vtable->klass->name, "MethodOnTypeBuilderInst") == 0) { - MonoReflectionMethodOnTypeBuilderInst *m = (MonoReflectionMethodOnTypeBuilderInst*)obj; - if (m->method_args) { - result = mono_reflection_method_on_tb_inst_get_handle (m, error); - return_val_if_nok (error, NULL); - if (context) { - result = mono_class_inflate_generic_method_checked ((MonoMethod *)result, context, error); - mono_error_assert_ok (error); - } - } else { - MonoType *minst = mono_reflection_type_get_handle ((MonoReflectionType*)m->inst, error); - return_val_if_nok (error, NULL); - MonoType *type = mono_class_inflate_generic_type_checked (minst, context, error); - return_val_if_nok (error, NULL); - - MonoClass *inflated_klass = mono_class_from_mono_type (type); - MonoMethod *method; - - if (is_sre_method_builder (mono_object_class (m->mb))) - method = ((MonoReflectionMethodBuilder *)m->mb)->mhandle; - else if (is_sr_mono_method (mono_object_class (m->mb))) - method = ((MonoReflectionMethod *)m->mb)->method; - else - g_error ("resolve_object:: can't handle a MTBI with base_method of type %s", mono_type_get_full_name (mono_object_class (m->mb))); - - result = inflate_mono_method (inflated_klass, method, (MonoObject*)m->mb); - mono_metadata_free_type (type); - } - *handle_class = mono_defaults.methodhandle_class; - } else if (strcmp (obj->vtable->klass->name, "MonoArrayMethod") == 0) { + } else if (strcmp (oklass->name, "MonoArrayMethod") == 0) { MonoReflectionArrayMethod *m = (MonoReflectionArrayMethod*)obj; MonoType *mtype; MonoClass *klass; @@ -4964,23 +4081,30 @@ mono_reflection_resolve_object (MonoImage *image, MonoObject *obj, MonoClass **h result = method; *handle_class = mono_defaults.methodhandle_class; - } else if (is_sre_array (mono_object_get_class(obj)) || - is_sre_byref (mono_object_get_class(obj)) || - is_sre_pointer (mono_object_get_class(obj))) { - MonoReflectionType *ref_type = (MonoReflectionType *)obj; - MonoType *type = mono_reflection_type_get_handle (ref_type, error); - return_val_if_nok (error, NULL); - - if (context) { - MonoType *inflated = mono_class_inflate_generic_type_checked (type, context, error); - return_val_if_nok (error, NULL); - - result = mono_class_from_mono_type (inflated); - mono_metadata_free_type (inflated); - } else { - result = mono_class_from_mono_type (type); + } else if (is_sre_method_builder (oklass) || + mono_is_sre_ctor_builder (oklass) || + is_sre_field_builder (oklass) || + is_sre_gparam_builder (oklass) || + is_sre_generic_instance (oklass) || + is_sre_array (oklass) || + is_sre_byref (oklass) || + is_sre_pointer (oklass) || + !strcmp (oklass->name, "FieldOnTypeBuilderInst") || + !strcmp (oklass->name, "MethodOnTypeBuilderInst") || + !strcmp (oklass->name, "ConstructorOnTypeBuilderInst")) { + static MonoMethod *resolve_method; + if (!resolve_method) { + MonoMethod *m = mono_class_get_method_from_name_flags (mono_class_get_module_builder_class (), "RuntimeResolve", 1, 0); + g_assert (m); + mono_memory_barrier (); + resolve_method = m; } - *handle_class = mono_defaults.typehandle_class; + void *args [16]; + args [0] = obj; + obj = mono_runtime_invoke_checked (resolve_method, NULL, args, error); + mono_error_assert_ok (error); + g_assert (obj); + return mono_reflection_resolve_object (image, obj, handle_class, context, error); } else { g_print ("%s\n", obj->vtable->klass->name); g_assert_not_reached (); @@ -5044,12 +4168,6 @@ mono_image_create_token (MonoDynamicImage *assembly, MonoObject *obj, return 0; } -void -mono_reflection_generic_class_initialize (MonoReflectionGenericClass *type, MonoArray *fields) -{ - g_assert_not_reached (); -} - void mono_reflection_get_dynamic_overrides (MonoClass *klass, MonoMethod ***overrides, int *num_overrides, MonoError *error) { @@ -5058,13 +4176,6 @@ mono_reflection_get_dynamic_overrides (MonoClass *klass, MonoMethod ***overrides *num_overrides = 0; } -MonoReflectionEvent * -ves_icall_TypeBuilder_get_event_info (MonoReflectionTypeBuilder *tb, MonoReflectionEventBuilder *eb) -{ - g_assert_not_reached (); - return NULL; -} - MonoReflectionType* ves_icall_TypeBuilder_create_runtime_class (MonoReflectionTypeBuilder *tb) { @@ -5207,12 +4318,6 @@ ves_icall_AssemblyBuilder_basic_init (MonoReflectionAssemblyBuilder *assemblyb) mono_reflection_dynimage_basic_init (assemblyb); } -MonoBoolean -ves_icall_TypeBuilder_get_IsGenericParameter (MonoReflectionTypeBuilder *tb) -{ - return mono_type_is_generic_parameter (tb->type.type); -} - void ves_icall_EnumBuilder_setup_enum_type (MonoReflectionType *enumtype, MonoReflectionType *t) -- 2.25.1