internal static TypeWrapper GetWrapperFromType(Type type) { //Tracer.Info(Tracer.Runtime, "GetWrapperFromType: {0}", type.AssemblyQualifiedName); #if !STATIC_COMPILER TypeWrapper.AssertFinished(type); #endif Debug.Assert(!type.IsPointer); Debug.Assert(!type.IsByRef); TypeWrapper wrapper; lock (globalTypeToTypeWrapper) { globalTypeToTypeWrapper.TryGetValue(type, out wrapper); } if (wrapper != null) { return(wrapper); } string remapped; if (remappedTypes.TryGetValue(type, out remapped)) { wrapper = LoadClassCritical(remapped); } else if (ReflectUtil.IsVector(type)) { // it might be an array of a dynamically compiled Java type int rank = 1; Type elem = type.GetElementType(); while (ReflectUtil.IsVector(elem)) { rank++; elem = elem.GetElementType(); } wrapper = GetWrapperFromType(elem).MakeArrayType(rank); } else { Assembly asm = type.Assembly; #if CLASSGC ClassLoaderWrapper loader; if (dynamicAssemblies != null && dynamicAssemblies.TryGetValue(asm, out loader)) { lock (loader.typeToTypeWrapper) { return(loader.typeToTypeWrapper[type]); } } #endif #if !STATIC_COMPILER && !STUB_GENERATOR if (ReflectUtil.IsReflectionOnly(type)) { // historically we've always returned null for types that don't have a corresponding TypeWrapper (or java.lang.Class) return(null); } #endif // if the wrapper doesn't already exist, that must mean that the type // is a .NET type (or a pre-compiled Java class), which means that it // was "loaded" by an assembly classloader wrapper = AssemblyClassLoader.FromAssembly(asm).GetWrapperFromAssemblyType(type); } #if CLASSGC if (type.Assembly.IsDynamic) { // don't cache types in dynamic assemblies, because they might live in a RunAndCollect assembly // TODO we also shouldn't cache generic type instances that have a GCable type parameter return(wrapper); } #endif lock (globalTypeToTypeWrapper) { globalTypeToTypeWrapper[type] = wrapper; } return(wrapper); }
private static MethodBuilder CreateConstructorAndDispatch(DynamicTypeWrapper.FinishContext context, ClassFile.ConstantPoolItemInvokeDynamic cpi, TypeBuilder tb, List <MethodWrapper> methods, TypeWrapper[] implParameters, ClassFile.ConstantPoolItemMethodType samMethodType, ClassFile.ConstantPoolItemMethodHandle implMethod, ClassFile.ConstantPoolItemMethodType instantiatedMethodType, bool serializable) { TypeWrapper[] args = cpi.GetArgTypes(); // captured values Type[] capturedTypes = new Type[args.Length]; FieldBuilder[] capturedFields = new FieldBuilder[capturedTypes.Length]; for (int i = 0; i < capturedTypes.Length; i++) { capturedTypes[i] = args[i].TypeAsSignatureType; FieldAttributes attr = FieldAttributes.Private; if (i > 0 || !args[0].IsGhost) { attr |= FieldAttributes.InitOnly; } capturedFields[i] = tb.DefineField("arg$" + (i + 1), capturedTypes[i], attr); } // constructor MethodBuilder ctor = ReflectUtil.DefineConstructor(tb, MethodAttributes.Assembly, capturedTypes); CodeEmitter ilgen = CodeEmitter.Create(ctor); ilgen.Emit(OpCodes.Ldarg_0); ilgen.Emit(OpCodes.Call, Types.Object.GetConstructor(Type.EmptyTypes)); for (int i = 0; i < capturedTypes.Length; i++) { ilgen.EmitLdarg(0); ilgen.EmitLdarg(i + 1); ilgen.Emit(OpCodes.Stfld, capturedFields[i]); } ilgen.Emit(OpCodes.Ret); ilgen.DoEmit(); // dispatch methods foreach (MethodWrapper mw in methods) { EmitDispatch(context, args, tb, mw, implParameters, implMethod, instantiatedMethodType, capturedFields); } // writeReplace method if (serializable) { MethodBuilder writeReplace = tb.DefineMethod("writeReplace", MethodAttributes.Private, Types.Object, Type.EmptyTypes); ilgen = CodeEmitter.Create(writeReplace); context.TypeWrapper.EmitClassLiteral(ilgen); ilgen.Emit(OpCodes.Ldstr, cpi.GetRetType().Name.Replace('.', '/')); ilgen.Emit(OpCodes.Ldstr, cpi.Name); ilgen.Emit(OpCodes.Ldstr, samMethodType.Signature.Replace('.', '/')); ilgen.EmitLdc_I4((int)implMethod.Kind); ilgen.Emit(OpCodes.Ldstr, implMethod.Class.Replace('.', '/')); ilgen.Emit(OpCodes.Ldstr, implMethod.Name); ilgen.Emit(OpCodes.Ldstr, implMethod.Signature.Replace('.', '/')); ilgen.Emit(OpCodes.Ldstr, instantiatedMethodType.Signature.Replace('.', '/')); ilgen.EmitLdc_I4(capturedFields.Length); ilgen.Emit(OpCodes.Newarr, Types.Object); for (int i = 0; i < capturedFields.Length; i++) { ilgen.Emit(OpCodes.Dup); ilgen.EmitLdc_I4(i); ilgen.EmitLdarg(0); ilgen.Emit(OpCodes.Ldfld, capturedFields[i]); if (args[i].IsPrimitive) { Boxer.EmitBox(ilgen, args[i]); } else if (args[i].IsGhost) { args[i].EmitConvSignatureTypeToStackType(ilgen); } ilgen.Emit(OpCodes.Stelem, Types.Object); } MethodWrapper ctorSerializedLambda = ClassLoaderWrapper.LoadClassCritical("java.lang.invoke.SerializedLambda").GetMethodWrapper(StringConstants.INIT, "(Ljava.lang.Class;Ljava.lang.String;Ljava.lang.String;Ljava.lang.String;ILjava.lang.String;Ljava.lang.String;Ljava.lang.String;Ljava.lang.String;[Ljava.lang.Object;)V", false); ctorSerializedLambda.Link(); ctorSerializedLambda.EmitNewobj(ilgen); ilgen.Emit(OpCodes.Ret); ilgen.DoEmit(); if (!context.TypeWrapper.GetClassLoader().NoAutomagicSerialization) { // add .NET serialization interop support Serialization.MarkSerializable(tb); Serialization.AddGetObjectData(tb); } } return(ctor); }
private IEnumerable <java.net.URL> GetResourcesImpl(string unmangledName, bool getFromDelegates) { if (ReflectUtil.IsDynamicAssembly(assemblyLoader.Assembly)) { yield break; } #if !FIRST_PASS java.util.Enumeration urls = assemblyLoader.FindResources(unmangledName); while (urls.hasMoreElements()) { yield return((java.net.URL)urls.nextElement()); } #endif string name = JVM.MangleResourceName(unmangledName); if (assemblyLoader.Assembly.GetManifestResourceInfo(name) != null) { yield return(MakeResourceURL(assemblyLoader.Assembly, name)); } LazyInitExports(); if (exports != null) { List <int> assemblies; if (exports.TryGetValue(JVM.PersistableHash(unmangledName), out assemblies)) { foreach (int index in assemblies) { AssemblyLoader loader = exportedAssemblies[index]; if (loader == null) { Assembly asm = LoadAssemblyOrClearName(ref exportedAssemblyNames[index], true); if (asm == null) { continue; } loader = exportedAssemblies[index] = GetLoaderForExportedAssembly(asm); } #if !FIRST_PASS urls = loader.FindResources(unmangledName); while (urls.hasMoreElements()) { yield return((java.net.URL)urls.nextElement()); } #endif if (loader.Assembly.GetManifestResourceInfo(name) != null) { yield return(MakeResourceURL(loader.Assembly, name)); } } } } if (!getFromDelegates) { yield break; } for (int i = 0; i < delegates.Length; i++) { if (delegates[i] == null) { Assembly asm = LoadAssemblyOrClearName(ref references[i], false); if (asm != null) { delegates[i] = AssemblyClassLoader.FromAssembly(asm); } } if (delegates[i] != null) { foreach (java.net.URL url in delegates[i].FindResources(unmangledName)) { yield return(url); } } } if (!assemblyLoader.HasJavaModule) { foreach (java.net.URL url in GetBootstrapClassLoader().FindResources(unmangledName)) { yield return(url); } } }