зеркало из https://github.com/mono/ikvm-fork.git
5875 строки
174 KiB
C#
5875 строки
174 KiB
C#
/*
|
|
Copyright (C) 2002, 2003, 2004 Jeroen Frijters
|
|
|
|
This software is provided 'as-is', without any express or implied
|
|
warranty. In no event will the authors be held liable for any damages
|
|
arising from the use of this software.
|
|
|
|
Permission is granted to anyone to use this software for any purpose,
|
|
including commercial applications, and to alter it and redistribute it
|
|
freely, subject to the following restrictions:
|
|
|
|
1. The origin of this software must not be misrepresented; you must not
|
|
claim that you wrote the original software. If you use this software
|
|
in a product, an acknowledgment in the product documentation would be
|
|
appreciated but is not required.
|
|
2. Altered source versions must be plainly marked as such, and must not be
|
|
misrepresented as being the original software.
|
|
3. This notice may not be removed or altered from any source distribution.
|
|
|
|
Jeroen Frijters
|
|
jeroen@frijters.net
|
|
|
|
*/
|
|
using System;
|
|
using System.Collections;
|
|
using System.Reflection;
|
|
using System.Reflection.Emit;
|
|
using System.Diagnostics;
|
|
using IKVM.Runtime;
|
|
using IKVM.Attributes;
|
|
using IKVM.Internal;
|
|
|
|
using ILGenerator = CountingILGenerator;
|
|
|
|
sealed class MethodDescriptor
|
|
{
|
|
private string name;
|
|
private string sig;
|
|
|
|
internal MethodDescriptor(string name, string sig)
|
|
{
|
|
Debug.Assert(name != null && sig != null);
|
|
// class name in the sig should be dotted
|
|
Debug.Assert(sig.IndexOf('/') < 0);
|
|
|
|
this.name = name;
|
|
this.sig = sig;
|
|
}
|
|
|
|
internal string Name
|
|
{
|
|
get
|
|
{
|
|
return name;
|
|
}
|
|
}
|
|
|
|
internal string Signature
|
|
{
|
|
get
|
|
{
|
|
return sig;
|
|
}
|
|
}
|
|
|
|
public override bool Equals(object o)
|
|
{
|
|
MethodDescriptor md = o as MethodDescriptor;
|
|
return md != null && md.name == name && md.sig == sig;
|
|
}
|
|
|
|
public override int GetHashCode()
|
|
{
|
|
return name.GetHashCode() ^ sig.GetHashCode();
|
|
}
|
|
}
|
|
|
|
class EmitHelper
|
|
{
|
|
private static MethodInfo objectToString = typeof(object).GetMethod("ToString");
|
|
|
|
internal static void Throw(ILGenerator ilgen, string dottedClassName)
|
|
{
|
|
TypeWrapper exception = ClassLoaderWrapper.GetBootstrapClassLoader().LoadClassByDottedName(dottedClassName);
|
|
MethodDescriptor md = new MethodDescriptor("<init>", "()V");
|
|
MethodWrapper mw = exception.GetMethodWrapper(md, false);
|
|
mw.Link();
|
|
mw.EmitNewobj(ilgen);
|
|
ilgen.Emit(OpCodes.Throw);
|
|
}
|
|
|
|
internal static void Throw(ILGenerator ilgen, string dottedClassName, string message)
|
|
{
|
|
TypeWrapper exception = ClassLoaderWrapper.GetBootstrapClassLoader().LoadClassByDottedName(dottedClassName);
|
|
ilgen.Emit(OpCodes.Ldstr, message);
|
|
MethodDescriptor md = new MethodDescriptor("<init>", "(Ljava.lang.String;)V");
|
|
MethodWrapper mw = exception.GetMethodWrapper(md, false);
|
|
mw.Link();
|
|
mw.EmitNewobj(ilgen);
|
|
ilgen.Emit(OpCodes.Throw);
|
|
}
|
|
|
|
internal static void RunClassConstructor(ILGenerator ilgen, Type type)
|
|
{
|
|
// NOTE we're *not* running the .cctor if the class is not a Java class
|
|
// NOTE this is a potential versioning problem, if the base class lives in another assembly and doesn't
|
|
// have a <clinit> now, a newer version that does have a <clinit> will not have it's <clinit> called by us.
|
|
// A possible solution would be to use RuntimeHelpers.RunClassConstructor when "type" is a Java type and
|
|
// lives in another assembly as the caller (which we don't know at the moment).
|
|
FieldInfo field = type.GetField("__<clinit>", BindingFlags.Static | BindingFlags.NonPublic);
|
|
if(field != null)
|
|
{
|
|
ilgen.Emit(OpCodes.Ldsfld, field);
|
|
ilgen.Emit(OpCodes.Pop);
|
|
}
|
|
}
|
|
|
|
internal static void NullCheck(ILGenerator ilgen)
|
|
{
|
|
// I think this is the most efficient way to generate a NullReferenceException if the
|
|
// reference is null
|
|
ilgen.Emit(OpCodes.Ldvirtftn, objectToString);
|
|
ilgen.Emit(OpCodes.Pop);
|
|
}
|
|
}
|
|
|
|
class AttributeHelper
|
|
{
|
|
private static CustomAttributeBuilder ghostInterfaceAttribute;
|
|
private static CustomAttributeBuilder hideFromJavaAttribute;
|
|
private static CustomAttributeBuilder deprecatedAttribute;
|
|
private static CustomAttributeBuilder editorBrowsableNever;
|
|
private static ConstructorInfo implementsAttribute;
|
|
private static ConstructorInfo throwsAttribute;
|
|
private static ConstructorInfo sourceFileAttribute;
|
|
private static ConstructorInfo lineNumberTableAttribute;
|
|
|
|
internal static void SetEditorBrowsableNever(MethodBuilder mb)
|
|
{
|
|
if(editorBrowsableNever == null)
|
|
{
|
|
editorBrowsableNever = new CustomAttributeBuilder(typeof(System.ComponentModel.EditorBrowsableAttribute).GetConstructor(new Type[] { typeof(System.ComponentModel.EditorBrowsableState) }), new object[] { System.ComponentModel.EditorBrowsableState.Never });
|
|
}
|
|
mb.SetCustomAttribute(editorBrowsableNever);
|
|
}
|
|
|
|
internal static void SetEditorBrowsableNever(PropertyBuilder pb)
|
|
{
|
|
if(editorBrowsableNever == null)
|
|
{
|
|
editorBrowsableNever = new CustomAttributeBuilder(typeof(System.ComponentModel.EditorBrowsableAttribute).GetConstructor(new Type[] { typeof(System.ComponentModel.EditorBrowsableState) }), new object[] { System.ComponentModel.EditorBrowsableState.Never });
|
|
}
|
|
pb.SetCustomAttribute(editorBrowsableNever);
|
|
}
|
|
|
|
internal static void SetDeprecatedAttribute(MethodBase mb)
|
|
{
|
|
if(deprecatedAttribute == null)
|
|
{
|
|
deprecatedAttribute = new CustomAttributeBuilder(typeof(ObsoleteAttribute).GetConstructor(Type.EmptyTypes), new object[0]);
|
|
}
|
|
MethodBuilder method = mb as MethodBuilder;
|
|
if(method != null)
|
|
{
|
|
method.SetCustomAttribute(deprecatedAttribute);
|
|
}
|
|
else
|
|
{
|
|
((ConstructorBuilder)mb).SetCustomAttribute(deprecatedAttribute);
|
|
}
|
|
}
|
|
|
|
internal static void SetDeprecatedAttribute(TypeBuilder tb)
|
|
{
|
|
if(deprecatedAttribute == null)
|
|
{
|
|
deprecatedAttribute = new CustomAttributeBuilder(typeof(ObsoleteAttribute).GetConstructor(Type.EmptyTypes), new object[0]);
|
|
}
|
|
tb.SetCustomAttribute(deprecatedAttribute);
|
|
}
|
|
|
|
internal static void SetDeprecatedAttribute(FieldBuilder fb)
|
|
{
|
|
if(deprecatedAttribute == null)
|
|
{
|
|
deprecatedAttribute = new CustomAttributeBuilder(typeof(ObsoleteAttribute).GetConstructor(Type.EmptyTypes), new object[0]);
|
|
}
|
|
fb.SetCustomAttribute(deprecatedAttribute);
|
|
}
|
|
|
|
internal static void SetThrowsAttribute(MethodBase mb, string[] exceptions)
|
|
{
|
|
if(exceptions != null && exceptions.Length != 0)
|
|
{
|
|
if(throwsAttribute == null)
|
|
{
|
|
throwsAttribute = typeof(ThrowsAttribute).GetConstructor(new Type[] { typeof(string[]) });
|
|
}
|
|
if(mb is MethodBuilder)
|
|
{
|
|
MethodBuilder method = (MethodBuilder)mb;
|
|
method.SetCustomAttribute(new CustomAttributeBuilder(throwsAttribute, new object[] { exceptions }));
|
|
}
|
|
else
|
|
{
|
|
ConstructorBuilder constructor = (ConstructorBuilder)mb;
|
|
constructor.SetCustomAttribute(new CustomAttributeBuilder(throwsAttribute, new object[] { exceptions }));
|
|
}
|
|
}
|
|
}
|
|
|
|
internal static void SetGhostInterface(TypeBuilder typeBuilder)
|
|
{
|
|
if(ghostInterfaceAttribute == null)
|
|
{
|
|
ghostInterfaceAttribute = new CustomAttributeBuilder(typeof(GhostInterfaceAttribute).GetConstructor(Type.EmptyTypes), new object[0]);
|
|
}
|
|
typeBuilder.SetCustomAttribute(ghostInterfaceAttribute);
|
|
}
|
|
|
|
internal static void MirandaMethod(MethodBuilder mb)
|
|
{
|
|
CustomAttributeBuilder cab = new CustomAttributeBuilder(typeof(MirandaMethodAttribute).GetConstructor(Type.EmptyTypes), new object[0]);
|
|
mb.SetCustomAttribute(cab);
|
|
}
|
|
|
|
internal static bool IsMirandaMethod(MethodInfo mi)
|
|
{
|
|
return mi.IsDefined(typeof(MirandaMethodAttribute), false);
|
|
}
|
|
|
|
internal static void HideFromJava(TypeBuilder typeBuilder)
|
|
{
|
|
if(hideFromJavaAttribute == null)
|
|
{
|
|
hideFromJavaAttribute = new CustomAttributeBuilder(typeof(HideFromJavaAttribute).GetConstructor(Type.EmptyTypes), new object[0]);
|
|
}
|
|
typeBuilder.SetCustomAttribute(hideFromJavaAttribute);
|
|
}
|
|
|
|
internal static void HideFromJava(ConstructorBuilder cb)
|
|
{
|
|
if(hideFromJavaAttribute == null)
|
|
{
|
|
hideFromJavaAttribute = new CustomAttributeBuilder(typeof(HideFromJavaAttribute).GetConstructor(Type.EmptyTypes), new object[0]);
|
|
}
|
|
cb.SetCustomAttribute(hideFromJavaAttribute);
|
|
}
|
|
|
|
internal static void HideFromJava(MethodBuilder mb)
|
|
{
|
|
if(hideFromJavaAttribute == null)
|
|
{
|
|
hideFromJavaAttribute = new CustomAttributeBuilder(typeof(HideFromJavaAttribute).GetConstructor(Type.EmptyTypes), new object[0]);
|
|
}
|
|
mb.SetCustomAttribute(hideFromJavaAttribute);
|
|
}
|
|
|
|
internal static void HideFromJava(FieldBuilder fb)
|
|
{
|
|
if(hideFromJavaAttribute == null)
|
|
{
|
|
hideFromJavaAttribute = new CustomAttributeBuilder(typeof(HideFromJavaAttribute).GetConstructor(Type.EmptyTypes), new object[0]);
|
|
}
|
|
fb.SetCustomAttribute(hideFromJavaAttribute);
|
|
}
|
|
|
|
internal static bool IsHideFromJava(MemberInfo mi)
|
|
{
|
|
// NOTE all privatescope fields and methods are "hideFromJava"
|
|
// because Java cannot deal with the potential name clashes
|
|
FieldInfo fi = mi as FieldInfo;
|
|
if(fi != null && (fi.Attributes & FieldAttributes.FieldAccessMask) == FieldAttributes.PrivateScope)
|
|
{
|
|
return true;
|
|
}
|
|
MethodBase mb = mi as MethodBase;
|
|
if(mb != null && (mb.Attributes & MethodAttributes.MemberAccessMask) == MethodAttributes.PrivateScope)
|
|
{
|
|
return true;
|
|
}
|
|
return mi.IsDefined(typeof(HideFromJavaAttribute), false);
|
|
}
|
|
|
|
internal static void SetImplementsAttribute(TypeBuilder typeBuilder, TypeWrapper[] ifaceWrappers)
|
|
{
|
|
if(ifaceWrappers != null && ifaceWrappers.Length != 0)
|
|
{
|
|
string[] interfaces = new string[ifaceWrappers.Length];
|
|
for(int i = 0; i < interfaces.Length; i++)
|
|
{
|
|
interfaces[i] = ifaceWrappers[i].Name;
|
|
}
|
|
if(implementsAttribute == null)
|
|
{
|
|
implementsAttribute = typeof(ImplementsAttribute).GetConstructor(new Type[] { typeof(string[]) });
|
|
}
|
|
typeBuilder.SetCustomAttribute(new CustomAttributeBuilder(implementsAttribute, new object[] { interfaces }));
|
|
}
|
|
}
|
|
|
|
internal static Modifiers GetModifiers(MethodBase mb, bool assemblyIsPrivate)
|
|
{
|
|
object[] customAttribute = mb.GetCustomAttributes(typeof(ModifiersAttribute), false);
|
|
if(customAttribute.Length == 1)
|
|
{
|
|
return ((ModifiersAttribute)customAttribute[0]).Modifiers;
|
|
}
|
|
Modifiers modifiers = 0;
|
|
if(mb.IsPublic)
|
|
{
|
|
modifiers |= Modifiers.Public;
|
|
}
|
|
else if(mb.IsPrivate)
|
|
{
|
|
modifiers |= Modifiers.Private;
|
|
}
|
|
else if(mb.IsFamily || mb.IsFamilyOrAssembly)
|
|
{
|
|
modifiers |= Modifiers.Protected;
|
|
}
|
|
else if(assemblyIsPrivate)
|
|
{
|
|
modifiers |= Modifiers.Private;
|
|
}
|
|
// NOTE Java doesn't support non-virtual methods, but we set the Final modifier for
|
|
// non-virtual methods to approximate the semantics
|
|
if((mb.IsFinal || (!mb.IsVirtual && ((modifiers & Modifiers.Private) == 0))) && !mb.IsStatic && !mb.IsConstructor)
|
|
{
|
|
modifiers |= Modifiers.Final;
|
|
}
|
|
if(mb.IsAbstract)
|
|
{
|
|
modifiers |= Modifiers.Abstract;
|
|
}
|
|
else
|
|
{
|
|
// Some .NET interfaces (like System._AppDomain) have synchronized methods,
|
|
// Java doesn't allow synchronized on an abstract methods, so we ignore it for
|
|
// abstract methods.
|
|
if((mb.GetMethodImplementationFlags() & MethodImplAttributes.Synchronized) != 0)
|
|
{
|
|
modifiers |= Modifiers.Synchronized;
|
|
}
|
|
}
|
|
if(mb.IsStatic)
|
|
{
|
|
modifiers |= Modifiers.Static;
|
|
}
|
|
if((mb.Attributes & MethodAttributes.PinvokeImpl) != 0)
|
|
{
|
|
modifiers |= Modifiers.Native;
|
|
}
|
|
return modifiers;
|
|
}
|
|
|
|
internal static Modifiers GetModifiers(FieldInfo fi, bool assemblyIsPrivate)
|
|
{
|
|
object[] customAttribute = fi.GetCustomAttributes(typeof(ModifiersAttribute), false);
|
|
if(customAttribute.Length == 1)
|
|
{
|
|
return ((ModifiersAttribute)customAttribute[0]).Modifiers;
|
|
}
|
|
Modifiers modifiers = 0;
|
|
if(fi.IsPublic)
|
|
{
|
|
modifiers |= Modifiers.Public;
|
|
}
|
|
else if(fi.IsPrivate)
|
|
{
|
|
modifiers |= Modifiers.Private;
|
|
}
|
|
else if(fi.IsFamily || fi.IsFamilyOrAssembly)
|
|
{
|
|
modifiers |= Modifiers.Protected;
|
|
}
|
|
else if(assemblyIsPrivate)
|
|
{
|
|
modifiers |= Modifiers.Private;
|
|
}
|
|
if(fi.IsInitOnly || fi.IsLiteral)
|
|
{
|
|
modifiers |= Modifiers.Final;
|
|
}
|
|
if(fi.IsNotSerialized)
|
|
{
|
|
modifiers |= Modifiers.Transient;
|
|
}
|
|
if(fi.IsStatic)
|
|
{
|
|
modifiers |= Modifiers.Static;
|
|
}
|
|
// TODO reflection doesn't support volatile
|
|
return modifiers;
|
|
}
|
|
|
|
internal static void SetModifiers(MethodBuilder mb, Modifiers modifiers)
|
|
{
|
|
CustomAttributeBuilder customAttributeBuilder = new CustomAttributeBuilder(typeof(ModifiersAttribute).GetConstructor(new Type[] { typeof(Modifiers) }), new object[] { modifiers });
|
|
mb.SetCustomAttribute(customAttributeBuilder);
|
|
}
|
|
|
|
internal static void SetModifiers(ConstructorBuilder cb, Modifiers modifiers)
|
|
{
|
|
CustomAttributeBuilder customAttributeBuilder = new CustomAttributeBuilder(typeof(ModifiersAttribute).GetConstructor(new Type[] { typeof(Modifiers) }), new object[] { modifiers });
|
|
cb.SetCustomAttribute(customAttributeBuilder);
|
|
}
|
|
|
|
internal static void SetModifiers(FieldBuilder fb, Modifiers modifiers)
|
|
{
|
|
CustomAttributeBuilder customAttributeBuilder = new CustomAttributeBuilder(typeof(ModifiersAttribute).GetConstructor(new Type[] { typeof(Modifiers) }), new object[] { modifiers });
|
|
fb.SetCustomAttribute(customAttributeBuilder);
|
|
}
|
|
|
|
internal static void SetModifiers(TypeBuilder tb, Modifiers modifiers)
|
|
{
|
|
CustomAttributeBuilder customAttributeBuilder = new CustomAttributeBuilder(typeof(ModifiersAttribute).GetConstructor(new Type[] { typeof(Modifiers) }), new object[] { modifiers });
|
|
tb.SetCustomAttribute(customAttributeBuilder);
|
|
}
|
|
|
|
internal static void SetNameSig(MethodBase mb, string name, string sig)
|
|
{
|
|
CustomAttributeBuilder customAttributeBuilder = new CustomAttributeBuilder(typeof(NameSigAttribute).GetConstructor(new Type[] { typeof(string), typeof(string) }), new object[] { name, sig });
|
|
MethodBuilder method = mb as MethodBuilder;
|
|
if(method != null)
|
|
{
|
|
method.SetCustomAttribute(customAttributeBuilder);
|
|
}
|
|
else
|
|
{
|
|
((ConstructorBuilder)mb).SetCustomAttribute(customAttributeBuilder);
|
|
}
|
|
}
|
|
|
|
internal static void SetNameSig(FieldBuilder fb, string name, string sig)
|
|
{
|
|
CustomAttributeBuilder customAttributeBuilder = new CustomAttributeBuilder(typeof(NameSigAttribute).GetConstructor(new Type[] { typeof(string), typeof(string) }), new object[] { name, sig });
|
|
fb.SetCustomAttribute(customAttributeBuilder);
|
|
}
|
|
|
|
internal static byte[] FreezeDryType(Type type)
|
|
{
|
|
System.IO.MemoryStream mem = new System.IO.MemoryStream();
|
|
System.IO.BinaryWriter bw = new System.IO.BinaryWriter(mem, System.Text.UTF8Encoding.UTF8);
|
|
bw.Write((short)1);
|
|
bw.Write(type.FullName);
|
|
bw.Write((short)0);
|
|
return mem.ToArray();
|
|
}
|
|
|
|
internal static void SetInnerClass(TypeBuilder typeBuilder, string innerClass, string outerClass, string name, Modifiers modifiers)
|
|
{
|
|
Type[] argTypes = new Type[] { typeof(string), typeof(string), typeof(string), typeof(Modifiers) };
|
|
object[] args = new object[] { innerClass, outerClass, name, modifiers };
|
|
ConstructorInfo ci = typeof(InnerClassAttribute).GetConstructor(argTypes);
|
|
CustomAttributeBuilder customAttributeBuilder = new CustomAttributeBuilder(ci, args);
|
|
typeBuilder.SetCustomAttribute(customAttributeBuilder);
|
|
}
|
|
|
|
internal static void SetSourceFile(TypeBuilder typeBuilder, string filename)
|
|
{
|
|
if(sourceFileAttribute == null)
|
|
{
|
|
sourceFileAttribute = typeof(SourceFileAttribute).GetConstructor(new Type[] { typeof(string) });
|
|
}
|
|
typeBuilder.SetCustomAttribute(new CustomAttributeBuilder(sourceFileAttribute, new object[] { filename }));
|
|
}
|
|
|
|
internal static void SetLineNumberTable(MethodBase mb, byte[] table)
|
|
{
|
|
if(lineNumberTableAttribute == null)
|
|
{
|
|
lineNumberTableAttribute = typeof(LineNumberTableAttribute).GetConstructor(new Type[] { typeof(byte[]) });
|
|
}
|
|
if(mb is ConstructorBuilder)
|
|
{
|
|
((ConstructorBuilder)mb).SetCustomAttribute(new CustomAttributeBuilder(lineNumberTableAttribute, new object[] { table }));
|
|
}
|
|
else
|
|
{
|
|
((MethodBuilder)mb).SetCustomAttribute(new CustomAttributeBuilder(lineNumberTableAttribute, new object[] { table }));
|
|
}
|
|
}
|
|
}
|
|
|
|
abstract class TypeWrapper
|
|
{
|
|
private readonly ClassLoaderWrapper classLoader;
|
|
private readonly string name; // java name (e.g. java.lang.Object)
|
|
private readonly Modifiers modifiers;
|
|
private readonly Hashtable methods = new Hashtable();
|
|
private readonly Hashtable fields = new Hashtable();
|
|
private readonly TypeWrapper baseWrapper;
|
|
private bool hasIncompleteInterfaceImplementation;
|
|
internal static readonly TypeWrapper[] EmptyArray = new TypeWrapper[0];
|
|
internal const Modifiers UnloadableModifiersHack = Modifiers.Final | Modifiers.Interface | Modifiers.Private;
|
|
internal const Modifiers VerifierTypeModifiersHack = Modifiers.Final | Modifiers.Interface;
|
|
|
|
internal TypeWrapper(Modifiers modifiers, string name, TypeWrapper baseWrapper, ClassLoaderWrapper classLoader)
|
|
{
|
|
Profiler.Count("TypeWrapper");
|
|
// class name should be dotted or null for primitives
|
|
Debug.Assert(name == null || name.IndexOf('/') < 0);
|
|
|
|
this.modifiers = modifiers;
|
|
this.name = name;
|
|
this.baseWrapper = baseWrapper;
|
|
this.classLoader = classLoader;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
return GetType().Name + "[" + name + "]";
|
|
}
|
|
|
|
internal bool HasIncompleteInterfaceImplementation
|
|
{
|
|
get
|
|
{
|
|
return hasIncompleteInterfaceImplementation || (baseWrapper != null && baseWrapper.HasIncompleteInterfaceImplementation);
|
|
}
|
|
set
|
|
{
|
|
hasIncompleteInterfaceImplementation = value;
|
|
}
|
|
}
|
|
|
|
internal virtual bool HasStaticInitializer
|
|
{
|
|
get
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// a ghost is an interface that appears to be implemented by a .NET type
|
|
// (e.g. System.String (aka java.lang.String) appears to implement java.lang.CharSequence,
|
|
// so java.lang.CharSequence is a ghost)
|
|
internal virtual bool IsGhost
|
|
{
|
|
get
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// is this an array type of which the ultimate element type is a ghost?
|
|
internal bool IsGhostArray
|
|
{
|
|
get
|
|
{
|
|
return IsArray && (ElementTypeWrapper.IsGhost || ElementTypeWrapper.IsGhostArray);
|
|
}
|
|
}
|
|
|
|
internal virtual FieldInfo GhostRefField
|
|
{
|
|
get
|
|
{
|
|
throw new InvalidOperationException();
|
|
}
|
|
}
|
|
|
|
internal virtual bool IsRemapped
|
|
{
|
|
get
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
internal bool IsArray
|
|
{
|
|
get
|
|
{
|
|
return name != null && name[0] == '[';
|
|
}
|
|
}
|
|
|
|
// NOTE for non-array types this returns 0
|
|
internal int ArrayRank
|
|
{
|
|
get
|
|
{
|
|
int i = 0;
|
|
if(name != null)
|
|
{
|
|
while(name[i] == '[')
|
|
{
|
|
i++;
|
|
}
|
|
}
|
|
return i;
|
|
}
|
|
}
|
|
|
|
internal bool IsNonPrimitiveValueType
|
|
{
|
|
get
|
|
{
|
|
return this != VerifierTypeWrapper.Null && !IsPrimitive && !IsGhost && TypeAsTBD.IsValueType;
|
|
}
|
|
}
|
|
|
|
internal bool IsPrimitive
|
|
{
|
|
get
|
|
{
|
|
return name == null;
|
|
}
|
|
}
|
|
|
|
internal bool IsWidePrimitive
|
|
{
|
|
get
|
|
{
|
|
return this == PrimitiveTypeWrapper.LONG || this == PrimitiveTypeWrapper.DOUBLE;
|
|
}
|
|
}
|
|
|
|
internal bool IsIntOnStackPrimitive
|
|
{
|
|
get
|
|
{
|
|
return name == null &&
|
|
(this == PrimitiveTypeWrapper.BOOLEAN ||
|
|
this == PrimitiveTypeWrapper.BYTE ||
|
|
this == PrimitiveTypeWrapper.CHAR ||
|
|
this == PrimitiveTypeWrapper.SHORT ||
|
|
this == PrimitiveTypeWrapper.INT);
|
|
}
|
|
}
|
|
|
|
internal bool IsUnloadable
|
|
{
|
|
get
|
|
{
|
|
// NOTE we abuse modifiers to note unloadable classes
|
|
return modifiers == UnloadableModifiersHack;
|
|
}
|
|
}
|
|
|
|
internal bool IsVerifierType
|
|
{
|
|
get
|
|
{
|
|
// NOTE we abuse modifiers to note verifier types
|
|
return modifiers == VerifierTypeModifiersHack;
|
|
}
|
|
}
|
|
|
|
internal virtual bool IsMapUnsafeException
|
|
{
|
|
get
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
internal Modifiers Modifiers
|
|
{
|
|
get
|
|
{
|
|
return modifiers;
|
|
}
|
|
}
|
|
|
|
// since for inner classes, the modifiers returned by Class.getModifiers are different from the actual
|
|
// modifiers (as used by the VM access control mechanism), we have this additional property
|
|
internal virtual Modifiers ReflectiveModifiers
|
|
{
|
|
get
|
|
{
|
|
return modifiers;
|
|
}
|
|
}
|
|
|
|
internal bool IsPublic
|
|
{
|
|
get
|
|
{
|
|
return (modifiers & Modifiers.Public) != 0;
|
|
}
|
|
}
|
|
|
|
internal bool IsAbstract
|
|
{
|
|
get
|
|
{
|
|
// interfaces don't need to marked abstract explicitly (and javac 1.1 didn't do it)
|
|
return (modifiers & (Modifiers.Abstract | Modifiers.Interface)) != 0;
|
|
}
|
|
}
|
|
|
|
internal bool IsFinal
|
|
{
|
|
get
|
|
{
|
|
return (modifiers & Modifiers.Final) != 0;
|
|
}
|
|
}
|
|
|
|
internal bool IsInterface
|
|
{
|
|
get
|
|
{
|
|
Debug.Assert(!IsUnloadable && !IsVerifierType);
|
|
return (modifiers & Modifiers.Interface) != 0;
|
|
}
|
|
}
|
|
|
|
// this exists because interfaces and arrays of interfaces are treated specially
|
|
// by the verifier, interfaces don't have a common base (other than java.lang.Object)
|
|
// so any object reference or object array reference can be used where an interface
|
|
// or interface array reference is expected (the compiler will insert the required casts).
|
|
internal bool IsInterfaceOrInterfaceArray
|
|
{
|
|
get
|
|
{
|
|
TypeWrapper tw = this;
|
|
while(tw.IsArray)
|
|
{
|
|
tw = tw.ElementTypeWrapper;
|
|
}
|
|
return tw.IsInterface;
|
|
}
|
|
}
|
|
|
|
internal virtual ClassLoaderWrapper GetClassLoader()
|
|
{
|
|
return classLoader;
|
|
}
|
|
|
|
protected abstract FieldWrapper GetFieldImpl(string fieldName, string fieldSig);
|
|
|
|
internal virtual FieldWrapper GetFieldWrapper(string fieldName, string fieldSig)
|
|
{
|
|
lock(fields.SyncRoot)
|
|
{
|
|
string key = fieldName + fieldSig;
|
|
FieldWrapper fae = (FieldWrapper)fields[key];
|
|
if(fae == null)
|
|
{
|
|
fae = GetFieldImpl(fieldName, fieldSig);
|
|
if(fae == null)
|
|
{
|
|
foreach(TypeWrapper iface in this.Interfaces)
|
|
{
|
|
fae = iface.GetFieldWrapper(fieldName, fieldSig);
|
|
if(fae != null)
|
|
{
|
|
return fae;
|
|
}
|
|
}
|
|
if(baseWrapper != null)
|
|
{
|
|
return baseWrapper.GetFieldWrapper(fieldName, fieldSig);
|
|
}
|
|
return null;
|
|
}
|
|
fields[key] = fae;
|
|
}
|
|
return fae;
|
|
}
|
|
}
|
|
|
|
// TODO figure out when it is safe to call this
|
|
// HACK for now we assume that the method hashtable has always been filled when this method is called (by java.lang.Class)
|
|
// UPDATE the above concerns should no longer apply, DynamicTypeWrappers now publish their methods eagerly and all
|
|
// others (derived from LazyTypeWrapper) override this method to do the publishing
|
|
internal virtual MethodWrapper[] GetMethods()
|
|
{
|
|
MethodWrapper[] wrappers = new MethodWrapper[methods.Count];
|
|
methods.Values.CopyTo(wrappers, 0);
|
|
return wrappers;
|
|
}
|
|
|
|
// TODO figure out when it is safe to call this
|
|
// HACK for now we assume that the fields hashtable has always been filled when this method is called (by java.lang.Class)
|
|
internal virtual FieldWrapper[] GetFields()
|
|
{
|
|
FieldWrapper[] wrappers = new FieldWrapper[fields.Count];
|
|
fields.Values.CopyTo(wrappers, 0);
|
|
return wrappers;
|
|
}
|
|
|
|
internal virtual MethodWrapper GetMethodWrapper(MethodDescriptor md, bool inherit)
|
|
{
|
|
MethodWrapper mw = (MethodWrapper)methods[md];
|
|
if(mw == null && inherit && baseWrapper != null)
|
|
{
|
|
mw = baseWrapper.GetMethodWrapper(md, inherit);
|
|
}
|
|
return mw;
|
|
}
|
|
|
|
internal void AddMethod(MethodWrapper method)
|
|
{
|
|
Debug.Assert(method != null);
|
|
methods[method.Descriptor] = method;
|
|
}
|
|
|
|
internal void AddField(FieldWrapper field)
|
|
{
|
|
Debug.Assert(field != null);
|
|
fields[field.Name + field.FieldTypeWrapper.SigName] = field;
|
|
}
|
|
|
|
internal string Name
|
|
{
|
|
get
|
|
{
|
|
return name;
|
|
}
|
|
}
|
|
|
|
// the name of the type as it appears in a Java signature string (e.g. "Ljava.lang.Object;" or "I")
|
|
internal virtual string SigName
|
|
{
|
|
get
|
|
{
|
|
return "L" + this.Name + ";";
|
|
}
|
|
}
|
|
|
|
internal abstract Assembly Assembly
|
|
{
|
|
get;
|
|
}
|
|
|
|
// returns true iff wrapper is allowed to access us
|
|
internal bool IsAccessibleFrom(TypeWrapper wrapper)
|
|
{
|
|
return IsPublic || IsInSamePackageAs(wrapper);
|
|
}
|
|
|
|
internal bool IsInSamePackageAs(TypeWrapper wrapper)
|
|
{
|
|
if(GetClassLoader() == wrapper.GetClassLoader() &&
|
|
// Both types must also be in the same assembly, otherwise
|
|
// the packages are not accessible.
|
|
wrapper.Assembly == this.Assembly)
|
|
{
|
|
int index1 = name.LastIndexOf('.');
|
|
int index2 = wrapper.name.LastIndexOf('.');
|
|
if(index1 == -1 && index2 == -1)
|
|
{
|
|
return true;
|
|
}
|
|
// for array types we need to skip the brackets
|
|
int skip1 = 0;
|
|
int skip2 = 0;
|
|
while(name[skip1] == '[')
|
|
{
|
|
skip1++;
|
|
}
|
|
while(wrapper.name[skip2] == '[')
|
|
{
|
|
skip2++;
|
|
}
|
|
if(skip1 > 0)
|
|
{
|
|
// skip over the L that follows the brackets
|
|
skip1++;
|
|
}
|
|
if(skip2 > 0)
|
|
{
|
|
// skip over the L that follows the brackets
|
|
skip2++;
|
|
}
|
|
if((index1 - skip1) != (index2 - skip2))
|
|
{
|
|
return false;
|
|
}
|
|
return String.CompareOrdinal(name, skip1, wrapper.name, skip2, index1 - skip1) == 0;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
internal abstract Type TypeAsTBD
|
|
{
|
|
get;
|
|
}
|
|
|
|
internal virtual TypeBuilder TypeAsBuilder
|
|
{
|
|
get
|
|
{
|
|
TypeBuilder typeBuilder = TypeAsTBD as TypeBuilder;
|
|
Debug.Assert(typeBuilder != null);
|
|
return typeBuilder;
|
|
}
|
|
}
|
|
|
|
internal Type TypeAsFieldType
|
|
{
|
|
get
|
|
{
|
|
return TypeAsParameterType;
|
|
}
|
|
}
|
|
|
|
internal Type TypeAsParameterType
|
|
{
|
|
get
|
|
{
|
|
if(IsUnloadable)
|
|
{
|
|
return typeof(object);
|
|
}
|
|
if(IsGhostArray)
|
|
{
|
|
int rank = ArrayRank;
|
|
string type = "System.Object";
|
|
for(int i = 0; i < rank; i++)
|
|
{
|
|
type += "[]";
|
|
}
|
|
return Type.GetType(type, true);
|
|
}
|
|
return TypeAsTBD;
|
|
}
|
|
}
|
|
|
|
internal virtual Type TypeAsBaseType
|
|
{
|
|
get
|
|
{
|
|
return TypeAsTBD;
|
|
}
|
|
}
|
|
|
|
internal Type TypeAsLocalOrStackType
|
|
{
|
|
get
|
|
{
|
|
// HACK as a convenience to the compiler, we replace return address types with typeof(int)
|
|
if(VerifierTypeWrapper.IsRet(this))
|
|
{
|
|
return typeof(int);
|
|
}
|
|
if(IsUnloadable || IsGhost)
|
|
{
|
|
return typeof(object);
|
|
}
|
|
if(IsNonPrimitiveValueType)
|
|
{
|
|
// return either System.ValueType or System.Enum
|
|
return TypeAsTBD.BaseType;
|
|
}
|
|
if(IsGhostArray)
|
|
{
|
|
int rank = ArrayRank;
|
|
string type = "System.Object";
|
|
for(int i = 0; i < rank; i++)
|
|
{
|
|
type += "[]";
|
|
}
|
|
return Type.GetType(type, true);
|
|
}
|
|
return TypeAsTBD;
|
|
}
|
|
}
|
|
|
|
/** <summary>Use this if the type is used as an array or array element</summary> */
|
|
internal Type TypeAsArrayType
|
|
{
|
|
get
|
|
{
|
|
if(IsUnloadable || IsGhost)
|
|
{
|
|
return typeof(object);
|
|
}
|
|
if(IsGhostArray)
|
|
{
|
|
int rank = ArrayRank;
|
|
string type = "System.Object";
|
|
for(int i = 0; i < rank; i++)
|
|
{
|
|
type += "[]";
|
|
}
|
|
return Type.GetType(type, true);
|
|
}
|
|
Type t = TypeAsTBD;
|
|
// HACK BYTE[]
|
|
//if(t == typeof(sbyte))
|
|
//{
|
|
// return typeof(byte);
|
|
//}
|
|
return t;
|
|
}
|
|
}
|
|
|
|
internal Type TypeAsExceptionType
|
|
{
|
|
get
|
|
{
|
|
if(IsUnloadable)
|
|
{
|
|
return typeof(Exception);
|
|
}
|
|
return TypeAsTBD;
|
|
}
|
|
}
|
|
|
|
internal TypeWrapper BaseTypeWrapper
|
|
{
|
|
get
|
|
{
|
|
return baseWrapper;
|
|
}
|
|
}
|
|
|
|
internal TypeWrapper ElementTypeWrapper
|
|
{
|
|
get
|
|
{
|
|
Debug.Assert(!this.IsUnloadable);
|
|
Debug.Assert(this == VerifierTypeWrapper.Null || this.IsArray);
|
|
|
|
if(this == VerifierTypeWrapper.Null)
|
|
{
|
|
return VerifierTypeWrapper.Null;
|
|
}
|
|
|
|
// TODO consider caching the element type
|
|
switch(name[1])
|
|
{
|
|
case '[':
|
|
// NOTE this call to LoadClassByDottedNameFast can never fail and will not trigger a class load
|
|
// (because the ultimate element type was already loaded when this type was created)
|
|
return classLoader.LoadClassByDottedNameFast(name.Substring(1));
|
|
case 'L':
|
|
// NOTE this call to LoadClassByDottedNameFast can never fail and will not trigger a class load
|
|
// (because the ultimate element type was already loaded when this type was created)
|
|
return classLoader.LoadClassByDottedNameFast(name.Substring(2, name.Length - 3));
|
|
case 'Z':
|
|
return PrimitiveTypeWrapper.BOOLEAN;
|
|
case 'B':
|
|
return PrimitiveTypeWrapper.BYTE;
|
|
case 'S':
|
|
return PrimitiveTypeWrapper.SHORT;
|
|
case 'C':
|
|
return PrimitiveTypeWrapper.CHAR;
|
|
case 'I':
|
|
return PrimitiveTypeWrapper.INT;
|
|
case 'J':
|
|
return PrimitiveTypeWrapper.LONG;
|
|
case 'F':
|
|
return PrimitiveTypeWrapper.FLOAT;
|
|
case 'D':
|
|
return PrimitiveTypeWrapper.DOUBLE;
|
|
default:
|
|
throw new InvalidOperationException(name);
|
|
}
|
|
}
|
|
}
|
|
|
|
internal TypeWrapper MakeArrayType(int rank)
|
|
{
|
|
// NOTE this call to LoadClassByDottedNameFast can never fail and will not trigger a class load
|
|
return GetClassLoader().LoadClassByDottedNameFast(new String('[', rank) + this.SigName);
|
|
}
|
|
|
|
internal bool ImplementsInterface(TypeWrapper interfaceWrapper)
|
|
{
|
|
TypeWrapper typeWrapper = this;
|
|
while(typeWrapper != null)
|
|
{
|
|
TypeWrapper[] interfaces = typeWrapper.Interfaces;
|
|
for(int i = 0; i < interfaces.Length; i++)
|
|
{
|
|
if(interfaces[i] == interfaceWrapper)
|
|
{
|
|
return true;
|
|
}
|
|
if(interfaces[i].ImplementsInterface(interfaceWrapper))
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
typeWrapper = typeWrapper.BaseTypeWrapper;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
internal bool IsSubTypeOf(TypeWrapper baseType)
|
|
{
|
|
// make sure IsSubTypeOf isn't used on primitives
|
|
Debug.Assert(!this.IsPrimitive);
|
|
Debug.Assert(!baseType.IsPrimitive);
|
|
// can't be used on Unloadable
|
|
Debug.Assert(!this.IsUnloadable);
|
|
Debug.Assert(!baseType.IsUnloadable);
|
|
|
|
if(baseType.IsInterface)
|
|
{
|
|
if(baseType == this)
|
|
{
|
|
return true;
|
|
}
|
|
return ImplementsInterface(baseType);
|
|
}
|
|
// NOTE this isn't just an optimization, it is also required when this is an interface
|
|
if(baseType == CoreClasses.java.lang.Object.Wrapper)
|
|
{
|
|
return true;
|
|
}
|
|
TypeWrapper subType = this;
|
|
while(subType != baseType)
|
|
{
|
|
subType = subType.BaseTypeWrapper;
|
|
if(subType == null)
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
internal bool IsAssignableTo(TypeWrapper wrapper)
|
|
{
|
|
if(this == wrapper)
|
|
{
|
|
return true;
|
|
}
|
|
if(this.IsPrimitive || wrapper.IsPrimitive)
|
|
{
|
|
return false;
|
|
}
|
|
if(this == VerifierTypeWrapper.Null)
|
|
{
|
|
return true;
|
|
}
|
|
if(wrapper.IsInterface)
|
|
{
|
|
return ImplementsInterface(wrapper);
|
|
}
|
|
int rank1 = this.ArrayRank;
|
|
int rank2 = wrapper.ArrayRank;
|
|
if(rank1 > 0 && rank2 > 0)
|
|
{
|
|
rank1--;
|
|
rank2--;
|
|
TypeWrapper elem1 = this.ElementTypeWrapper;
|
|
TypeWrapper elem2 = wrapper.ElementTypeWrapper;
|
|
while(rank1 != 0 && rank2 != 0)
|
|
{
|
|
elem1 = elem1.ElementTypeWrapper;
|
|
elem2 = elem2.ElementTypeWrapper;
|
|
rank1--;
|
|
rank2--;
|
|
}
|
|
return !elem1.IsNonPrimitiveValueType && elem1.IsSubTypeOf(elem2);
|
|
}
|
|
return this.IsSubTypeOf(wrapper);
|
|
}
|
|
|
|
internal abstract TypeWrapper[] Interfaces
|
|
{
|
|
get;
|
|
}
|
|
|
|
// NOTE this property can only be called for finished types!
|
|
internal abstract TypeWrapper[] InnerClasses
|
|
{
|
|
get;
|
|
}
|
|
|
|
// NOTE this property can only be called for finished types!
|
|
internal abstract TypeWrapper DeclaringTypeWrapper
|
|
{
|
|
get;
|
|
}
|
|
|
|
internal void Finish()
|
|
{
|
|
Finish(false);
|
|
}
|
|
|
|
internal abstract void Finish(bool forDebugSave);
|
|
|
|
private void ImplementInterfaceMethodStubImpl(MethodWrapper ifmethod, TypeBuilder typeBuilder, DynamicTypeWrapper wrapper)
|
|
{
|
|
MethodDescriptor md = ifmethod.Descriptor;
|
|
// we're mangling the name to prevent subclasses from accidentally overriding this method and to
|
|
// prevent clashes with overloaded method stubs that are erased to the same signature (e.g. unloadable types and ghost arrays)
|
|
string mangledName = this.Name + "/" + ifmethod.Name + ifmethod.Signature;
|
|
MethodWrapper mce = null;
|
|
TypeWrapper lookup = wrapper;
|
|
while(lookup != null)
|
|
{
|
|
mce = lookup.GetMethodWrapper(md, true);
|
|
if(mce == null || !mce.IsStatic)
|
|
{
|
|
break;
|
|
}
|
|
lookup = mce.DeclaringType.BaseTypeWrapper;
|
|
}
|
|
if(mce != null)
|
|
{
|
|
if(!mce.IsPublic)
|
|
{
|
|
// NOTE according to the ECMA spec it isn't legal for a privatescope method to be virtual, but this works and
|
|
// it makes sense, so I hope the spec is wrong
|
|
// UPDATE unfortunately, according to Serge Lidin the spec is correct, and it is not allowed to have virtual privatescope
|
|
// methods. Sigh! So I have to use private methods and mangle the name
|
|
MethodBuilder mb = typeBuilder.DefineMethod(mangledName, MethodAttributes.NewSlot | MethodAttributes.Private | MethodAttributes.Virtual | MethodAttributes.Final, ifmethod.ReturnTypeForDefineMethod, ifmethod.GetParametersForDefineMethod());
|
|
AttributeHelper.HideFromJava(mb);
|
|
EmitHelper.Throw(mb.GetILGenerator(), "java.lang.IllegalAccessError", wrapper.Name + "." + md.Name + md.Signature);
|
|
typeBuilder.DefineMethodOverride(mb, (MethodInfo)ifmethod.GetMethod());
|
|
wrapper.HasIncompleteInterfaceImplementation = true;
|
|
}
|
|
else if(mce.GetMethod() == null || mce.RealName != ifmethod.RealName)
|
|
{
|
|
MethodBuilder mb = typeBuilder.DefineMethod(mangledName, MethodAttributes.NewSlot | MethodAttributes.Private | MethodAttributes.Virtual | MethodAttributes.Final, ifmethod.ReturnTypeForDefineMethod, ifmethod.GetParametersForDefineMethod());
|
|
AttributeHelper.HideFromJava(mb);
|
|
ILGenerator ilGenerator = mb.GetILGenerator();
|
|
ilGenerator.Emit(OpCodes.Ldarg_0);
|
|
int argc = mce.GetParameters().Length;
|
|
for(int n = 0; n < argc; n++)
|
|
{
|
|
ilGenerator.Emit(OpCodes.Ldarg_S, (byte)(n + 1));
|
|
}
|
|
mce.EmitCallvirt(ilGenerator);
|
|
ilGenerator.Emit(OpCodes.Ret);
|
|
typeBuilder.DefineMethodOverride(mb, (MethodInfo)ifmethod.GetMethod());
|
|
}
|
|
else if(mce.DeclaringType.TypeAsTBD.Assembly != typeBuilder.Assembly)
|
|
{
|
|
// NOTE methods inherited from base classes in a different assembly do *not* automatically implement
|
|
// interface methods, so we have to generate a stub here that doesn't do anything but call the base
|
|
// implementation
|
|
MethodBuilder mb = typeBuilder.DefineMethod(mangledName, MethodAttributes.NewSlot | MethodAttributes.Private | MethodAttributes.Virtual | MethodAttributes.Final, ifmethod.ReturnTypeForDefineMethod, ifmethod.GetParametersForDefineMethod());
|
|
typeBuilder.DefineMethodOverride(mb, (MethodInfo)ifmethod.GetMethod());
|
|
AttributeHelper.HideFromJava(mb);
|
|
ILGenerator ilGenerator = mb.GetILGenerator();
|
|
ilGenerator.Emit(OpCodes.Ldarg_0);
|
|
int argc = mce.GetParameters().Length;
|
|
for(int n = 0; n < argc; n++)
|
|
{
|
|
ilGenerator.Emit(OpCodes.Ldarg_S, (byte)(n + 1));
|
|
}
|
|
mce.EmitCallvirt(ilGenerator);
|
|
ilGenerator.Emit(OpCodes.Ret);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if(!wrapper.IsAbstract)
|
|
{
|
|
// the type doesn't implement the interface method and isn't abstract either. The JVM allows this, but the CLR doesn't,
|
|
// so we have to create a stub method that throws an AbstractMethodError
|
|
MethodBuilder mb = typeBuilder.DefineMethod(mangledName, MethodAttributes.NewSlot | MethodAttributes.Private | MethodAttributes.Virtual | MethodAttributes.Final, ifmethod.ReturnTypeForDefineMethod, ifmethod.GetParametersForDefineMethod());
|
|
AttributeHelper.HideFromJava(mb);
|
|
EmitHelper.Throw(mb.GetILGenerator(), "java.lang.AbstractMethodError", wrapper.Name + "." + md.Name + md.Signature);
|
|
typeBuilder.DefineMethodOverride(mb, (MethodInfo)ifmethod.GetMethod());
|
|
wrapper.HasIncompleteInterfaceImplementation = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
internal void ImplementInterfaceMethodStubs(TypeBuilder typeBuilder, DynamicTypeWrapper wrapper, Hashtable doneSet)
|
|
{
|
|
Debug.Assert(this.IsInterface);
|
|
|
|
// make sure we don't do the same method twice
|
|
if(doneSet.ContainsKey(this))
|
|
{
|
|
return;
|
|
}
|
|
doneSet.Add(this, this);
|
|
foreach(MethodWrapper method in GetMethods())
|
|
{
|
|
if(!method.IsStatic)
|
|
{
|
|
ImplementInterfaceMethodStubImpl(method, typeBuilder, wrapper);
|
|
}
|
|
}
|
|
TypeWrapper[] interfaces = Interfaces;
|
|
for(int i = 0; i < interfaces.Length; i++)
|
|
{
|
|
interfaces[i].ImplementInterfaceMethodStubs(typeBuilder, wrapper, doneSet);
|
|
}
|
|
}
|
|
|
|
[Conditional("DEBUG")]
|
|
internal static void AssertFinished(Type type)
|
|
{
|
|
if(type != null)
|
|
{
|
|
while(type.IsArray)
|
|
{
|
|
type = type.GetElementType();
|
|
}
|
|
Debug.Assert(!(type is TypeBuilder));
|
|
}
|
|
}
|
|
|
|
internal void RunClassInit()
|
|
{
|
|
System.Runtime.CompilerServices.RuntimeHelpers.RunClassConstructor(TypeAsTBD.TypeHandle);
|
|
}
|
|
|
|
internal void EmitUnbox(ILGenerator ilgen)
|
|
{
|
|
Debug.Assert(this.IsNonPrimitiveValueType);
|
|
|
|
Type type = this.TypeAsTBD;
|
|
// NOTE if the reference is null, we treat it as a default instance of the value type.
|
|
ilgen.Emit(OpCodes.Dup);
|
|
Label label1 = ilgen.DefineLabel();
|
|
ilgen.Emit(OpCodes.Brtrue_S, label1);
|
|
ilgen.Emit(OpCodes.Pop);
|
|
ilgen.Emit(OpCodes.Ldloc, ilgen.DeclareLocal(type));
|
|
Label label2 = ilgen.DefineLabel();
|
|
ilgen.Emit(OpCodes.Br_S, label2);
|
|
ilgen.MarkLabel(label1);
|
|
ilgen.Emit(OpCodes.Unbox, type);
|
|
ilgen.Emit(OpCodes.Ldobj, type);
|
|
ilgen.MarkLabel(label2);
|
|
}
|
|
|
|
internal void EmitBox(ILGenerator ilgen)
|
|
{
|
|
Debug.Assert(this.IsNonPrimitiveValueType);
|
|
|
|
ilgen.Emit(OpCodes.Box, this.TypeAsTBD);
|
|
}
|
|
|
|
// NOTE sourceType is optional and only used for special types (e.g. interfaces),
|
|
// it is *not* used to automatically downcast
|
|
internal void EmitConvStackToParameterType(ILGenerator ilgen, TypeWrapper sourceType)
|
|
{
|
|
if(!IsUnloadable)
|
|
{
|
|
if(IsGhost)
|
|
{
|
|
LocalBuilder local1 = ilgen.DeclareLocal(TypeAsLocalOrStackType);
|
|
ilgen.Emit(OpCodes.Stloc, local1);
|
|
LocalBuilder local2 = ilgen.DeclareLocal(TypeAsParameterType);
|
|
ilgen.Emit(OpCodes.Ldloca, local2);
|
|
ilgen.Emit(OpCodes.Ldloc, local1);
|
|
ilgen.Emit(OpCodes.Stfld, GhostRefField);
|
|
ilgen.Emit(OpCodes.Ldloca, local2);
|
|
ilgen.Emit(OpCodes.Ldobj, TypeAsParameterType);
|
|
}
|
|
// because of the way interface merging works, any reference is valid
|
|
// for any interface reference
|
|
else if(IsInterfaceOrInterfaceArray && (sourceType == null || sourceType.IsUnloadable || !sourceType.IsAssignableTo(this)))
|
|
{
|
|
ilgen.Emit(OpCodes.Castclass, TypeAsTBD);
|
|
}
|
|
else if(IsNonPrimitiveValueType)
|
|
{
|
|
EmitUnbox(ilgen);
|
|
}
|
|
}
|
|
}
|
|
|
|
internal void EmitConvParameterToStackType(ILGenerator ilgen)
|
|
{
|
|
if(IsUnloadable)
|
|
{
|
|
// nothing to do
|
|
}
|
|
else if(IsNonPrimitiveValueType)
|
|
{
|
|
EmitBox(ilgen);
|
|
}
|
|
else if(IsGhost)
|
|
{
|
|
LocalBuilder local = ilgen.DeclareLocal(TypeAsParameterType);
|
|
ilgen.Emit(OpCodes.Stloc, local);
|
|
ilgen.Emit(OpCodes.Ldloca, local);
|
|
ilgen.Emit(OpCodes.Ldfld, GhostRefField);
|
|
}
|
|
}
|
|
|
|
internal virtual void EmitCheckcast(TypeWrapper context, ILGenerator ilgen)
|
|
{
|
|
if(IsGhost)
|
|
{
|
|
ilgen.Emit(OpCodes.Dup);
|
|
// TODO make sure we get the right "Cast" method and cache it
|
|
// NOTE for dynamic ghosts we don't end up here because DynamicTypeWrapper overrides this method,
|
|
// so we're safe to call GetMethod on TypeAsTBD (because it has to be a compiled type, if we're here)
|
|
ilgen.Emit(OpCodes.Call, TypeAsTBD.GetMethod("Cast"));
|
|
ilgen.Emit(OpCodes.Pop);
|
|
}
|
|
else if(IsGhostArray)
|
|
{
|
|
ilgen.Emit(OpCodes.Dup);
|
|
// TODO make sure we get the right "CastArray" method and cache it
|
|
// NOTE for dynamic ghosts we don't end up here because DynamicTypeWrapper overrides this method,
|
|
// so we're safe to call GetMethod on TypeAsTBD (because it has to be a compiled type, if we're here)
|
|
TypeWrapper tw = this;
|
|
int rank = 0;
|
|
while(tw.IsArray)
|
|
{
|
|
rank++;
|
|
tw = tw.ElementTypeWrapper;
|
|
}
|
|
ilgen.Emit(OpCodes.Ldc_I4, rank);
|
|
ilgen.Emit(OpCodes.Call, tw.TypeAsTBD.GetMethod("CastArray"));
|
|
}
|
|
else
|
|
{
|
|
ilgen.Emit(OpCodes.Castclass, TypeAsTBD);
|
|
}
|
|
}
|
|
|
|
internal virtual void EmitInstanceOf(TypeWrapper context, ILGenerator ilgen)
|
|
{
|
|
if(IsGhost)
|
|
{
|
|
// TODO make sure we get the right "IsInstance" method and cache it
|
|
// NOTE for dynamic ghosts we don't end up here because DynamicTypeWrapper overrides this method,
|
|
// so we're safe to call GetMethod on TypeAsTBD (because it has to be a compiled type, if we're here)
|
|
ilgen.Emit(OpCodes.Call, TypeAsTBD.GetMethod("IsInstance"));
|
|
}
|
|
else if(IsGhostArray)
|
|
{
|
|
// TODO make sure we get the right "IsInstanceArray" method and cache it
|
|
// NOTE for dynamic ghosts we don't end up here because DynamicTypeWrapper overrides this method,
|
|
// so we're safe to call GetMethod on TypeAsTBD (because it has to be a compiled type, if we're here)
|
|
ilgen.Emit(OpCodes.Call, TypeAsTBD.GetMethod("IsInstanceArray"));
|
|
}
|
|
else
|
|
{
|
|
ilgen.Emit(OpCodes.Isinst, TypeAsTBD);
|
|
ilgen.Emit(OpCodes.Ldnull);
|
|
ilgen.Emit(OpCodes.Cgt_Un);
|
|
}
|
|
}
|
|
|
|
internal static string GetSigNameFromType(Type type)
|
|
{
|
|
TypeWrapper wrapper = ClassLoaderWrapper.GetWrapperFromTypeFast(type);
|
|
|
|
if(wrapper != null)
|
|
{
|
|
return wrapper.SigName;
|
|
}
|
|
|
|
if(type.IsArray)
|
|
{
|
|
System.Text.StringBuilder sb = new System.Text.StringBuilder();
|
|
while(type.IsArray)
|
|
{
|
|
sb.Append('[');
|
|
type = type.GetElementType();
|
|
}
|
|
return sb.Append(GetSigNameFromType(type)).ToString();
|
|
}
|
|
|
|
string s = TypeWrapper.GetNameFromType(type);
|
|
if(s[0] != '[')
|
|
{
|
|
s = "L" + s + ";";
|
|
}
|
|
return s;
|
|
}
|
|
|
|
// NOTE returns null for primitive types
|
|
internal static string GetNameFromType(Type type)
|
|
{
|
|
TypeWrapper.AssertFinished(type);
|
|
|
|
if(type.IsArray)
|
|
{
|
|
return GetSigNameFromType(type);
|
|
}
|
|
|
|
// first we check if a wrapper exists, because if it does we must use the name from the wrapper to
|
|
// make sure that remapped types return the proper name
|
|
TypeWrapper wrapper = ClassLoaderWrapper.GetWrapperFromTypeFast(type);
|
|
if(wrapper != null)
|
|
{
|
|
return wrapper.Name;
|
|
}
|
|
|
|
if(type.Module.IsDefined(typeof(JavaModuleAttribute), false))
|
|
{
|
|
return CompiledTypeWrapper.GetName(type);
|
|
}
|
|
else
|
|
{
|
|
return DotNetTypeWrapper.GetName(type);
|
|
}
|
|
}
|
|
|
|
// NOTE don't call this method, call MethodWrapper.Link instead
|
|
internal virtual MethodBase LinkMethod(MethodWrapper mw)
|
|
{
|
|
return mw.GetMethod();
|
|
}
|
|
|
|
// NOTE don't call this method, call FieldWrapper.Link instead
|
|
internal virtual void LinkField(FieldWrapper fw)
|
|
{
|
|
}
|
|
}
|
|
|
|
class UnloadableTypeWrapper : TypeWrapper
|
|
{
|
|
internal UnloadableTypeWrapper(string name)
|
|
: base(TypeWrapper.UnloadableModifiersHack, name, null, null)
|
|
{
|
|
}
|
|
|
|
internal override Assembly Assembly
|
|
{
|
|
get
|
|
{
|
|
return null;
|
|
}
|
|
}
|
|
|
|
internal override string SigName
|
|
{
|
|
get
|
|
{
|
|
string name = Name;
|
|
if(name.StartsWith("["))
|
|
{
|
|
return name;
|
|
}
|
|
return "L" + name + ";";
|
|
}
|
|
}
|
|
|
|
protected override FieldWrapper GetFieldImpl(string fieldName, string fieldSig)
|
|
{
|
|
throw new InvalidOperationException("GetFieldImpl called on UnloadableTypeWrapper: " + Name);
|
|
}
|
|
|
|
internal override MethodWrapper GetMethodWrapper(MethodDescriptor md, bool inherit)
|
|
{
|
|
throw new InvalidOperationException("GetMethodWrapper called on UnloadableTypeWrapper: " + Name);
|
|
}
|
|
|
|
internal override Type TypeAsTBD
|
|
{
|
|
get
|
|
{
|
|
throw new InvalidOperationException("get_Type called on UnloadableTypeWrapper: " + Name);
|
|
}
|
|
}
|
|
|
|
internal override TypeWrapper[] Interfaces
|
|
{
|
|
get
|
|
{
|
|
throw new InvalidOperationException("get_Interfaces called on UnloadableTypeWrapper: " + Name);
|
|
}
|
|
}
|
|
|
|
internal override TypeWrapper[] InnerClasses
|
|
{
|
|
get
|
|
{
|
|
throw new InvalidOperationException("get_InnerClasses called on UnloadableTypeWrapper: " + Name);
|
|
}
|
|
}
|
|
|
|
internal override TypeWrapper DeclaringTypeWrapper
|
|
{
|
|
get
|
|
{
|
|
throw new InvalidOperationException("get_DeclaringTypeWrapper called on UnloadableTypeWrapper: " + Name);
|
|
}
|
|
}
|
|
|
|
internal override void Finish(bool forDebugSave)
|
|
{
|
|
throw new InvalidOperationException("Finish called on UnloadableTypeWrapper: " + Name);
|
|
}
|
|
|
|
internal override void EmitCheckcast(TypeWrapper context, ILGenerator ilgen)
|
|
{
|
|
ilgen.Emit(OpCodes.Ldtoken, context.TypeAsTBD);
|
|
ilgen.Emit(OpCodes.Ldstr, Name);
|
|
ilgen.Emit(OpCodes.Call, typeof(ByteCodeHelper).GetMethod("DynamicCast"));
|
|
}
|
|
|
|
internal override void EmitInstanceOf(TypeWrapper context, ILGenerator ilgen)
|
|
{
|
|
ilgen.Emit(OpCodes.Ldtoken, context.TypeAsTBD);
|
|
ilgen.Emit(OpCodes.Ldstr, Name);
|
|
ilgen.Emit(OpCodes.Call, typeof(ByteCodeHelper).GetMethod("DynamicInstanceOf"));
|
|
}
|
|
}
|
|
|
|
class PrimitiveTypeWrapper : TypeWrapper
|
|
{
|
|
internal static readonly PrimitiveTypeWrapper BYTE = new PrimitiveTypeWrapper(typeof(sbyte), "B");
|
|
internal static readonly PrimitiveTypeWrapper CHAR = new PrimitiveTypeWrapper(typeof(char), "C");
|
|
internal static readonly PrimitiveTypeWrapper DOUBLE = new PrimitiveTypeWrapper(typeof(double), "D");
|
|
internal static readonly PrimitiveTypeWrapper FLOAT = new PrimitiveTypeWrapper(typeof(float), "F");
|
|
internal static readonly PrimitiveTypeWrapper INT = new PrimitiveTypeWrapper(typeof(int), "I");
|
|
internal static readonly PrimitiveTypeWrapper LONG = new PrimitiveTypeWrapper(typeof(long), "J");
|
|
internal static readonly PrimitiveTypeWrapper SHORT = new PrimitiveTypeWrapper(typeof(short), "S");
|
|
internal static readonly PrimitiveTypeWrapper BOOLEAN = new PrimitiveTypeWrapper(typeof(bool), "Z");
|
|
internal static readonly PrimitiveTypeWrapper VOID = new PrimitiveTypeWrapper(typeof(void), "V");
|
|
|
|
private readonly Type type;
|
|
private readonly string sigName;
|
|
|
|
private PrimitiveTypeWrapper(Type type, string sigName)
|
|
: base(Modifiers.Public | Modifiers.Abstract | Modifiers.Final, null, null, null)
|
|
{
|
|
this.type = type;
|
|
this.sigName = sigName;
|
|
}
|
|
|
|
internal override Assembly Assembly
|
|
{
|
|
get
|
|
{
|
|
return null;
|
|
}
|
|
}
|
|
|
|
internal override string SigName
|
|
{
|
|
get
|
|
{
|
|
return sigName;
|
|
}
|
|
}
|
|
|
|
internal override ClassLoaderWrapper GetClassLoader()
|
|
{
|
|
return ClassLoaderWrapper.GetBootstrapClassLoader();
|
|
}
|
|
|
|
internal override Type TypeAsTBD
|
|
{
|
|
get
|
|
{
|
|
return type;
|
|
}
|
|
}
|
|
|
|
protected override FieldWrapper GetFieldImpl(string fieldName, string fieldSig)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
internal override TypeWrapper[] Interfaces
|
|
{
|
|
get
|
|
{
|
|
return TypeWrapper.EmptyArray;
|
|
}
|
|
}
|
|
|
|
internal override TypeWrapper[] InnerClasses
|
|
{
|
|
get
|
|
{
|
|
return TypeWrapper.EmptyArray;
|
|
}
|
|
}
|
|
|
|
internal override TypeWrapper DeclaringTypeWrapper
|
|
{
|
|
get
|
|
{
|
|
return null;
|
|
}
|
|
}
|
|
|
|
internal override void Finish(bool forDebugSave)
|
|
{
|
|
}
|
|
}
|
|
|
|
sealed class DynamicTypeWrapper : TypeWrapper
|
|
{
|
|
private volatile DynamicImpl impl;
|
|
private TypeWrapper[] interfaces;
|
|
private FieldInfo ghostRefField;
|
|
private MethodBuilder ghostIsInstanceMethod;
|
|
private MethodBuilder ghostIsInstanceArrayMethod;
|
|
private MethodBuilder ghostCastMethod;
|
|
private MethodBuilder ghostCastArrayMethod;
|
|
private bool hasStaticInitializer;
|
|
private static TypeWrapper[] mappedExceptions;
|
|
private static bool[] mappedExceptionsAllSubClasses;
|
|
private static Hashtable ghosts;
|
|
private static Hashtable nativeMethods;
|
|
|
|
private static TypeWrapper LoadTypeWrapper(ClassLoaderWrapper classLoader, string name)
|
|
{
|
|
TypeWrapper tw = classLoader.LoadClassByDottedNameFast(name);
|
|
if(tw == null)
|
|
{
|
|
throw new NoClassDefFoundError(name);
|
|
}
|
|
return tw;
|
|
}
|
|
|
|
internal DynamicTypeWrapper(ClassFile f, ClassLoaderWrapper classLoader)
|
|
: base(f.Modifiers, f.Name, f.IsInterface ? null : LoadTypeWrapper(classLoader, f.SuperClass), classLoader)
|
|
{
|
|
Profiler.Count("DynamicTypeWrapper");
|
|
if(BaseTypeWrapper != null)
|
|
{
|
|
if(!BaseTypeWrapper.IsAccessibleFrom(this))
|
|
{
|
|
throw new IllegalAccessError("Class " + f.Name + " cannot access its superclass " + BaseTypeWrapper.Name);
|
|
}
|
|
if(BaseTypeWrapper.IsFinal)
|
|
{
|
|
throw new VerifyError("Cannot inherit from final class");
|
|
}
|
|
if(BaseTypeWrapper.IsInterface)
|
|
{
|
|
throw new IncompatibleClassChangeError("Class " + f.Name + " has interface " + BaseTypeWrapper.Name + " as superclass");
|
|
}
|
|
if(!f.IsFinal)
|
|
{
|
|
if(BaseTypeWrapper.TypeAsTBD == typeof(ValueType) || BaseTypeWrapper.TypeAsTBD == typeof(Enum))
|
|
{
|
|
throw new VerifyError("Value types must be final");
|
|
}
|
|
if(BaseTypeWrapper.TypeAsTBD == typeof(MulticastDelegate))
|
|
{
|
|
throw new VerifyError("Delegates must be final");
|
|
}
|
|
}
|
|
if(BaseTypeWrapper.TypeAsTBD == typeof(Delegate))
|
|
{
|
|
throw new VerifyError(BaseTypeWrapper.Name + " cannot be used as a base class");
|
|
}
|
|
// NOTE defining value types, enums and delegates is not supported in IKVM v1
|
|
if(BaseTypeWrapper.TypeAsTBD == typeof(ValueType) || BaseTypeWrapper.TypeAsTBD == typeof(Enum))
|
|
{
|
|
throw new VerifyError("Defining value types in Java is not implemented in IKVM v1");
|
|
}
|
|
if(BaseTypeWrapper.TypeAsTBD == typeof(MulticastDelegate))
|
|
{
|
|
throw new VerifyError("Defining delegates in Java is not implemented in IKVM v1");
|
|
}
|
|
}
|
|
|
|
ClassFile.ConstantPoolItemClass[] interfaces = f.Interfaces;
|
|
this.interfaces = new TypeWrapper[interfaces.Length];
|
|
for(int i = 0; i < interfaces.Length; i++)
|
|
{
|
|
TypeWrapper iface = LoadTypeWrapper(classLoader, interfaces[i].Name);
|
|
if(!iface.IsAccessibleFrom(this))
|
|
{
|
|
throw new IllegalAccessError("Class " + f.Name + " cannot access its superinterface " + iface.Name);
|
|
}
|
|
if(!iface.IsInterface)
|
|
{
|
|
throw new IncompatibleClassChangeError("Implementing class");
|
|
}
|
|
this.interfaces[i] = iface;
|
|
}
|
|
|
|
impl = new JavaTypeImpl(f, this);
|
|
}
|
|
|
|
internal override bool HasStaticInitializer
|
|
{
|
|
get
|
|
{
|
|
return hasStaticInitializer;
|
|
}
|
|
}
|
|
|
|
internal override Assembly Assembly
|
|
{
|
|
get
|
|
{
|
|
return GetClassLoader().ModuleBuilder.Assembly;
|
|
}
|
|
}
|
|
|
|
internal override FieldInfo GhostRefField
|
|
{
|
|
get
|
|
{
|
|
return ghostRefField;
|
|
}
|
|
}
|
|
|
|
internal override Modifiers ReflectiveModifiers
|
|
{
|
|
get
|
|
{
|
|
return impl.ReflectiveModifiers;
|
|
}
|
|
}
|
|
|
|
protected override FieldWrapper GetFieldImpl(string fieldName, string fieldSig)
|
|
{
|
|
return impl.GetFieldImpl(fieldName, fieldSig);
|
|
}
|
|
|
|
internal override TypeWrapper[] Interfaces
|
|
{
|
|
get
|
|
{
|
|
return interfaces;
|
|
}
|
|
}
|
|
|
|
internal override TypeWrapper[] InnerClasses
|
|
{
|
|
get
|
|
{
|
|
return impl.InnerClasses;
|
|
}
|
|
}
|
|
|
|
internal override TypeWrapper DeclaringTypeWrapper
|
|
{
|
|
get
|
|
{
|
|
return impl.DeclaringTypeWrapper;
|
|
}
|
|
}
|
|
|
|
internal override Type TypeAsTBD
|
|
{
|
|
get
|
|
{
|
|
return impl.Type;
|
|
}
|
|
}
|
|
|
|
internal override Type TypeAsBaseType
|
|
{
|
|
get
|
|
{
|
|
return impl.TypeAsBaseType;
|
|
}
|
|
}
|
|
|
|
internal override void Finish(bool forDebugSave)
|
|
{
|
|
lock(this)
|
|
{
|
|
Profiler.Enter("DynamicTypeWrapper.Finish");
|
|
try
|
|
{
|
|
impl = impl.Finish(forDebugSave);
|
|
}
|
|
finally
|
|
{
|
|
Profiler.Leave("DynamicTypeWrapper.Finish");
|
|
}
|
|
}
|
|
}
|
|
|
|
internal static void SetupGhosts(IKVM.Internal.MapXml.Root map)
|
|
{
|
|
ghosts = new Hashtable();
|
|
|
|
// find the ghost interfaces
|
|
foreach(IKVM.Internal.MapXml.Class c in map.assembly)
|
|
{
|
|
if(c.Shadows != null && c.Interfaces != null)
|
|
{
|
|
// NOTE we don't support interfaces that inherit from other interfaces
|
|
// (actually, if they are explicitly listed it would probably work)
|
|
TypeWrapper typeWrapper = ClassLoaderWrapper.GetBootstrapClassLoader().GetLoadedClass(c.Name);
|
|
foreach(IKVM.Internal.MapXml.Interface iface in c.Interfaces)
|
|
{
|
|
TypeWrapper ifaceWrapper = ClassLoaderWrapper.GetBootstrapClassLoader().GetLoadedClass(iface.Name);
|
|
if(ifaceWrapper == null || !ifaceWrapper.TypeAsTBD.IsAssignableFrom(typeWrapper.TypeAsTBD))
|
|
{
|
|
AddGhost(iface.Name, typeWrapper);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
// we manually add the array ghost interfaces
|
|
TypeWrapper array = ClassLoaderWrapper.GetWrapperFromType(typeof(Array));
|
|
AddGhost("java.io.Serializable", array);
|
|
AddGhost("java.lang.Cloneable", array);
|
|
}
|
|
|
|
private static void AddGhost(string interfaceName, TypeWrapper implementer)
|
|
{
|
|
ArrayList list = (ArrayList)ghosts[interfaceName];
|
|
if(list == null)
|
|
{
|
|
list = new ArrayList();
|
|
ghosts[interfaceName] = list;
|
|
}
|
|
list.Add(implementer);
|
|
}
|
|
|
|
internal override bool IsGhost
|
|
{
|
|
get
|
|
{
|
|
return ghosts != null && IsInterface && ghosts.ContainsKey(Name);
|
|
}
|
|
}
|
|
|
|
private static TypeWrapper[] GetGhostImplementers(TypeWrapper wrapper)
|
|
{
|
|
ArrayList list = (ArrayList)ghosts[wrapper.Name];
|
|
if(list == null)
|
|
{
|
|
return TypeWrapper.EmptyArray;
|
|
}
|
|
return (TypeWrapper[])list.ToArray(typeof(TypeWrapper));
|
|
}
|
|
|
|
private class ExceptionMapEmitter : CodeEmitter
|
|
{
|
|
private IKVM.Internal.MapXml.ExceptionMapping[] map;
|
|
|
|
internal ExceptionMapEmitter(IKVM.Internal.MapXml.ExceptionMapping[] map)
|
|
{
|
|
this.map = map;
|
|
}
|
|
|
|
internal override void Emit(ILGenerator ilgen)
|
|
{
|
|
ilgen.Emit(OpCodes.Ldarg_0);
|
|
ilgen.Emit(OpCodes.Callvirt, typeof(Object).GetMethod("GetType"));
|
|
MethodInfo GetTypeFromHandle = typeof(Type).GetMethod("GetTypeFromHandle");
|
|
for(int i = 0; i < map.Length; i++)
|
|
{
|
|
ilgen.Emit(OpCodes.Dup);
|
|
ilgen.Emit(OpCodes.Ldtoken, Type.GetType(map[i].src));
|
|
ilgen.Emit(OpCodes.Call, GetTypeFromHandle);
|
|
ilgen.Emit(OpCodes.Ceq);
|
|
Label label = ilgen.DefineLabel();
|
|
ilgen.Emit(OpCodes.Brfalse_S, label);
|
|
ilgen.Emit(OpCodes.Pop);
|
|
if(map[i].code != null)
|
|
{
|
|
ilgen.Emit(OpCodes.Ldarg_0);
|
|
map[i].code.Emit(ilgen);
|
|
ilgen.Emit(OpCodes.Ret);
|
|
}
|
|
else
|
|
{
|
|
TypeWrapper tw = ClassLoaderWrapper.GetBootstrapClassLoader().LoadClassByDottedName(map[i].dst);
|
|
MethodWrapper mw = tw.GetMethodWrapper(new MethodDescriptor("<init>", "()V"), false);
|
|
mw.Link();
|
|
mw.EmitNewobj(ilgen);
|
|
ilgen.Emit(OpCodes.Ret);
|
|
}
|
|
ilgen.MarkLabel(label);
|
|
}
|
|
ilgen.Emit(OpCodes.Pop);
|
|
ilgen.Emit(OpCodes.Ldarg_0);
|
|
ilgen.Emit(OpCodes.Ret);
|
|
}
|
|
}
|
|
|
|
internal static void LoadNativeMethods(IKVM.Internal.MapXml.Root map)
|
|
{
|
|
nativeMethods = new Hashtable();
|
|
// HACK we've got a hardcoded location for the exception mapping method that is generated from the xml mapping
|
|
nativeMethods["java.lang.ExceptionHelper.MapExceptionImpl(Ljava.lang.Throwable;)Ljava.lang.Throwable;"] = new ExceptionMapEmitter(map.exceptionMappings);
|
|
foreach(IKVM.Internal.MapXml.Class c in map.assembly)
|
|
{
|
|
// HACK if it is not a remapped type, we assume it is a container for native methods
|
|
if(c.Shadows == null)
|
|
{
|
|
string className = c.Name;
|
|
foreach(IKVM.Internal.MapXml.Method method in c.Methods)
|
|
{
|
|
if(method.body != null)
|
|
{
|
|
string methodName = method.Name;
|
|
string methodSig = method.Sig;
|
|
nativeMethods[className + "." + methodName + methodSig] = method.body;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
internal override bool IsMapUnsafeException
|
|
{
|
|
get
|
|
{
|
|
if(mappedExceptions != null)
|
|
{
|
|
for(int i = 0; i < mappedExceptions.Length; i++)
|
|
{
|
|
if(mappedExceptions[i].IsSubTypeOf(this) ||
|
|
(mappedExceptionsAllSubClasses[i] && this.IsSubTypeOf(mappedExceptions[i])))
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
|
|
internal static void LoadMappedExceptions(IKVM.Internal.MapXml.Root map)
|
|
{
|
|
mappedExceptionsAllSubClasses = new bool[map.exceptionMappings.Length];
|
|
mappedExceptions = new TypeWrapper[map.exceptionMappings.Length];
|
|
for(int i = 0; i < mappedExceptions.Length; i++)
|
|
{
|
|
string dst = map.exceptionMappings[i].dst;
|
|
if(dst[0] == '*')
|
|
{
|
|
mappedExceptionsAllSubClasses[i] = true;
|
|
dst = dst.Substring(1);
|
|
}
|
|
mappedExceptions[i] = ClassLoaderWrapper.GetBootstrapClassLoader().LoadClassByDottedName(dst);
|
|
}
|
|
}
|
|
|
|
// NOTE can only be used if the type hasn't been finished yet!
|
|
internal FieldInfo ClassObjectField
|
|
{
|
|
get
|
|
{
|
|
return ((JavaTypeImpl)impl).ClassObjectField;
|
|
}
|
|
}
|
|
|
|
private abstract class DynamicImpl
|
|
{
|
|
internal abstract FieldWrapper GetFieldImpl(string fieldName, string fieldSig);
|
|
internal abstract Type Type { get; }
|
|
internal abstract Type TypeAsBaseType { get; }
|
|
internal abstract TypeWrapper[] InnerClasses { get; }
|
|
internal abstract TypeWrapper DeclaringTypeWrapper { get; }
|
|
internal abstract Modifiers ReflectiveModifiers { get; }
|
|
internal abstract DynamicImpl Finish(bool forDebugSave);
|
|
internal abstract MethodBase LinkMethod(MethodWrapper mw);
|
|
internal abstract void LinkField(FieldWrapper fw);
|
|
}
|
|
|
|
private class JavaTypeImpl : DynamicImpl
|
|
{
|
|
private readonly ClassFile classFile;
|
|
private readonly DynamicTypeWrapper wrapper;
|
|
private readonly TypeBuilder typeBuilder;
|
|
private MethodWrapper[] methods;
|
|
private MethodWrapper[] baseMethods;
|
|
private FieldWrapper[] fields;
|
|
private Hashtable methodLookup;
|
|
private Hashtable fieldLookup;
|
|
private bool finishing;
|
|
private bool finishingForDebugSave;
|
|
private FinishedTypeImpl finishedType;
|
|
private readonly TypeWrapper outerClassWrapper;
|
|
private readonly TypeBuilder typeBuilderGhostInterface;
|
|
private Hashtable memberclashtable;
|
|
private Hashtable classCache = new Hashtable();
|
|
private FieldInfo classObjectField;
|
|
|
|
internal JavaTypeImpl(ClassFile f, DynamicTypeWrapper wrapper)
|
|
{
|
|
Tracer.Info(Tracer.Compiler, "constructing JavaTypeImpl for " + f.Name);
|
|
this.classFile = f;
|
|
this.wrapper = wrapper;
|
|
|
|
// process all methods
|
|
bool hasclinit = wrapper.BaseTypeWrapper == null ? false : wrapper.BaseTypeWrapper.HasStaticInitializer;
|
|
methods = new MethodWrapper[classFile.Methods.Length];
|
|
baseMethods = new MethodWrapper[classFile.Methods.Length];
|
|
methodLookup = new Hashtable();
|
|
for(int i = 0; i < methods.Length; i++)
|
|
{
|
|
ClassFile.Method m = classFile.Methods[i];
|
|
if(m.IsClassInitializer)
|
|
{
|
|
if(JVM.IsStaticCompiler)
|
|
{
|
|
if(!IsSideEffectFreeStaticInitializer(m))
|
|
{
|
|
hasclinit = true;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
hasclinit = true;
|
|
}
|
|
}
|
|
MethodDescriptor md = new MethodDescriptor(m.Name, m.Signature);
|
|
if(wrapper.IsGhost)
|
|
{
|
|
methods[i] = new MethodWrapper.GhostMethodWrapper(wrapper, md, null, null, null, m.Modifiers, MemberFlags.None);
|
|
}
|
|
else if(m.Name == "<init>")
|
|
{
|
|
methods[i] = new SmartConstructorMethodWrapper(wrapper, md, null, null, m.Modifiers, MemberFlags.None);
|
|
}
|
|
else
|
|
{
|
|
bool explicitOverride = false;
|
|
if(!classFile.IsInterface && !m.IsStatic && !m.IsPrivate)
|
|
{
|
|
baseMethods[i] = FindBaseMethod(md, out explicitOverride);
|
|
}
|
|
methods[i] = new SmartCallMethodWrapper(wrapper, md, null, null, null, m.Modifiers, explicitOverride ? MemberFlags.ExplicitOverride : MemberFlags.None, OpCodes.Call, OpCodes.Callvirt);
|
|
}
|
|
methodLookup[md] = i;
|
|
wrapper.AddMethod(methods[i]);
|
|
}
|
|
wrapper.hasStaticInitializer = hasclinit;
|
|
if(wrapper.IsAbstract && !wrapper.IsInterface)
|
|
{
|
|
ArrayList methodsArray = new ArrayList(methods);
|
|
ArrayList baseMethodsArray = new ArrayList(baseMethods);
|
|
AddMirandaMethods(methodsArray, baseMethodsArray, wrapper);
|
|
this.methods = (MethodWrapper[])methodsArray.ToArray(typeof(MethodWrapper));
|
|
this.baseMethods = (MethodWrapper[])baseMethodsArray.ToArray(typeof(MethodWrapper));
|
|
}
|
|
|
|
// from now on we shouldn't be throwing any exceptions (to be precise, after we've
|
|
// called ModuleBuilder.DefineType)
|
|
try
|
|
{
|
|
TypeAttributes typeAttribs = 0;
|
|
if(f.IsAbstract)
|
|
{
|
|
typeAttribs |= TypeAttributes.Abstract;
|
|
}
|
|
if(f.IsFinal)
|
|
{
|
|
typeAttribs |= TypeAttributes.Sealed;
|
|
}
|
|
if(!hasclinit)
|
|
{
|
|
typeAttribs |= TypeAttributes.BeforeFieldInit;
|
|
}
|
|
TypeBuilder outer = null;
|
|
// only if requested, we compile inner classes as nested types, because it has a higher cost
|
|
// and doesn't buy us anything, unless we're compiling a library that could be used from C# (e.g.)
|
|
if(JVM.CompileInnerClassesAsNestedTypes)
|
|
{
|
|
if(f.OuterClass != null)
|
|
{
|
|
if(!CheckInnerOuterNames(f.Name, f.OuterClass.Name))
|
|
{
|
|
Tracer.Warning(Tracer.Compiler, "Incorrect InnerClasses attribute on {0}", f.Name);
|
|
}
|
|
else
|
|
{
|
|
outerClassWrapper = wrapper.GetClassLoader().LoadClassByDottedName(f.OuterClass.Name);
|
|
if(outerClassWrapper is DynamicTypeWrapper)
|
|
{
|
|
outer = outerClassWrapper.TypeAsBuilder;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if(f.IsPublic)
|
|
{
|
|
if(outer != null)
|
|
{
|
|
typeAttribs |= TypeAttributes.NestedPublic;
|
|
}
|
|
else
|
|
{
|
|
typeAttribs |= TypeAttributes.Public;
|
|
}
|
|
}
|
|
else if(outer != null)
|
|
{
|
|
typeAttribs |= TypeAttributes.NestedAssembly;
|
|
}
|
|
if(f.IsInterface)
|
|
{
|
|
typeAttribs |= TypeAttributes.Interface | TypeAttributes.Abstract;
|
|
if(outer != null)
|
|
{
|
|
if(wrapper.IsGhost)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
// LAMESPEC the CLI spec says interfaces cannot contain nested types (Part.II, 9.6), but that rule isn't enforced
|
|
// (and broken by J# as well), so we'll just ignore it too.
|
|
typeBuilder = outer.DefineNestedType(GetInnerClassName(outerClassWrapper.Name, f.Name), typeAttribs);
|
|
}
|
|
else
|
|
{
|
|
if(wrapper.IsGhost)
|
|
{
|
|
typeAttribs &= ~(TypeAttributes.Interface | TypeAttributes.Abstract);
|
|
typeAttribs |= TypeAttributes.Class | TypeAttributes.Sealed;
|
|
typeBuilder = wrapper.GetClassLoader().ModuleBuilder.DefineType(wrapper.GetClassLoader().MangleTypeName(f.Name), typeAttribs, typeof(ValueType));
|
|
AttributeHelper.SetGhostInterface(typeBuilder);
|
|
AttributeHelper.SetModifiers(typeBuilder, wrapper.Modifiers);
|
|
wrapper.ghostRefField = typeBuilder.DefineField("__<ref>", typeof(object), FieldAttributes.Public | FieldAttributes.SpecialName);
|
|
AttributeHelper.HideFromJava((FieldBuilder)wrapper.ghostRefField);
|
|
typeBuilderGhostInterface = typeBuilder.DefineNestedType("__Interface", TypeAttributes.Interface | TypeAttributes.Abstract | TypeAttributes.NestedPublic);
|
|
AttributeHelper.HideFromJava(typeBuilderGhostInterface);
|
|
wrapper.ghostIsInstanceMethod = typeBuilder.DefineMethod("IsInstance", MethodAttributes.Public | MethodAttributes.Static, typeof(bool), new Type[] { typeof(object) });
|
|
wrapper.ghostIsInstanceArrayMethod = typeBuilder.DefineMethod("IsInstanceArray", MethodAttributes.Public | MethodAttributes.Static, typeof(bool), new Type[] { typeof(object), typeof(int) });
|
|
wrapper.ghostCastMethod = typeBuilder.DefineMethod("Cast", MethodAttributes.Public | MethodAttributes.Static, typeBuilder, new Type[] { typeof(object) });
|
|
wrapper.ghostCastArrayMethod = typeBuilder.DefineMethod("CastArray", MethodAttributes.Public | MethodAttributes.Static, typeof(void), new Type[] { typeof(object), typeof(int) });
|
|
}
|
|
else
|
|
{
|
|
typeBuilder = wrapper.GetClassLoader().ModuleBuilder.DefineType(wrapper.GetClassLoader().MangleTypeName(f.Name), typeAttribs);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
typeAttribs |= TypeAttributes.Class;
|
|
if(outer != null)
|
|
{
|
|
// LAMESPEC the CLI spec says interfaces cannot contain nested types (Part.II, 9.6), but that rule isn't enforced
|
|
// (and broken by J# as well), so we'll just ignore it too.
|
|
typeBuilder = outer.DefineNestedType(GetInnerClassName(outerClassWrapper.Name, f.Name), typeAttribs, wrapper.BaseTypeWrapper.TypeAsBaseType);
|
|
}
|
|
else
|
|
{
|
|
typeBuilder = wrapper.GetClassLoader().ModuleBuilder.DefineType(wrapper.GetClassLoader().MangleTypeName(f.Name), typeAttribs, wrapper.BaseTypeWrapper.TypeAsBaseType);
|
|
}
|
|
}
|
|
TypeWrapper[] interfaces = wrapper.Interfaces;
|
|
for(int i = 0; i < interfaces.Length; i++)
|
|
{
|
|
// NOTE we're using TypeAsBaseType for the interfaces!
|
|
typeBuilder.AddInterfaceImplementation(interfaces[i].TypeAsBaseType);
|
|
}
|
|
AttributeHelper.SetImplementsAttribute(typeBuilder, interfaces);
|
|
if(JVM.IsStaticCompiler && classFile.DeprecatedAttribute)
|
|
{
|
|
AttributeHelper.SetDeprecatedAttribute(typeBuilder);
|
|
}
|
|
if(f.SourceFileAttribute != null && !JVM.NoStackTraceInfo)
|
|
{
|
|
AttributeHelper.SetSourceFile(typeBuilder, f.SourceFileAttribute);
|
|
}
|
|
}
|
|
catch(Exception x)
|
|
{
|
|
if(typeBuilder != null)
|
|
{
|
|
JVM.CriticalFailure("Exception during critical part of JavaTypeImpl construction", x);
|
|
}
|
|
throw;
|
|
}
|
|
}
|
|
|
|
private bool IsSideEffectFreeStaticInitializer(ClassFile.Method m)
|
|
{
|
|
if(m.ExceptionTable.Length != 0)
|
|
{
|
|
return false;
|
|
}
|
|
for(int i = 0; i < m.Instructions.Length; i++)
|
|
{
|
|
ByteCode bc = m.Instructions[i].OpCode;
|
|
if(bc == ByteCode.__getstatic || bc == ByteCode.__putstatic)
|
|
{
|
|
ClassFile.ConstantPoolItemFieldref fld = classFile.GetFieldref(m.Instructions[i].Arg1);
|
|
if(fld.Class != classFile.Name)
|
|
{
|
|
return false;
|
|
}
|
|
// don't allow getstatic to load non-primitive fields, because that would
|
|
// cause the verifier to try to load the type
|
|
if(bc == ByteCode.__getstatic && "L[".IndexOf(fld.Signature[0]) != -1)
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
else if(bc == ByteCode.__areturn ||
|
|
bc == ByteCode.__ireturn ||
|
|
bc == ByteCode.__lreturn ||
|
|
bc == ByteCode.__freturn ||
|
|
bc == ByteCode.__dreturn)
|
|
{
|
|
return false;
|
|
}
|
|
else if(ByteCodeMetaData.CanThrowException(bc))
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
// the method needs to be verifiable to be side effect free, since we already analysed it,
|
|
// we know that the verifier won't try to load any types (which isn't allowed at this time)
|
|
try
|
|
{
|
|
new MethodAnalyzer(wrapper, null, classFile, m, null);
|
|
return true;
|
|
}
|
|
catch(VerifyError)
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
private void AddMirandaMethods(ArrayList methods, ArrayList baseMethods, TypeWrapper tw)
|
|
{
|
|
foreach(TypeWrapper iface in tw.Interfaces)
|
|
{
|
|
AddMirandaMethods(methods, baseMethods, iface);
|
|
foreach(MethodWrapper ifmethod in iface.GetMethods())
|
|
{
|
|
// skip <clinit>
|
|
if(!ifmethod.IsStatic)
|
|
{
|
|
TypeWrapper lookup = wrapper;
|
|
while(lookup != null)
|
|
{
|
|
MethodWrapper mw = lookup.GetMethodWrapper(ifmethod.Descriptor, true);
|
|
if(mw == null)
|
|
{
|
|
mw = new SmartCallMethodWrapper(wrapper, ifmethod.Descriptor, null, null, null, Modifiers.Public | Modifiers.Abstract, MemberFlags.HideFromReflection, OpCodes.Call, OpCodes.Callvirt);
|
|
methodLookup[ifmethod.Descriptor] = methods.Count;
|
|
methods.Add(mw);
|
|
baseMethods.Add(ifmethod);
|
|
wrapper.AddMethod(mw);
|
|
break;
|
|
}
|
|
if(!mw.IsStatic)
|
|
{
|
|
break;
|
|
}
|
|
lookup = mw.DeclaringType.BaseTypeWrapper;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private static bool CheckInnerOuterNames(string inner, string outer)
|
|
{
|
|
// do some sanity checks on the inner/outer class names
|
|
return inner.Length > outer.Length + 1 && inner[outer.Length] == '$' && inner.IndexOf('$', outer.Length + 1) == -1;
|
|
}
|
|
|
|
private static string GetInnerClassName(string outer, string inner)
|
|
{
|
|
Debug.Assert(CheckInnerOuterNames(inner, outer));
|
|
return inner.Substring(outer.Length + 1);
|
|
}
|
|
|
|
private static bool IsCompatibleArgList(TypeWrapper[] caller, TypeWrapper[] callee)
|
|
{
|
|
if(caller.Length == callee.Length)
|
|
{
|
|
for(int i = 0; i < caller.Length; i++)
|
|
{
|
|
if(caller[i].TypeAsParameterType == typeof(sbyte[]) && callee[i].TypeAsParameterType == typeof(byte[]))
|
|
{
|
|
// special case for byte array cheating...
|
|
}
|
|
else if(!caller[i].IsAssignableTo(callee[i]))
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
private void EmitConstantValueInitialization(ILGenerator ilGenerator)
|
|
{
|
|
ClassFile.Field[] fields = classFile.Fields;
|
|
for(int i = 0; i < fields.Length; i++)
|
|
{
|
|
ClassFile.Field f = fields[i];
|
|
if(f.IsStatic && !f.IsFinal)
|
|
{
|
|
object constant = f.ConstantValue;
|
|
if(constant != null)
|
|
{
|
|
if(constant is int)
|
|
{
|
|
ilGenerator.Emit(OpCodes.Ldc_I4, (int)constant);
|
|
}
|
|
else if(constant is long)
|
|
{
|
|
ilGenerator.Emit(OpCodes.Ldc_I8, (long)constant);
|
|
}
|
|
else if(constant is double)
|
|
{
|
|
ilGenerator.Emit(OpCodes.Ldc_R8, (double)constant);
|
|
}
|
|
else if(constant is float)
|
|
{
|
|
ilGenerator.Emit(OpCodes.Ldc_R4, (float)constant);
|
|
}
|
|
else if(constant is string)
|
|
{
|
|
ilGenerator.Emit(OpCodes.Ldstr, (string)constant);
|
|
}
|
|
else
|
|
{
|
|
throw new InvalidOperationException();
|
|
}
|
|
this.fields[i].EmitSet(ilGenerator);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
internal FieldInfo ClassObjectField
|
|
{
|
|
get
|
|
{
|
|
lock(this)
|
|
{
|
|
if(classObjectField == null)
|
|
{
|
|
classObjectField = typeBuilder.DefineField("__<classObject>", typeof(object), FieldAttributes.Private | FieldAttributes.Static);
|
|
AttributeHelper.HideFromJava((FieldBuilder)classObjectField);
|
|
}
|
|
return classObjectField;
|
|
}
|
|
}
|
|
}
|
|
|
|
internal override MethodBase LinkMethod(MethodWrapper mw)
|
|
{
|
|
Debug.Assert(mw != null);
|
|
bool unloadableOverrideStub = false;
|
|
int index = (int)methodLookup[mw.Descriptor];
|
|
MethodWrapper baseMethod = baseMethods[index];
|
|
if(baseMethod != null)
|
|
{
|
|
baseMethod.Link();
|
|
// check the loader constraints
|
|
if(mw.ReturnType != baseMethod.ReturnType)
|
|
{
|
|
if(baseMethod.ReturnType.IsUnloadable || finishingForDebugSave)
|
|
{
|
|
if(!mw.ReturnType.IsUnloadable || (!baseMethod.ReturnType.IsUnloadable && finishingForDebugSave))
|
|
{
|
|
unloadableOverrideStub = true;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
throw new LinkageError("Loader constraints violated");
|
|
}
|
|
}
|
|
TypeWrapper[] here = mw.GetParameters();
|
|
TypeWrapper[] there = baseMethod.GetParameters();
|
|
for(int i = 0; i < here.Length; i++)
|
|
{
|
|
if(here[i] != there[i])
|
|
{
|
|
if(there[i].IsUnloadable || finishingForDebugSave)
|
|
{
|
|
if(!here[i].IsUnloadable || (!there[i].IsUnloadable && finishingForDebugSave))
|
|
{
|
|
unloadableOverrideStub = true;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
throw new LinkageError("Loader constraints violated");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
Debug.Assert(mw.GetMethod() == null);
|
|
return GenerateMethod(index, unloadableOverrideStub);
|
|
}
|
|
|
|
internal override void LinkField(FieldWrapper fw)
|
|
{
|
|
Debug.Assert(fw != null);
|
|
// TODO
|
|
}
|
|
|
|
internal override DynamicImpl Finish(bool forDebugSave)
|
|
{
|
|
this.finishingForDebugSave = forDebugSave;
|
|
// NOTE if a finish is triggered during static compilation phase 1, it cannot be handled properly,
|
|
// so we bail out.
|
|
// (this should only happen during compilation of classpath.dll and is most likely caused by a bug somewhere)
|
|
if(JVM.IsStaticCompilerPhase1)
|
|
{
|
|
JVM.CriticalFailure("Finish triggered during phase 1 of compilation.", null);
|
|
return null;
|
|
}
|
|
if(wrapper.BaseTypeWrapper != null)
|
|
{
|
|
wrapper.BaseTypeWrapper.Finish(forDebugSave);
|
|
}
|
|
if(outerClassWrapper != null)
|
|
{
|
|
outerClassWrapper.Finish(forDebugSave);
|
|
}
|
|
// NOTE there is a bug in the CLR (.NET 1.0 & 1.1 [1.2 is not yet available]) that
|
|
// causes the AppDomain.TypeResolve event to receive the incorrect type name for nested types.
|
|
// The Name in the ResolveEventArgs contains only the nested type name, not the full type name,
|
|
// for example, if the type being resolved is "MyOuterType+MyInnerType", then the event only
|
|
// receives "MyInnerType" as the name. Since we only compile inner classes as nested types
|
|
// when we're statically compiling, we can only run into this bug when we're statically compiling.
|
|
// NOTE To work around this bug, we have to make sure that all types that are going to be
|
|
// required in finished form, are finished explicitly here. It isn't clear what other types are
|
|
// required to be finished. I instrumented a static compilation of classpath.dll and this
|
|
// turned up no other cases of the TypeResolve event firing.
|
|
for(int i = 0; i < wrapper.Interfaces.Length; i++)
|
|
{
|
|
wrapper.Interfaces[i].Finish(forDebugSave);
|
|
}
|
|
// make sure all classes are loaded, before we start finishing the type. During finishing, we
|
|
// may not run any Java code, because that might result in a request to finish the type that we
|
|
// are in the process of finishing, and this would be a problem.
|
|
classFile.Link(wrapper, classCache);
|
|
// for(int i = 0; i < fields.Length; i++)
|
|
// {
|
|
// fields[i].Link();
|
|
// }
|
|
for(int i = 0; i < methods.Length; i++)
|
|
{
|
|
methods[i].Link();
|
|
}
|
|
// it is possible that the loading of the referenced classes triggered a finish of us,
|
|
// if that happens, we just return
|
|
if(finishedType != null)
|
|
{
|
|
return finishedType;
|
|
}
|
|
Profiler.Enter("JavaTypeImpl.Finish.Core");
|
|
try
|
|
{
|
|
Debug.Assert(!finishing);
|
|
finishing = true;
|
|
TypeWrapper declaringTypeWrapper = null;
|
|
TypeWrapper[] innerClassesTypeWrappers = TypeWrapper.EmptyArray;
|
|
// if we're an inner class, we need to attach an InnerClass attribute
|
|
ClassFile.InnerClass[] innerclasses = classFile.InnerClasses;
|
|
if(innerclasses != null)
|
|
{
|
|
// TODO consider not pre-computing innerClassesTypeWrappers and declaringTypeWrapper here
|
|
ArrayList wrappers = new ArrayList();
|
|
for(int i = 0; i < innerclasses.Length; i++)
|
|
{
|
|
if(innerclasses[i].innerClass != 0 && innerclasses[i].outerClass != 0)
|
|
{
|
|
if(classFile.GetConstantPoolClassType(innerclasses[i].outerClass) == wrapper)
|
|
{
|
|
wrappers.Add(classFile.GetConstantPoolClassType(innerclasses[i].innerClass));
|
|
}
|
|
if(classFile.GetConstantPoolClassType(innerclasses[i].innerClass) == wrapper)
|
|
{
|
|
declaringTypeWrapper = classFile.GetConstantPoolClassType(innerclasses[i].outerClass);
|
|
AttributeHelper.SetInnerClass(typeBuilder,
|
|
classFile.GetConstantPoolClass(innerclasses[i].innerClass),
|
|
classFile.GetConstantPoolClass(innerclasses[i].outerClass),
|
|
innerclasses[i].name == 0 ? null : classFile.GetConstantPoolUtf8String(innerclasses[i].name),
|
|
innerclasses[i].accessFlags);
|
|
}
|
|
}
|
|
}
|
|
innerClassesTypeWrappers = (TypeWrapper[])wrappers.ToArray(typeof(TypeWrapper));
|
|
}
|
|
if(fieldLookup == null)
|
|
{
|
|
fields = new FieldWrapper[classFile.Fields.Length];
|
|
fieldLookup = new Hashtable();
|
|
for(int i = 0; i < classFile.Fields.Length; i++)
|
|
{
|
|
fieldLookup[classFile.Fields[i].Name + classFile.Fields[i].Signature] = i;
|
|
}
|
|
}
|
|
for(int i = 0; i < fields.Length; i++)
|
|
{
|
|
if(fields[i] == null)
|
|
{
|
|
GenerateField(i);
|
|
wrapper.AddField(fields[i]);
|
|
}
|
|
}
|
|
if(typeBuilderGhostInterface != null)
|
|
{
|
|
// TODO consider adding methods from base interface and java.lang.Object as well
|
|
for(int i = 0; i < methods.Length; i++)
|
|
{
|
|
// skip <clinit>
|
|
if(!methods[i].IsStatic)
|
|
{
|
|
TypeWrapper[] args = methods[i].GetParameters();
|
|
MethodBuilder stub = typeBuilder.DefineMethod(methods[i].Name, MethodAttributes.Public, methods[i].ReturnTypeForDefineMethod, methods[i].GetParametersForDefineMethod());
|
|
AttributeHelper.SetModifiers(stub, methods[i].Modifiers);
|
|
ILGenerator ilgen = stub.GetILGenerator();
|
|
Label end = ilgen.DefineLabel();
|
|
TypeWrapper[] implementers = GetGhostImplementers(wrapper);
|
|
ilgen.Emit(OpCodes.Ldarg_0);
|
|
ilgen.Emit(OpCodes.Ldfld, wrapper.GhostRefField);
|
|
ilgen.Emit(OpCodes.Dup);
|
|
ilgen.Emit(OpCodes.Isinst, wrapper.TypeAsBaseType);
|
|
Label label = ilgen.DefineLabel();
|
|
ilgen.Emit(OpCodes.Brfalse_S, label);
|
|
ilgen.Emit(OpCodes.Castclass, wrapper.TypeAsBaseType);
|
|
for(int k = 0; k < args.Length; k++)
|
|
{
|
|
ilgen.Emit(OpCodes.Ldarg_S, (byte)(k + 1));
|
|
}
|
|
ilgen.Emit(OpCodes.Callvirt, (MethodInfo)methods[i].GetMethod());
|
|
ilgen.Emit(OpCodes.Br, end);
|
|
ilgen.MarkLabel(label);
|
|
for(int j = 0; j < implementers.Length; j++)
|
|
{
|
|
ilgen.Emit(OpCodes.Dup);
|
|
ilgen.Emit(OpCodes.Isinst, implementers[j].TypeAsTBD);
|
|
label = ilgen.DefineLabel();
|
|
ilgen.Emit(OpCodes.Brfalse_S, label);
|
|
ilgen.Emit(OpCodes.Castclass, implementers[j].TypeAsTBD);
|
|
for(int k = 0; k < args.Length; k++)
|
|
{
|
|
ilgen.Emit(OpCodes.Ldarg_S, (byte)(k + 1));
|
|
}
|
|
MethodWrapper mw = implementers[j].GetMethodWrapper(methods[i].Descriptor, true);
|
|
mw.EmitCallvirt(ilgen);
|
|
ilgen.Emit(OpCodes.Br, end);
|
|
ilgen.MarkLabel(label);
|
|
}
|
|
// we need to do a null check (null fails all the isinst checks)
|
|
EmitHelper.NullCheck(ilgen);
|
|
EmitHelper.Throw(ilgen, "java.lang.IncompatibleClassChangeError", wrapper.Name);
|
|
ilgen.MarkLabel(end);
|
|
ilgen.Emit(OpCodes.Ret);
|
|
}
|
|
}
|
|
// HACK create a scope to enable reuse of "implementers" name
|
|
if(true)
|
|
{
|
|
MethodBuilder mb;
|
|
ILGenerator ilgen;
|
|
LocalBuilder local;
|
|
// add implicit conversions for all the ghost implementers
|
|
TypeWrapper[] implementers = GetGhostImplementers(wrapper);
|
|
for(int i = 0; i < implementers.Length; i++)
|
|
{
|
|
mb = typeBuilder.DefineMethod("op_Implicit", MethodAttributes.Public | MethodAttributes.Static | MethodAttributes.SpecialName, wrapper.TypeAsParameterType, new Type[] { implementers[i].TypeAsParameterType });
|
|
AttributeHelper.HideFromJava(mb);
|
|
ilgen = mb.GetILGenerator();
|
|
local = ilgen.DeclareLocal(wrapper.TypeAsParameterType);
|
|
ilgen.Emit(OpCodes.Ldloca, local);
|
|
ilgen.Emit(OpCodes.Ldarg_0);
|
|
ilgen.Emit(OpCodes.Stfld, wrapper.GhostRefField);
|
|
ilgen.Emit(OpCodes.Ldloca, local);
|
|
ilgen.Emit(OpCodes.Ldobj, wrapper.TypeAsParameterType);
|
|
ilgen.Emit(OpCodes.Ret);
|
|
}
|
|
// Implement the "IsInstance" method
|
|
mb = wrapper.ghostIsInstanceMethod;
|
|
AttributeHelper.HideFromJava(mb);
|
|
ilgen = mb.GetILGenerator();
|
|
Label end = ilgen.DefineLabel();
|
|
for(int i = 0; i < implementers.Length; i++)
|
|
{
|
|
ilgen.Emit(OpCodes.Ldarg_0);
|
|
ilgen.Emit(OpCodes.Isinst, implementers[i].TypeAsTBD);
|
|
Label label = ilgen.DefineLabel();
|
|
ilgen.Emit(OpCodes.Brfalse_S, label);
|
|
ilgen.Emit(OpCodes.Ldc_I4_1);
|
|
ilgen.Emit(OpCodes.Br, end);
|
|
ilgen.MarkLabel(label);
|
|
}
|
|
ilgen.Emit(OpCodes.Ldarg_0);
|
|
ilgen.Emit(OpCodes.Isinst, wrapper.TypeAsBaseType);
|
|
ilgen.Emit(OpCodes.Ldnull);
|
|
ilgen.Emit(OpCodes.Cgt_Un);
|
|
ilgen.MarkLabel(end);
|
|
ilgen.Emit(OpCodes.Ret);
|
|
// Implement the "IsInstanceArray" method
|
|
mb = wrapper.ghostIsInstanceArrayMethod;
|
|
AttributeHelper.HideFromJava(mb);
|
|
ilgen = mb.GetILGenerator();
|
|
LocalBuilder localType = ilgen.DeclareLocal(typeof(Type));
|
|
ilgen.Emit(OpCodes.Ldarg_0);
|
|
Label skip = ilgen.DefineLabel();
|
|
ilgen.Emit(OpCodes.Brtrue_S, skip);
|
|
ilgen.Emit(OpCodes.Ldc_I4_0);
|
|
ilgen.Emit(OpCodes.Ret);
|
|
ilgen.MarkLabel(skip);
|
|
ilgen.Emit(OpCodes.Ldarg_0);
|
|
ilgen.Emit(OpCodes.Call, typeof(object).GetMethod("GetType"));
|
|
ilgen.Emit(OpCodes.Stloc, localType);
|
|
skip = ilgen.DefineLabel();
|
|
ilgen.Emit(OpCodes.Br_S, skip);
|
|
Label iter = ilgen.DefineLabel();
|
|
ilgen.MarkLabel(iter);
|
|
ilgen.Emit(OpCodes.Ldarg_1);
|
|
ilgen.Emit(OpCodes.Ldc_I4_1);
|
|
ilgen.Emit(OpCodes.Sub);
|
|
ilgen.Emit(OpCodes.Starg_S, (byte)1);
|
|
ilgen.Emit(OpCodes.Ldloc, localType);
|
|
ilgen.Emit(OpCodes.Callvirt, typeof(Type).GetMethod("GetElementType"));
|
|
ilgen.Emit(OpCodes.Stloc, localType);
|
|
ilgen.MarkLabel(skip);
|
|
ilgen.Emit(OpCodes.Ldloc, localType);
|
|
ilgen.Emit(OpCodes.Callvirt, typeof(Type).GetMethod("get_IsArray"));
|
|
ilgen.Emit(OpCodes.Brtrue_S, iter);
|
|
ilgen.Emit(OpCodes.Ldarg_1);
|
|
skip = ilgen.DefineLabel();
|
|
ilgen.Emit(OpCodes.Brfalse_S, skip);
|
|
ilgen.Emit(OpCodes.Ldc_I4_0);
|
|
ilgen.Emit(OpCodes.Ret);
|
|
ilgen.MarkLabel(skip);
|
|
for(int i = 0; i < implementers.Length; i++)
|
|
{
|
|
ilgen.Emit(OpCodes.Ldtoken, implementers[i].TypeAsTBD);
|
|
ilgen.Emit(OpCodes.Call, typeof(Type).GetMethod("GetTypeFromHandle"));
|
|
ilgen.Emit(OpCodes.Ldloc, localType);
|
|
ilgen.Emit(OpCodes.Callvirt, typeof(Type).GetMethod("IsAssignableFrom"));
|
|
Label label = ilgen.DefineLabel();
|
|
ilgen.Emit(OpCodes.Brfalse_S, label);
|
|
ilgen.Emit(OpCodes.Ldc_I4_1);
|
|
ilgen.Emit(OpCodes.Ret);
|
|
ilgen.MarkLabel(label);
|
|
}
|
|
ilgen.Emit(OpCodes.Ldtoken, wrapper.TypeAsBaseType);
|
|
ilgen.Emit(OpCodes.Call, typeof(Type).GetMethod("GetTypeFromHandle"));
|
|
ilgen.Emit(OpCodes.Ldloc, localType);
|
|
ilgen.Emit(OpCodes.Callvirt, typeof(Type).GetMethod("IsAssignableFrom"));
|
|
ilgen.Emit(OpCodes.Ret);
|
|
|
|
// Implement the "Cast" method
|
|
mb = wrapper.ghostCastMethod;
|
|
AttributeHelper.HideFromJava(mb);
|
|
ilgen = mb.GetILGenerator();
|
|
end = ilgen.DefineLabel();
|
|
for(int i = 0; i < implementers.Length; i++)
|
|
{
|
|
ilgen.Emit(OpCodes.Ldarg_0);
|
|
ilgen.Emit(OpCodes.Isinst, implementers[i].TypeAsTBD);
|
|
ilgen.Emit(OpCodes.Brtrue, end);
|
|
}
|
|
ilgen.Emit(OpCodes.Ldarg_0);
|
|
ilgen.Emit(OpCodes.Castclass, wrapper.TypeAsBaseType);
|
|
ilgen.Emit(OpCodes.Pop);
|
|
ilgen.MarkLabel(end);
|
|
local = ilgen.DeclareLocal(wrapper.TypeAsParameterType);
|
|
ilgen.Emit(OpCodes.Ldloca, local);
|
|
ilgen.Emit(OpCodes.Ldarg_0);
|
|
ilgen.Emit(OpCodes.Stfld, wrapper.ghostRefField);
|
|
ilgen.Emit(OpCodes.Ldloca, local);
|
|
ilgen.Emit(OpCodes.Ldobj, wrapper.TypeAsParameterType);
|
|
ilgen.Emit(OpCodes.Ret);
|
|
// Add "ToObject" methods
|
|
mb = typeBuilder.DefineMethod("ToObject", MethodAttributes.Public, typeof(object), Type.EmptyTypes);
|
|
AttributeHelper.HideFromJava(mb);
|
|
ilgen = mb.GetILGenerator();
|
|
ilgen.Emit(OpCodes.Ldarg_0);
|
|
ilgen.Emit(OpCodes.Ldfld, wrapper.GhostRefField);
|
|
ilgen.Emit(OpCodes.Ret);
|
|
|
|
// Implement the "CastArray" method
|
|
// NOTE unlike "Cast" this doesn't return anything, it just throws a ClassCastException if the
|
|
// cast is unsuccessful. Also, because of the complexity of this test, we call IsInstanceArray
|
|
// instead of reimplementing the check here.
|
|
mb = wrapper.ghostCastArrayMethod;
|
|
AttributeHelper.HideFromJava(mb);
|
|
ilgen = mb.GetILGenerator();
|
|
end = ilgen.DefineLabel();
|
|
ilgen.Emit(OpCodes.Ldarg_0);
|
|
ilgen.Emit(OpCodes.Brfalse_S, end);
|
|
ilgen.Emit(OpCodes.Ldarg_0);
|
|
ilgen.Emit(OpCodes.Ldarg_1);
|
|
ilgen.Emit(OpCodes.Call, wrapper.ghostIsInstanceArrayMethod);
|
|
ilgen.Emit(OpCodes.Brtrue_S, end);
|
|
EmitHelper.Throw(ilgen, "java.lang.ClassCastException");
|
|
ilgen.MarkLabel(end);
|
|
ilgen.Emit(OpCodes.Ret);
|
|
}
|
|
}
|
|
// if we're not abstract make sure we don't inherit any abstract methods
|
|
if(!wrapper.IsAbstract)
|
|
{
|
|
TypeWrapper parent = wrapper.BaseTypeWrapper;
|
|
// if parent is not abstract, the .NET implementation will never have abstract methods (only
|
|
// stubs that throw AbstractMethodError)
|
|
// NOTE interfaces are supposed to be abstract, but the VM doesn't enforce this, so
|
|
// we have to check for a null parent (interfaces have no parent).
|
|
while(parent != null && parent.IsAbstract)
|
|
{
|
|
foreach(MethodWrapper mw in parent.GetMethods())
|
|
{
|
|
MethodInfo mi = mw.GetMethod() as MethodInfo;
|
|
if(mi != null && mi.IsAbstract && wrapper.GetMethodWrapper(mw.Descriptor, true).IsAbstract)
|
|
{
|
|
// NOTE in Sun's JRE 1.4.1 this method cannot be overridden by subclasses,
|
|
// but I think this is a bug, so we'll support it anyway.
|
|
MethodBuilder mb = typeBuilder.DefineMethod(mi.Name, mi.Attributes & ~(MethodAttributes.Abstract|MethodAttributes.NewSlot), CallingConventions.Standard, mw.ReturnTypeForDefineMethod, mw.GetParametersForDefineMethod());
|
|
AttributeHelper.HideFromJava(mb);
|
|
EmitHelper.Throw(mb.GetILGenerator(), "java.lang.AbstractMethodError", wrapper.Name + "." + mw.Name + mw.Signature);
|
|
}
|
|
}
|
|
parent = parent.BaseTypeWrapper;
|
|
}
|
|
}
|
|
bool basehasclinit = wrapper.BaseTypeWrapper != null && wrapper.BaseTypeWrapper.HasStaticInitializer;
|
|
bool hasclinit = false;
|
|
for(int i = 0; i < classFile.Methods.Length; i++)
|
|
{
|
|
ClassFile.Method m = classFile.Methods[i];
|
|
MethodBase mb = methods[i].GetMethod();
|
|
if(mb is ConstructorBuilder)
|
|
{
|
|
ILGenerator ilGenerator = ((ConstructorBuilder)mb).GetILGenerator();
|
|
Tracer.EmitMethodTrace(ilGenerator, classFile.Name + "." + m.Name + m.Signature);
|
|
if(basehasclinit && m.IsClassInitializer && !classFile.IsInterface)
|
|
{
|
|
hasclinit = true;
|
|
// before we call the base class initializer, we need to set the non-final static ConstantValue fields
|
|
EmitConstantValueInitialization(ilGenerator);
|
|
EmitHelper.RunClassConstructor(ilGenerator, Type.BaseType);
|
|
}
|
|
Compiler.Compile(wrapper, methods[i], classFile, m, ilGenerator);
|
|
}
|
|
else
|
|
{
|
|
if(m.IsAbstract)
|
|
{
|
|
// NOTE in the JVM it is apparently legal for a non-abstract class to have abstract methods, but
|
|
// the CLR doens't allow this, so we have to emit a method that throws an AbstractMethodError
|
|
if(!classFile.IsAbstract)
|
|
{
|
|
ILGenerator ilGenerator = ((MethodBuilder)mb).GetILGenerator();
|
|
Tracer.EmitMethodTrace(ilGenerator, classFile.Name + "." + m.Name + m.Signature);
|
|
EmitHelper.Throw(ilGenerator, "java.lang.AbstractMethodError", classFile.Name + "." + m.Name + m.Signature);
|
|
}
|
|
}
|
|
else if(m.IsNative)
|
|
{
|
|
Profiler.Enter("JavaTypeImpl.Finish.Native");
|
|
try
|
|
{
|
|
ILGenerator ilGenerator = ((MethodBuilder)mb).GetILGenerator();
|
|
Tracer.EmitMethodTrace(ilGenerator, classFile.Name + "." + m.Name + m.Signature);
|
|
// do we have a native implementation in map.xml?
|
|
if(nativeMethods != null)
|
|
{
|
|
CodeEmitter opcodes = (CodeEmitter)nativeMethods[classFile.Name + "." + m.Name + m.Signature];
|
|
if(opcodes != null)
|
|
{
|
|
opcodes.Emit(ilGenerator);
|
|
continue;
|
|
}
|
|
}
|
|
// see if there exists a IKVM.NativeCode class for this type
|
|
Type nativeCodeType = Type.GetType("IKVM.NativeCode." + classFile.Name.Replace('$', '+'));
|
|
MethodInfo nativeMethod = null;
|
|
TypeWrapper[] args = methods[i].GetParameters();
|
|
if(nativeCodeType != null)
|
|
{
|
|
TypeWrapper[] nargs = args;
|
|
if(!m.IsStatic)
|
|
{
|
|
nargs = new TypeWrapper[args.Length + 1];
|
|
args.CopyTo(nargs, 1);
|
|
nargs[0] = this.wrapper;
|
|
}
|
|
MethodInfo[] nativeCodeTypeMethods = nativeCodeType.GetMethods(BindingFlags.Static | BindingFlags.Public);
|
|
foreach(MethodInfo method in nativeCodeTypeMethods)
|
|
{
|
|
ParameterInfo[] param = method.GetParameters();
|
|
TypeWrapper[] match = new TypeWrapper[param.Length];
|
|
for(int j = 0; j < param.Length; j++)
|
|
{
|
|
match[j] = ClassLoaderWrapper.GetWrapperFromType(param[j].ParameterType);
|
|
}
|
|
if(m.Name == method.Name && IsCompatibleArgList(nargs, match))
|
|
{
|
|
// TODO instead of taking the first matching method, we should find the best one
|
|
nativeMethod = method;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if(nativeMethod != null)
|
|
{
|
|
int add = 0;
|
|
if(!m.IsStatic)
|
|
{
|
|
ilGenerator.Emit(OpCodes.Ldarg_0);
|
|
add = 1;
|
|
}
|
|
for(int j = 0; j < args.Length; j++)
|
|
{
|
|
ilGenerator.Emit(OpCodes.Ldarg_S, (byte)(j + add));
|
|
}
|
|
ilGenerator.Emit(OpCodes.Call, nativeMethod);
|
|
TypeWrapper retTypeWrapper = methods[i].ReturnType;
|
|
if(!retTypeWrapper.TypeAsTBD.Equals(nativeMethod.ReturnType) && !retTypeWrapper.IsGhost)
|
|
{
|
|
ilGenerator.Emit(OpCodes.Castclass, retTypeWrapper.TypeAsTBD);
|
|
}
|
|
ilGenerator.Emit(OpCodes.Ret);
|
|
}
|
|
else
|
|
{
|
|
if(JVM.NoJniStubs)
|
|
{
|
|
// since NoJniStubs can only be set when we're statically compiling, it is safe to use the "compiler" trace switch
|
|
Tracer.Warning(Tracer.Compiler, "Native method not implemented: {0}.{1}.{2}", classFile.Name, m.Name, m.Signature);
|
|
EmitHelper.Throw(ilGenerator, "java.lang.UnsatisfiedLinkError", "Native method not implemented: " + classFile.Name + "." + m.Name + m.Signature);
|
|
}
|
|
else
|
|
{
|
|
if(ClassLoaderWrapper.IsSaveDebugImage)
|
|
{
|
|
JniProxyBuilder.Generate(ilGenerator, wrapper, methods[i], typeBuilder, classFile, m, args);
|
|
}
|
|
else
|
|
{
|
|
JniBuilder.Generate(ilGenerator, wrapper, methods[i], typeBuilder, classFile, m, args, false);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
finally
|
|
{
|
|
Profiler.Leave("JavaTypeImpl.Finish.Native");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ILGenerator ilGenerator = ((MethodBuilder)mb).GetILGenerator();
|
|
Tracer.EmitMethodTrace(ilGenerator, classFile.Name + "." + m.Name + m.Signature);
|
|
if(nativeMethods != null)
|
|
{
|
|
CodeEmitter opcodes = (CodeEmitter)nativeMethods[classFile.Name + "." + m.Name + m.Signature];
|
|
if(opcodes != null)
|
|
{
|
|
opcodes.Emit(ilGenerator);
|
|
continue;
|
|
}
|
|
}
|
|
Compiler.Compile(wrapper, methods[i], classFile, m, ilGenerator);
|
|
}
|
|
}
|
|
}
|
|
// NOTE non-final fields aren't allowed in interfaces so we don't have to initialize constant fields
|
|
if(!classFile.IsInterface)
|
|
{
|
|
// if we don't have a <clinit> we may need to inject one
|
|
if(!hasclinit)
|
|
{
|
|
bool hasconstantfields = false;
|
|
if(!basehasclinit)
|
|
{
|
|
foreach(ClassFile.Field f in classFile.Fields)
|
|
{
|
|
if(f.IsStatic && !f.IsFinal && f.ConstantValue != null)
|
|
{
|
|
hasconstantfields = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if(basehasclinit || hasconstantfields)
|
|
{
|
|
ConstructorBuilder cb = DefineClassInitializer();
|
|
AttributeHelper.HideFromJava(cb);
|
|
ILGenerator ilGenerator = cb.GetILGenerator();
|
|
EmitConstantValueInitialization(ilGenerator);
|
|
if(basehasclinit)
|
|
{
|
|
EmitHelper.RunClassConstructor(ilGenerator, Type.BaseType);
|
|
}
|
|
ilGenerator.Emit(OpCodes.Ret);
|
|
}
|
|
}
|
|
|
|
// here we loop thru all the interfaces to explicitly implement any methods that we inherit from
|
|
// base types that may have a different name from the name in the interface
|
|
// (e.g. interface that has an equals() method that should override System.Object.Equals())
|
|
// also deals with interface methods that aren't implemented (generate a stub that throws AbstractMethodError)
|
|
// and with methods that aren't public (generate a stub that throws IllegalAccessError)
|
|
Hashtable doneSet = new Hashtable();
|
|
TypeWrapper[] interfaces = wrapper.Interfaces;
|
|
for(int i = 0; i < interfaces.Length; i++)
|
|
{
|
|
// if we implement a ghost interface, add an implicit conversion to the ghost reference value type
|
|
// TODO do this for indirectly implemented interfaces (interfaces implemented by interfaces) as well
|
|
if(interfaces[i].IsGhost)
|
|
{
|
|
MethodBuilder mb = typeBuilder.DefineMethod("op_Implicit", MethodAttributes.Public | MethodAttributes.Static | MethodAttributes.SpecialName, interfaces[i].TypeAsParameterType, new Type[] { wrapper.TypeAsParameterType });
|
|
AttributeHelper.HideFromJava(mb);
|
|
ILGenerator ilgen = mb.GetILGenerator();
|
|
LocalBuilder local = ilgen.DeclareLocal(interfaces[i].TypeAsParameterType);
|
|
ilgen.Emit(OpCodes.Ldloca, local);
|
|
ilgen.Emit(OpCodes.Ldarg_0);
|
|
ilgen.Emit(OpCodes.Stfld, interfaces[i].GhostRefField);
|
|
ilgen.Emit(OpCodes.Ldloca, local);
|
|
ilgen.Emit(OpCodes.Ldobj, interfaces[i].TypeAsParameterType);
|
|
ilgen.Emit(OpCodes.Ret);
|
|
}
|
|
interfaces[i].ImplementInterfaceMethodStubs(typeBuilder, wrapper, doneSet);
|
|
}
|
|
// if any of our base classes has an incomplete interface implementation we need to look through all
|
|
// the base class interfaces to see if we've got an implementation now
|
|
TypeWrapper baseTypeWrapper = wrapper.BaseTypeWrapper;
|
|
while(baseTypeWrapper.HasIncompleteInterfaceImplementation)
|
|
{
|
|
for(int i = 0; i < baseTypeWrapper.Interfaces.Length; i++)
|
|
{
|
|
baseTypeWrapper.Interfaces[i].ImplementInterfaceMethodStubs(typeBuilder, wrapper, doneSet);
|
|
}
|
|
baseTypeWrapper = baseTypeWrapper.BaseTypeWrapper;
|
|
}
|
|
foreach(MethodWrapper mw in methods)
|
|
{
|
|
if(mw.Name != "<init>" && !mw.IsStatic && !mw.IsPrivate)
|
|
{
|
|
if(wrapper.BaseTypeWrapper != null && wrapper.BaseTypeWrapper.HasIncompleteInterfaceImplementation)
|
|
{
|
|
Hashtable hashtable = null;
|
|
TypeWrapper tw = wrapper.BaseTypeWrapper;
|
|
while(tw.HasIncompleteInterfaceImplementation)
|
|
{
|
|
foreach(TypeWrapper iface in tw.Interfaces)
|
|
{
|
|
AddMethodOverride(mw, (MethodBuilder)mw.GetMethod(), iface, mw.Descriptor, ref hashtable, false);
|
|
}
|
|
tw = tw.BaseTypeWrapper;
|
|
}
|
|
}
|
|
if(true)
|
|
{
|
|
Hashtable hashtable = null;
|
|
foreach(TypeWrapper iface in wrapper.Interfaces)
|
|
{
|
|
AddMethodOverride(mw, (MethodBuilder)mw.GetMethod(), iface, mw.Descriptor, ref hashtable, true);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
Type type;
|
|
Profiler.Enter("TypeBuilder.CreateType");
|
|
try
|
|
{
|
|
type = typeBuilder.CreateType();
|
|
}
|
|
finally
|
|
{
|
|
Profiler.Leave("TypeBuilder.CreateType");
|
|
}
|
|
ClassLoaderWrapper.SetWrapperForType(type, wrapper);
|
|
finishedType = new FinishedTypeImpl(type, typeBuilderGhostInterface != null ? typeBuilderGhostInterface.CreateType() : null, innerClassesTypeWrappers, declaringTypeWrapper, this.ReflectiveModifiers);
|
|
return finishedType;
|
|
}
|
|
catch(Exception x)
|
|
{
|
|
JVM.CriticalFailure("Exception during finishing of: " + wrapper.Name, x);
|
|
return null;
|
|
}
|
|
finally
|
|
{
|
|
Profiler.Leave("JavaTypeImpl.Finish.Core");
|
|
}
|
|
}
|
|
|
|
internal class JniProxyBuilder
|
|
{
|
|
private static ModuleBuilder mod;
|
|
private static int count;
|
|
|
|
static JniProxyBuilder()
|
|
{
|
|
mod = ((AssemblyBuilder)ClassLoaderWrapper.GetBootstrapClassLoader().ModuleBuilder.Assembly).DefineDynamicModule("jniproxy.dll", "jniproxy.dll");
|
|
}
|
|
|
|
private static string Cleanup(string n)
|
|
{
|
|
n = n.Replace('\\', '_');
|
|
n = n.Replace('[', '_');
|
|
n = n.Replace(']', '_');
|
|
n = n.Replace('+', '_');
|
|
n = n.Replace(',', '_');
|
|
return n;
|
|
}
|
|
|
|
internal static void Generate(ILGenerator ilGenerator, DynamicTypeWrapper wrapper, MethodWrapper mw, TypeBuilder typeBuilder, ClassFile classFile, ClassFile.Method m, TypeWrapper[] args)
|
|
{
|
|
TypeBuilder tb = mod.DefineType("class" + (count++), TypeAttributes.Public | TypeAttributes.Class);
|
|
int instance = m.IsStatic ? 0 : 1;
|
|
Type[] argTypes = new Type[args.Length + instance + 1];
|
|
if(instance != 0)
|
|
{
|
|
argTypes[0] = wrapper.TypeAsParameterType;
|
|
}
|
|
for(int i = 0; i < args.Length; i++)
|
|
{
|
|
argTypes[i + instance] = args[i].TypeAsParameterType;
|
|
}
|
|
argTypes[argTypes.Length - 1] = typeof(RuntimeMethodHandle);
|
|
MethodBuilder mb = tb.DefineMethod("method", MethodAttributes.Public | MethodAttributes.Static, mw.ReturnType.TypeAsParameterType, argTypes);
|
|
JniBuilder.Generate(mb.GetILGenerator(), wrapper, mw, tb, classFile, m, args, true);
|
|
for(int i = 0; i < argTypes.Length - 1; i++)
|
|
{
|
|
ilGenerator.Emit(OpCodes.Ldarg, (short)i);
|
|
}
|
|
ilGenerator.Emit(OpCodes.Ldtoken, (MethodInfo)mw.GetMethod());
|
|
ilGenerator.Emit(OpCodes.Call, mb);
|
|
ilGenerator.Emit(OpCodes.Ret);
|
|
Type type = tb.CreateType();
|
|
// HACK since we're creating a type in the dynamic assembly, we must also register its wrapper,
|
|
// because the ClassLoaderWrapper assumes that all dynamic types are in its hashtable,
|
|
// but note that this only registers it for reverse lookup (from Type -> TypeWrapper), this
|
|
// is necessary to make stack walking work.
|
|
ClassLoaderWrapper.SetWrapperForType(type, new CompiledTypeWrapper(type.FullName, type));
|
|
}
|
|
}
|
|
|
|
private class JniBuilder
|
|
{
|
|
private static readonly Type localRefStructType = typeof(IKVM.Runtime.JNI.Frame);
|
|
private static readonly MethodInfo jniFuncPtrMethod = localRefStructType.GetMethod("GetFuncPtr");
|
|
private static readonly MethodInfo enterLocalRefStruct = localRefStructType.GetMethod("Enter");
|
|
private static readonly MethodInfo leaveLocalRefStruct = localRefStructType.GetMethod("Leave");
|
|
private static readonly MethodInfo makeLocalRef = localRefStructType.GetMethod("MakeLocalRef");
|
|
private static readonly MethodInfo unwrapLocalRef = localRefStructType.GetMethod("UnwrapLocalRef");
|
|
private static readonly MethodInfo getClassFromTypeHandle = typeof(ByteCodeHelper).GetMethod("GetClassFromTypeHandle");
|
|
private static readonly MethodInfo writeLine = typeof(Console).GetMethod("WriteLine", new Type[] { typeof(object) }, null);
|
|
private static readonly MethodInfo monitorEnter = typeof(ByteCodeHelper).GetMethod("monitorenter");
|
|
private static readonly MethodInfo monitorExit = typeof(System.Threading.Monitor).GetMethod("Exit", new Type[] { typeof(object) });
|
|
|
|
internal static void Generate(ILGenerator ilGenerator, DynamicTypeWrapper wrapper, MethodWrapper mw, TypeBuilder typeBuilder, ClassFile classFile, ClassFile.Method m, TypeWrapper[] args, bool thruProxy)
|
|
{
|
|
LocalBuilder syncObject = null;
|
|
FieldInfo classObjectField;
|
|
if(thruProxy)
|
|
{
|
|
classObjectField = typeBuilder.DefineField("__<classObject>", typeof(object), FieldAttributes.Static | FieldAttributes.Private);
|
|
}
|
|
else
|
|
{
|
|
classObjectField = wrapper.ClassObjectField;
|
|
}
|
|
if(m.IsSynchronized)
|
|
{
|
|
if(m.IsStatic)
|
|
{
|
|
ilGenerator.Emit(OpCodes.Ldsfld, classObjectField);
|
|
Label label = ilGenerator.DefineLabel();
|
|
ilGenerator.Emit(OpCodes.Brtrue_S, label);
|
|
ilGenerator.Emit(OpCodes.Ldtoken, wrapper.TypeAsTBD);
|
|
ilGenerator.Emit(OpCodes.Call, getClassFromTypeHandle);
|
|
ilGenerator.Emit(OpCodes.Stsfld, classObjectField);
|
|
ilGenerator.MarkLabel(label);
|
|
ilGenerator.Emit(OpCodes.Ldsfld, classObjectField);
|
|
}
|
|
else
|
|
{
|
|
ilGenerator.Emit(OpCodes.Ldarg_0);
|
|
}
|
|
ilGenerator.Emit(OpCodes.Dup);
|
|
syncObject = ilGenerator.DeclareLocal(typeof(object));
|
|
ilGenerator.Emit(OpCodes.Stloc, syncObject);
|
|
ilGenerator.Emit(OpCodes.Call, monitorEnter);
|
|
ilGenerator.BeginExceptionBlock();
|
|
}
|
|
FieldBuilder methodPtr = typeBuilder.DefineField(JNI.METHOD_PTR_FIELD_PREFIX + m.Name + m.Signature + ">", typeof(IntPtr), FieldAttributes.Static | FieldAttributes.PrivateScope);
|
|
LocalBuilder localRefStruct = ilGenerator.DeclareLocal(localRefStructType);
|
|
ilGenerator.Emit(OpCodes.Ldloca, localRefStruct);
|
|
ilGenerator.Emit(OpCodes.Initobj, localRefStructType);
|
|
ilGenerator.Emit(OpCodes.Ldsfld, methodPtr);
|
|
Label oklabel = ilGenerator.DefineLabel();
|
|
ilGenerator.Emit(OpCodes.Brtrue, oklabel);
|
|
if(thruProxy)
|
|
{
|
|
ilGenerator.Emit(OpCodes.Ldarg_S, (byte)(args.Length + (mw.IsStatic ? 0 : 1)));
|
|
}
|
|
else
|
|
{
|
|
ilGenerator.Emit(OpCodes.Ldtoken, (MethodInfo)mw.GetMethod());
|
|
}
|
|
ilGenerator.Emit(OpCodes.Ldstr, classFile.Name.Replace('.', '/'));
|
|
ilGenerator.Emit(OpCodes.Ldstr, m.Name);
|
|
ilGenerator.Emit(OpCodes.Ldstr, m.Signature.Replace('.', '/'));
|
|
ilGenerator.Emit(OpCodes.Call, jniFuncPtrMethod);
|
|
ilGenerator.Emit(OpCodes.Stsfld, methodPtr);
|
|
ilGenerator.MarkLabel(oklabel);
|
|
ilGenerator.Emit(OpCodes.Ldloca, localRefStruct);
|
|
if(thruProxy)
|
|
{
|
|
ilGenerator.Emit(OpCodes.Ldarg_S, (byte)(args.Length + (mw.IsStatic ? 0 : 1)));
|
|
}
|
|
else
|
|
{
|
|
ilGenerator.Emit(OpCodes.Ldtoken, (MethodInfo)mw.GetMethod());
|
|
}
|
|
ilGenerator.Emit(OpCodes.Call, enterLocalRefStruct);
|
|
LocalBuilder jnienv = ilGenerator.DeclareLocal(typeof(IntPtr));
|
|
ilGenerator.Emit(OpCodes.Stloc, jnienv);
|
|
Label tryBlock = ilGenerator.BeginExceptionBlock();
|
|
TypeWrapper retTypeWrapper = mw.ReturnType;
|
|
if(!retTypeWrapper.IsPrimitive)
|
|
{
|
|
// this one is for use after we return from "calli"
|
|
ilGenerator.Emit(OpCodes.Ldloca, localRefStruct);
|
|
}
|
|
ilGenerator.Emit(OpCodes.Ldloc, jnienv);
|
|
Type[] modargs = new Type[args.Length + 2];
|
|
modargs[0] = typeof(IntPtr);
|
|
modargs[1] = typeof(IntPtr);
|
|
for(int i = 0; i < args.Length; i++)
|
|
{
|
|
modargs[i + 2] = args[i].TypeAsParameterType;
|
|
}
|
|
int add = 0;
|
|
if(!m.IsStatic)
|
|
{
|
|
ilGenerator.Emit(OpCodes.Ldloca, localRefStruct);
|
|
ilGenerator.Emit(OpCodes.Ldarg_0);
|
|
ilGenerator.Emit(OpCodes.Call, makeLocalRef);
|
|
add = 1;
|
|
}
|
|
else
|
|
{
|
|
ilGenerator.Emit(OpCodes.Ldloca, localRefStruct);
|
|
|
|
ilGenerator.Emit(OpCodes.Ldsfld, classObjectField);
|
|
Label label = ilGenerator.DefineLabel();
|
|
ilGenerator.Emit(OpCodes.Brtrue_S, label);
|
|
ilGenerator.Emit(OpCodes.Ldtoken, wrapper.TypeAsTBD);
|
|
ilGenerator.Emit(OpCodes.Call, getClassFromTypeHandle);
|
|
ilGenerator.Emit(OpCodes.Stsfld, classObjectField);
|
|
ilGenerator.MarkLabel(label);
|
|
ilGenerator.Emit(OpCodes.Ldsfld, classObjectField);
|
|
|
|
ilGenerator.Emit(OpCodes.Call, makeLocalRef);
|
|
}
|
|
for(int j = 0; j < args.Length; j++)
|
|
{
|
|
if(!args[j].IsPrimitive)
|
|
{
|
|
ilGenerator.Emit(OpCodes.Ldloca, localRefStruct);
|
|
ilGenerator.Emit(OpCodes.Ldarg_S, (byte)(j + add));
|
|
if(args[j].IsNonPrimitiveValueType)
|
|
{
|
|
args[j].EmitBox(ilGenerator);
|
|
}
|
|
ilGenerator.Emit(OpCodes.Call, makeLocalRef);
|
|
modargs[j + 2] = typeof(IntPtr);
|
|
}
|
|
else
|
|
{
|
|
ilGenerator.Emit(OpCodes.Ldarg_S, (byte)(j + add));
|
|
}
|
|
}
|
|
ilGenerator.Emit(OpCodes.Ldsfld, methodPtr);
|
|
ilGenerator.EmitCalli(OpCodes.Calli, System.Runtime.InteropServices.CallingConvention.StdCall, (retTypeWrapper.IsPrimitive) ? retTypeWrapper.TypeAsParameterType : typeof(IntPtr), modargs);
|
|
LocalBuilder retValue = null;
|
|
if(retTypeWrapper != PrimitiveTypeWrapper.VOID)
|
|
{
|
|
if(!retTypeWrapper.IsUnloadable && !retTypeWrapper.IsPrimitive)
|
|
{
|
|
ilGenerator.Emit(OpCodes.Call, unwrapLocalRef);
|
|
if(retTypeWrapper.IsNonPrimitiveValueType)
|
|
{
|
|
retTypeWrapper.EmitUnbox(ilGenerator);
|
|
}
|
|
else if(!retTypeWrapper.IsGhost)
|
|
{
|
|
ilGenerator.Emit(OpCodes.Castclass, retTypeWrapper.TypeAsTBD);
|
|
}
|
|
}
|
|
retValue = ilGenerator.DeclareLocal(retTypeWrapper.TypeAsParameterType);
|
|
ilGenerator.Emit(OpCodes.Stloc, retValue);
|
|
}
|
|
ilGenerator.BeginCatchBlock(typeof(object));
|
|
ilGenerator.EmitWriteLine("*** exception in native code ***");
|
|
ilGenerator.Emit(OpCodes.Call, writeLine);
|
|
ilGenerator.Emit(OpCodes.Rethrow);
|
|
ilGenerator.BeginFinallyBlock();
|
|
ilGenerator.Emit(OpCodes.Ldloca, localRefStruct);
|
|
ilGenerator.Emit(OpCodes.Call, leaveLocalRefStruct);
|
|
ilGenerator.EndExceptionBlock();
|
|
if(m.IsSynchronized)
|
|
{
|
|
ilGenerator.BeginFinallyBlock();
|
|
ilGenerator.Emit(OpCodes.Ldloc, syncObject);
|
|
ilGenerator.Emit(OpCodes.Call, monitorExit);
|
|
ilGenerator.EndExceptionBlock();
|
|
}
|
|
if(retTypeWrapper != PrimitiveTypeWrapper.VOID)
|
|
{
|
|
ilGenerator.Emit(OpCodes.Ldloc, retValue);
|
|
}
|
|
ilGenerator.Emit(OpCodes.Ret);
|
|
}
|
|
}
|
|
|
|
internal override TypeWrapper[] InnerClasses
|
|
{
|
|
get
|
|
{
|
|
throw new InvalidOperationException("InnerClasses is only available for finished types");
|
|
}
|
|
}
|
|
|
|
internal override TypeWrapper DeclaringTypeWrapper
|
|
{
|
|
get
|
|
{
|
|
throw new InvalidOperationException("DeclaringTypeWrapper is only available for finished types");
|
|
}
|
|
}
|
|
|
|
internal override Modifiers ReflectiveModifiers
|
|
{
|
|
get
|
|
{
|
|
ClassFile.InnerClass[] innerclasses = classFile.InnerClasses;
|
|
if(innerclasses != null)
|
|
{
|
|
for(int i = 0; i < innerclasses.Length; i++)
|
|
{
|
|
if(innerclasses[i].innerClass != 0)
|
|
{
|
|
if(classFile.GetConstantPoolClass(innerclasses[i].innerClass) == wrapper.Name)
|
|
{
|
|
return innerclasses[i].accessFlags;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return classFile.Modifiers;
|
|
}
|
|
}
|
|
|
|
internal override FieldWrapper GetFieldImpl(string fieldName, string fieldSig)
|
|
{
|
|
if(fieldLookup == null)
|
|
{
|
|
fields = new FieldWrapper[classFile.Fields.Length];
|
|
fieldLookup = new Hashtable();
|
|
for(int i = 0; i < classFile.Fields.Length; i++)
|
|
{
|
|
fieldLookup[classFile.Fields[i].Name + classFile.Fields[i].Signature] = i;
|
|
}
|
|
}
|
|
object index = fieldLookup[fieldName + fieldSig];
|
|
if(index != null)
|
|
{
|
|
int i = (int)index;
|
|
if(fields[i] == null)
|
|
{
|
|
GenerateField(i);
|
|
}
|
|
return fields[i];
|
|
}
|
|
return null;
|
|
}
|
|
|
|
private void UpdateClashTable()
|
|
{
|
|
lock(this)
|
|
{
|
|
if(memberclashtable == null)
|
|
{
|
|
memberclashtable = new Hashtable();
|
|
for(int i = 0; i < methods.Length; i++)
|
|
{
|
|
// TODO at the moment we don't support constructor signature clash resolving, so we better
|
|
// not put them in the clash table
|
|
if(methods[i].IsLinked && methods[i].Name != "<init>")
|
|
{
|
|
string key = GenerateClashKey("method", methods[i].RealName, methods[i].ReturnTypeForDefineMethod, methods[i].GetParametersForDefineMethod());
|
|
memberclashtable.Add(key, key);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private string GenerateClashKey(string type, string name, Type retOrFieldType, Type[] args)
|
|
{
|
|
System.Text.StringBuilder sb = new System.Text.StringBuilder(type);
|
|
sb.Append(':').Append(name).Append(':').Append(retOrFieldType.FullName);
|
|
if(args != null)
|
|
{
|
|
foreach(Type t in args)
|
|
{
|
|
sb.Append(':').Append(t.FullName);
|
|
}
|
|
}
|
|
return sb.ToString();
|
|
}
|
|
|
|
private void GenerateField(int i)
|
|
{
|
|
Profiler.Enter("JavaTypeImpl.GenerateField");
|
|
try
|
|
{
|
|
FieldBuilder field;
|
|
ClassFile.Field fld = classFile.Fields[i];
|
|
string fieldName = fld.Name;
|
|
// TODO we're not allowed to load types here (potentially), it needs to be done in the Link step
|
|
TypeWrapper typeWrapper = ClassFile.FieldTypeWrapperFromSig(wrapper.GetClassLoader(), classCache, fld.Signature);
|
|
Type type = typeWrapper.TypeAsFieldType;
|
|
bool setNameSig = typeWrapper.IsUnloadable || typeWrapper.IsGhostArray;
|
|
if(setNameSig)
|
|
{
|
|
// TODO use clashtable
|
|
// the field name is mangled here, because otherwise it can (theoretically)
|
|
// conflict with another unloadable or object or ghost array field
|
|
// (fields can be overloaded on type)
|
|
fieldName += "/" + typeWrapper.Name;
|
|
}
|
|
FieldAttributes attribs = 0;
|
|
MethodAttributes methodAttribs = 0;
|
|
bool setModifiers = false;
|
|
if(fld.IsPrivate)
|
|
{
|
|
attribs |= FieldAttributes.Private;
|
|
}
|
|
else if(fld.IsProtected)
|
|
{
|
|
attribs |= FieldAttributes.FamORAssem;
|
|
methodAttribs |= MethodAttributes.FamORAssem;
|
|
}
|
|
else if(fld.IsPublic)
|
|
{
|
|
attribs |= FieldAttributes.Public;
|
|
methodAttribs |= MethodAttributes.Public;
|
|
}
|
|
else
|
|
{
|
|
attribs |= FieldAttributes.Assembly;
|
|
methodAttribs |= MethodAttributes.Assembly;
|
|
}
|
|
if(fld.IsStatic)
|
|
{
|
|
attribs |= FieldAttributes.Static;
|
|
methodAttribs |= MethodAttributes.Static;
|
|
}
|
|
// NOTE "constant" static finals are converted into literals
|
|
// TODO it would be possible for Java code to change the value of a non-blank static final, but I don't
|
|
// know if we want to support this (since the Java JITs don't really support it either)
|
|
object constantValue = fld.ConstantValue;
|
|
if(fld.IsStatic && fld.IsFinal && constantValue != null)
|
|
{
|
|
Profiler.Count("Static Final Constant");
|
|
attribs |= FieldAttributes.Literal;
|
|
field = typeBuilder.DefineField(fieldName, type, attribs);
|
|
field.SetConstant(constantValue);
|
|
fields[i] = new ConstantFieldWrapper(wrapper, typeWrapper, fld.Name, fld.Signature, fld.Modifiers, field, constantValue);
|
|
}
|
|
else
|
|
{
|
|
bool isWrappedFinal = fld.IsFinal && (fld.IsPublic || fld.IsProtected) && !wrapper.IsInterface;
|
|
if(isWrappedFinal)
|
|
{
|
|
// NOTE public/protected blank final fields get converted into a read-only property with a private field
|
|
// backing store
|
|
// we used to make the field privatescope, but that really serves no purpose (and it hinders
|
|
// serialization, which uses .NET reflection to get at the field)
|
|
attribs &= ~FieldAttributes.FieldAccessMask;
|
|
attribs |= FieldAttributes.Private;
|
|
setModifiers = true;
|
|
}
|
|
else if(fld.IsFinal)
|
|
{
|
|
setModifiers = true;
|
|
}
|
|
field = typeBuilder.DefineField(fieldName, type, attribs);
|
|
if(fld.IsTransient)
|
|
{
|
|
CustomAttributeBuilder transientAttrib = new CustomAttributeBuilder(typeof(NonSerializedAttribute).GetConstructor(Type.EmptyTypes), new object[0]);
|
|
field.SetCustomAttribute(transientAttrib);
|
|
}
|
|
if(fld.IsVolatile)
|
|
{
|
|
// TODO the field should be marked as modreq(IsVolatile), but Reflection.Emit doesn't have a way of doing this
|
|
setModifiers = true;
|
|
}
|
|
// Instance fields can also have a ConstantValue attribute (and are inlined by the compiler),
|
|
// and ikvmstub has to export them, so we have to add a custom attribute.
|
|
if(constantValue != null)
|
|
{
|
|
CustomAttributeBuilder constantValueAttrib = new CustomAttributeBuilder(typeof(ConstantValueAttribute).GetConstructor(new Type[] { constantValue.GetType() }), new object[] { constantValue });
|
|
field.SetCustomAttribute(constantValueAttrib);
|
|
}
|
|
if(isWrappedFinal)
|
|
{
|
|
methodAttribs |= MethodAttributes.SpecialName;
|
|
// TODO we should ensure that the getter method name doesn't clash with an existing method
|
|
MethodBuilder getter = typeBuilder.DefineMethod("get_" + fld.Name, methodAttribs, CallingConventions.Standard, type, Type.EmptyTypes);
|
|
AttributeHelper.HideFromJava(getter);
|
|
ILGenerator ilgen = getter.GetILGenerator();
|
|
if(fld.IsStatic)
|
|
{
|
|
ilgen.Emit(OpCodes.Ldsfld, field);
|
|
}
|
|
else
|
|
{
|
|
ilgen.Emit(OpCodes.Ldarg_0);
|
|
ilgen.Emit(OpCodes.Ldfld, field);
|
|
}
|
|
ilgen.Emit(OpCodes.Ret);
|
|
PropertyBuilder pb = typeBuilder.DefineProperty(fld.Name, PropertyAttributes.None, type, Type.EmptyTypes);
|
|
pb.SetGetMethod(getter);
|
|
fields[i] = new GetterFieldWrapper(wrapper, typeWrapper, field, fld.Name, fld.Signature, fld.Modifiers, getter);
|
|
}
|
|
else
|
|
{
|
|
fields[i] = FieldWrapper.Create(wrapper, typeWrapper, field, fld.Name, fld.Signature, fld.Modifiers);
|
|
}
|
|
}
|
|
// if the Java modifiers cannot be expressed in .NET, we emit the Modifiers attribute to store
|
|
// the Java modifiers
|
|
if(setModifiers)
|
|
{
|
|
AttributeHelper.SetModifiers(field, fld.Modifiers);
|
|
}
|
|
if(setNameSig)
|
|
{
|
|
AttributeHelper.SetNameSig(field, fld.Name, fld.Signature);
|
|
}
|
|
if(JVM.IsStaticCompiler && fld.DeprecatedAttribute)
|
|
{
|
|
AttributeHelper.SetDeprecatedAttribute(field);
|
|
}
|
|
}
|
|
finally
|
|
{
|
|
Profiler.Leave("JavaTypeImpl.GenerateField");
|
|
}
|
|
}
|
|
|
|
private ConstructorBuilder DefineClassInitializer()
|
|
{
|
|
if(!classFile.IsFinal && !classFile.IsInterface && wrapper.HasStaticInitializer)
|
|
{
|
|
// We create a field that the derived classes can access in their .cctor to trigger our .cctor
|
|
// (previously we used RuntimeHelpers.RunClassConstructor, but that is slow and requires additional privileges)
|
|
FieldBuilder field = typeBuilder.DefineField("__<clinit>", typeof(int), FieldAttributes.SpecialName | FieldAttributes.Family | FieldAttributes.Static);
|
|
AttributeHelper.HideFromJava(field);
|
|
}
|
|
if(typeBuilder.IsInterface)
|
|
{
|
|
// LAMESPEC the ECMA spec says (part. I, sect. 8.5.3.2) that all interface members must be public, so we make
|
|
// the class constructor public
|
|
return typeBuilder.DefineConstructor(MethodAttributes.Static | MethodAttributes.Public, CallingConventions.Standard, Type.EmptyTypes);
|
|
}
|
|
// NOTE we don't need to record the modifiers here, because they aren't visible from Java reflection
|
|
return typeBuilder.DefineTypeInitializer();
|
|
}
|
|
|
|
// this finds the method that md is going to be overriding
|
|
private MethodWrapper FindBaseMethod(MethodDescriptor md, out bool explicitOverride)
|
|
{
|
|
Debug.Assert(!classFile.IsInterface);
|
|
Debug.Assert(md.Name != "<init>");
|
|
|
|
explicitOverride = false;
|
|
TypeWrapper tw = wrapper.BaseTypeWrapper;
|
|
while(tw != null)
|
|
{
|
|
// TODO we need to handle static methods (duh!)
|
|
MethodWrapper baseMethod = tw.GetMethodWrapper(md, true);
|
|
if(baseMethod == null)
|
|
{
|
|
return null;
|
|
}
|
|
// here are the complex rules for determining whether this method overrides the method we found
|
|
// RULE 1: final methods may not be overridden
|
|
if(baseMethod.IsFinal && !baseMethod.IsPrivate)
|
|
{
|
|
throw new VerifyError("final method " + baseMethod.Name + baseMethod.Signature + " in " + tw.Name + " is overriden in " + wrapper.Name);
|
|
}
|
|
// RULE 2: public & protected methods can be overridden (package methods are handled by RULE 4)
|
|
// (by public, protected & *package* methods [even if they are in a different package])
|
|
if(baseMethod.IsPublic || baseMethod.IsProtected)
|
|
{
|
|
// if we already encountered a package method, we cannot override the base method of
|
|
// that package method
|
|
if(explicitOverride)
|
|
{
|
|
explicitOverride = false;
|
|
return null;
|
|
}
|
|
return baseMethod;
|
|
}
|
|
// RULE 3: private methods are ignored
|
|
if(!baseMethod.IsPrivate)
|
|
{
|
|
// RULE 4: package methods can only be overridden in the same package
|
|
if(baseMethod.DeclaringType.IsInSamePackageAs(wrapper))
|
|
{
|
|
return baseMethod;
|
|
}
|
|
// since we encountered a method with the same name/signature that we aren't overriding,
|
|
// we need to specify an explicit override
|
|
// NOTE we only do this if baseMethod isn't private, because if it is, Reflection.Emit
|
|
// will complain about the explicit MethodOverride (possibly a bug)
|
|
explicitOverride = true;
|
|
}
|
|
tw = baseMethod.DeclaringType.BaseTypeWrapper;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
private string GenerateUniqueMethodName(string basename, MethodWrapper mw)
|
|
{
|
|
string name = basename;
|
|
string key = GenerateClashKey("method", name, mw.ReturnTypeForDefineMethod, mw.GetParametersForDefineMethod());
|
|
UpdateClashTable();
|
|
lock(memberclashtable.SyncRoot)
|
|
{
|
|
for(int clashcount = 0; memberclashtable.ContainsKey(key); clashcount++)
|
|
{
|
|
name = basename + "$" + clashcount;
|
|
key = GenerateClashKey("method", name, mw.ReturnTypeForDefineMethod, mw.GetParametersForDefineMethod());
|
|
}
|
|
memberclashtable.Add(key, key);
|
|
}
|
|
return name;
|
|
}
|
|
|
|
private MethodBase GenerateMethod(int index, bool unloadableOverrideStub)
|
|
{
|
|
methods[index].AssertLinked();
|
|
Profiler.Enter("JavaTypeImpl.GenerateMethod");
|
|
try
|
|
{
|
|
if(index >= classFile.Methods.Length)
|
|
{
|
|
// We're a Miranda method
|
|
Debug.Assert(baseMethods[index].DeclaringType.IsInterface);
|
|
string name = GenerateUniqueMethodName(methods[index].Name, baseMethods[index]);
|
|
// TODO if the interface is not public, we probably shouldn't make the Miranda method public
|
|
MethodBuilder mb = typeBuilder.DefineMethod(methods[index].Name, MethodAttributes.NewSlot | MethodAttributes.Public | MethodAttributes.Virtual | MethodAttributes.Abstract | MethodAttributes.CheckAccessOnOverride, baseMethods[index].ReturnTypeForDefineMethod, baseMethods[index].GetParametersForDefineMethod());
|
|
AttributeHelper.MirandaMethod(mb);
|
|
if(unloadableOverrideStub || name != methods[index].Name)
|
|
{
|
|
// instead of creating an override stub, we created the Miranda method with the proper signature and
|
|
// decorate it with a NameSigAttribute that contains the real signature
|
|
AttributeHelper.SetNameSig(mb, methods[index].Name, methods[index].Signature);
|
|
}
|
|
// if we changed the name or if the interface method name is remapped, we need to add an explicit methodoverride.
|
|
if(name != baseMethods[index].RealName)
|
|
{
|
|
typeBuilder.DefineMethodOverride(mb, (MethodInfo)baseMethods[index].GetMethod());
|
|
}
|
|
return mb;
|
|
}
|
|
ClassFile.Method m = classFile.Methods[index];
|
|
MethodBase method;
|
|
bool setNameSig = methods[index].ReturnType.IsUnloadable || methods[index].ReturnType.IsGhostArray;
|
|
foreach(TypeWrapper tw in methods[index].GetParameters())
|
|
{
|
|
setNameSig |= tw.IsUnloadable || tw.IsGhostArray;
|
|
}
|
|
bool setModifiers = m.IsNative;
|
|
MethodAttributes attribs = 0;
|
|
if(m.IsPrivate)
|
|
{
|
|
attribs |= MethodAttributes.Private;
|
|
}
|
|
else if(m.IsProtected)
|
|
{
|
|
attribs |= MethodAttributes.FamORAssem;
|
|
}
|
|
else if(m.IsPublic)
|
|
{
|
|
attribs |= MethodAttributes.Public;
|
|
}
|
|
else
|
|
{
|
|
attribs |= MethodAttributes.Assembly;
|
|
}
|
|
if(m.Name == "<init>")
|
|
{
|
|
if(setNameSig)
|
|
{
|
|
// TODO we might have to mangle the signature to make it unique
|
|
}
|
|
// strictfp is the only modifier that a constructor can have
|
|
if(m.IsStrictfp)
|
|
{
|
|
setModifiers = true;
|
|
}
|
|
method = typeBuilder.DefineConstructor(attribs, CallingConventions.Standard, methods[index].GetParametersForDefineMethod());
|
|
if(JVM.IsStaticCompiler || ClassLoaderWrapper.IsSaveDebugImage)
|
|
{
|
|
AddParameterNames(method, m);
|
|
}
|
|
}
|
|
else if(m.IsClassInitializer)
|
|
{
|
|
method = DefineClassInitializer();
|
|
}
|
|
else
|
|
{
|
|
if(m.IsAbstract)
|
|
{
|
|
// only if the classfile is abstract, we make the CLR method abstract, otherwise,
|
|
// we have to generate a method that throws an AbstractMethodError (because the JVM
|
|
// allows abstract methods in non-abstract classes)
|
|
if(classFile.IsAbstract)
|
|
{
|
|
attribs |= MethodAttributes.Abstract;
|
|
}
|
|
else
|
|
{
|
|
setModifiers = true;
|
|
}
|
|
}
|
|
if(m.IsFinal)
|
|
{
|
|
if(!m.IsStatic && !m.IsPrivate)
|
|
{
|
|
attribs |= MethodAttributes.Final;
|
|
}
|
|
else
|
|
{
|
|
setModifiers = true;
|
|
}
|
|
}
|
|
if(m.IsStatic)
|
|
{
|
|
attribs |= MethodAttributes.Static;
|
|
}
|
|
else if(!m.IsPrivate)
|
|
{
|
|
attribs |= MethodAttributes.Virtual | MethodAttributes.CheckAccessOnOverride;
|
|
}
|
|
string name = m.Name;
|
|
MethodDescriptor md = methods[index].Descriptor;
|
|
// if a method is virtual, we need to find the method it overrides (if any), for several reasons:
|
|
// - if we're overriding a method that has a different name (e.g. some of the virtual methods
|
|
// in System.Object [Equals <-> equals]) we need to add an explicit MethodOverride
|
|
// - if one of the base classes has a similar method that is private (or package) that we aren't
|
|
// overriding, we need to specify an explicit MethodOverride
|
|
MethodWrapper baseMce = baseMethods[index];
|
|
bool explicitOverride = methods[index].IsExplicitOverride;
|
|
if((attribs & MethodAttributes.Virtual) != 0 && !classFile.IsInterface)
|
|
{
|
|
// make sure the base method is already defined
|
|
Debug.Assert(baseMce == null || baseMce.GetMethod() != null);
|
|
if(baseMce == null || baseMce.DeclaringType.IsInterface)
|
|
{
|
|
// we need to set NewSlot here, to prevent accidentally overriding methods
|
|
// (for example, if a Java class has a method "boolean Equals(object)", we don't want that method
|
|
// to override System.Object.Equals)
|
|
attribs |= MethodAttributes.NewSlot;
|
|
}
|
|
else
|
|
{
|
|
// if we have a method overriding a more accessible method (the JVM allows this), we need to make the
|
|
// method more accessible, because otherwise the CLR will complain that we're reducing access
|
|
MethodBase baseMethod = baseMce.GetMethod();
|
|
if((baseMethod.IsPublic && !m.IsPublic) ||
|
|
(baseMethod.IsFamily && !m.IsPublic && !m.IsProtected) ||
|
|
(!m.IsPublic && !m.IsProtected && !baseMce.DeclaringType.IsInSamePackageAs(wrapper)))
|
|
{
|
|
attribs &= ~MethodAttributes.MemberAccessMask;
|
|
attribs |= baseMethod.IsPublic ? MethodAttributes.Public : MethodAttributes.FamORAssem;
|
|
setModifiers = true;
|
|
}
|
|
}
|
|
}
|
|
MethodBuilder mb;
|
|
if(typeBuilderGhostInterface != null)
|
|
{
|
|
mb = typeBuilderGhostInterface.DefineMethod(name, attribs, methods[index].ReturnTypeForDefineMethod, methods[index].GetParametersForDefineMethod());
|
|
}
|
|
else
|
|
{
|
|
bool needFinalize = false;
|
|
bool needDispatch = false;
|
|
if(baseMce != null && md.Name == "finalize" && md.Signature == "()V")
|
|
{
|
|
if(baseMce.RealName == "Finalize")
|
|
{
|
|
//baseMethod = null;
|
|
attribs |= MethodAttributes.NewSlot;
|
|
needFinalize = true;
|
|
needDispatch = true;
|
|
}
|
|
else if(baseMce.DeclaringType == CoreClasses.java.lang.Object.Wrapper)
|
|
{
|
|
needFinalize = true;
|
|
needDispatch = true;
|
|
}
|
|
else if(m.IsFinal)
|
|
{
|
|
needFinalize = true;
|
|
needDispatch = false;
|
|
}
|
|
}
|
|
if(unloadableOverrideStub)
|
|
{
|
|
attribs |= MethodAttributes.NewSlot;
|
|
}
|
|
if(setNameSig || memberclashtable != null)
|
|
{
|
|
name = GenerateUniqueMethodName(name, methods[index]);
|
|
}
|
|
mb = typeBuilder.DefineMethod(name, attribs, methods[index].ReturnTypeForDefineMethod, methods[index].GetParametersForDefineMethod());
|
|
if(unloadableOverrideStub)
|
|
{
|
|
GenerateUnloadableOverrideStub(baseMce, mb, methods[index].ReturnTypeForDefineMethod, methods[index].GetParametersForDefineMethod());
|
|
}
|
|
else if(baseMce != null && (explicitOverride || baseMce.RealName != name))
|
|
{
|
|
// assert that the method we're overriding is in fact virtual and not final!
|
|
Debug.Assert(baseMce.GetMethod().IsVirtual && !baseMce.GetMethod().IsFinal);
|
|
typeBuilder.DefineMethodOverride(mb, (MethodInfo)baseMce.GetMethod());
|
|
}
|
|
// if we're overriding java.lang.Object.finalize we need to emit a stub to override System.Object.Finalize,
|
|
// or if we're subclassing a non-Java class that has a Finalize method, we need a new Finalize override
|
|
if(needFinalize)
|
|
{
|
|
MethodInfo baseFinalize = typeBuilder.BaseType.GetMethod("Finalize", BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance, null, Type.EmptyTypes, null);
|
|
MethodAttributes attr = MethodAttributes.Virtual;
|
|
// make sure we don't reduce accessibility
|
|
attr |= baseFinalize.IsPublic ? MethodAttributes.Public : MethodAttributes.Family;
|
|
if(m.IsFinal)
|
|
{
|
|
attr |= MethodAttributes.Final;
|
|
}
|
|
// TODO if the Java class also defines a Finalize() method, we need to name the stub differently
|
|
// (and make it effectively appear hidden by the class's Finalize method)
|
|
MethodBuilder finalize = typeBuilder.DefineMethod("Finalize", attr, CallingConventions.Standard, typeof(void), Type.EmptyTypes);
|
|
AttributeHelper.HideFromJava(finalize);
|
|
ILGenerator ilgen = finalize.GetILGenerator();
|
|
if(needDispatch)
|
|
{
|
|
ilgen.BeginExceptionBlock();
|
|
ilgen.Emit(OpCodes.Ldarg_0);
|
|
ilgen.Emit(OpCodes.Callvirt, mb);
|
|
ilgen.BeginCatchBlock(typeof(object));
|
|
ilgen.EndExceptionBlock();
|
|
}
|
|
else
|
|
{
|
|
ilgen.Emit(OpCodes.Ldarg_0);
|
|
ilgen.Emit(OpCodes.Call, baseFinalize);
|
|
}
|
|
ilgen.Emit(OpCodes.Ret);
|
|
}
|
|
}
|
|
if(JVM.IsStaticCompiler || ClassLoaderWrapper.IsSaveDebugImage)
|
|
{
|
|
AddParameterNames(mb, m);
|
|
if(setModifiers)
|
|
{
|
|
AttributeHelper.SetModifiers(mb, m.Modifiers);
|
|
}
|
|
}
|
|
method = mb;
|
|
}
|
|
string[] exceptions = m.ExceptionsAttribute;
|
|
methods[index].SetDeclaredExceptions(exceptions);
|
|
if(JVM.IsStaticCompiler || ClassLoaderWrapper.IsSaveDebugImage)
|
|
{
|
|
AttributeHelper.SetThrowsAttribute(method, exceptions);
|
|
if(m.DeprecatedAttribute)
|
|
{
|
|
AttributeHelper.SetDeprecatedAttribute(method);
|
|
}
|
|
if(setNameSig)
|
|
{
|
|
AttributeHelper.SetNameSig(method, m.Name, m.Signature);
|
|
}
|
|
}
|
|
return method;
|
|
}
|
|
finally
|
|
{
|
|
Profiler.Leave("JavaTypeImpl.GenerateMethod");
|
|
}
|
|
}
|
|
|
|
private static ParameterBuilder[] AddParameterNames(MethodBase mb, ClassFile.Method m)
|
|
{
|
|
ClassFile.Method.LocalVariableTableEntry[] localVars = m.LocalVariableTableAttribute;
|
|
if(localVars != null)
|
|
{
|
|
int bias = 1;
|
|
if(m.IsStatic)
|
|
{
|
|
bias = 0;
|
|
}
|
|
ParameterBuilder[] parameterBuilders = new ParameterBuilder[m.ArgMap.Length - bias];
|
|
for(int i = bias; i < m.ArgMap.Length; i++)
|
|
{
|
|
if(m.ArgMap[i] != -1)
|
|
{
|
|
for(int j = 0; j < localVars.Length; j++)
|
|
{
|
|
if(localVars[j].index == i && parameterBuilders[i - bias] == null)
|
|
{
|
|
if(mb is MethodBuilder)
|
|
{
|
|
parameterBuilders[i - bias] = ((MethodBuilder)mb).DefineParameter(m.ArgMap[i] + 1 - bias, ParameterAttributes.None, localVars[j].name);
|
|
}
|
|
else if(mb is ConstructorBuilder)
|
|
{
|
|
parameterBuilders[i - bias] = ((ConstructorBuilder)mb).DefineParameter(m.ArgMap[i], ParameterAttributes.None, localVars[j].name);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return parameterBuilders;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
private void GenerateUnloadableOverrideStub(MethodWrapper baseMethod, MethodInfo target, Type targetRet, Type[] targetArgs)
|
|
{
|
|
Type stubret = baseMethod.ReturnTypeForDefineMethod;
|
|
Type[] stubargs = baseMethod.GetParametersForDefineMethod();
|
|
string name = GenerateUniqueMethodName(baseMethod.RealName + "/unloadablestub", baseMethod);
|
|
MethodBuilder overrideStub = typeBuilder.DefineMethod(name, MethodAttributes.Private | MethodAttributes.Virtual | MethodAttributes.NewSlot | MethodAttributes.Final, stubret, stubargs);
|
|
AttributeHelper.HideFromJava(overrideStub);
|
|
typeBuilder.DefineMethodOverride(overrideStub, (MethodInfo)baseMethod.GetMethod());
|
|
ILGenerator ilgen = overrideStub.GetILGenerator();
|
|
ilgen.Emit(OpCodes.Ldarg_0);
|
|
for(int i = 0; i < targetArgs.Length; i++)
|
|
{
|
|
ilgen.Emit(OpCodes.Ldarg_S, (byte)(i + 1));
|
|
if(targetArgs[i] != stubargs[i])
|
|
{
|
|
ilgen.Emit(OpCodes.Castclass, targetArgs[i]);
|
|
}
|
|
}
|
|
ilgen.Emit(OpCodes.Callvirt, target);
|
|
if(targetRet != stubret)
|
|
{
|
|
ilgen.Emit(OpCodes.Castclass, stubret);
|
|
}
|
|
ilgen.Emit(OpCodes.Ret);
|
|
}
|
|
|
|
private static bool CheckRequireOverrideStub(MethodWrapper mw1, MethodWrapper mw2)
|
|
{
|
|
// TODO this is too late to generate LinkageErrors so we need to figure this out earlier
|
|
if(mw1.ReturnType != mw2.ReturnType && !(mw1.ReturnType.IsUnloadable && mw2.ReturnType.IsUnloadable))
|
|
{
|
|
return true;
|
|
}
|
|
TypeWrapper[] args1 = mw1.GetParameters();
|
|
TypeWrapper[] args2 = mw2.GetParameters();
|
|
for(int i = 0; i < args1.Length; i++)
|
|
{
|
|
if(args1[i] != args2[i] && !(args1[i].IsUnloadable && args2[i].IsUnloadable))
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
private void AddMethodOverride(MethodWrapper method, MethodBuilder mb, TypeWrapper iface, MethodDescriptor md, ref Hashtable hashtable, bool unloadableOnly)
|
|
{
|
|
if(hashtable != null && hashtable.ContainsKey(iface))
|
|
{
|
|
return;
|
|
}
|
|
MethodWrapper mw = iface.GetMethodWrapper(md, false);
|
|
if(mw != null)
|
|
{
|
|
if(hashtable == null)
|
|
{
|
|
hashtable = new Hashtable();
|
|
}
|
|
hashtable.Add(iface, iface);
|
|
if(CheckRequireOverrideStub(method, mw))
|
|
{
|
|
GenerateUnloadableOverrideStub(mw, mb, method.ReturnTypeForDefineMethod, method.GetParametersForDefineMethod());
|
|
}
|
|
else if(!unloadableOnly)
|
|
{
|
|
typeBuilder.DefineMethodOverride(mb, (MethodInfo)mw.GetMethod());
|
|
}
|
|
}
|
|
foreach(TypeWrapper iface2 in iface.Interfaces)
|
|
{
|
|
AddMethodOverride(method, mb, iface2, md, ref hashtable, unloadableOnly);
|
|
}
|
|
}
|
|
|
|
internal override Type Type
|
|
{
|
|
get
|
|
{
|
|
return typeBuilder;
|
|
}
|
|
}
|
|
|
|
internal override Type TypeAsBaseType
|
|
{
|
|
get
|
|
{
|
|
return typeBuilderGhostInterface != null ? typeBuilderGhostInterface : typeBuilder;
|
|
}
|
|
}
|
|
}
|
|
|
|
private class FinishedTypeImpl : DynamicImpl
|
|
{
|
|
private Type type;
|
|
private Type typeGhostInterface;
|
|
private TypeWrapper[] innerclasses;
|
|
private TypeWrapper declaringTypeWrapper;
|
|
private Modifiers reflectiveModifiers;
|
|
|
|
internal FinishedTypeImpl(Type type, Type typeGhostInterface, TypeWrapper[] innerclasses, TypeWrapper declaringTypeWrapper, Modifiers reflectiveModifiers)
|
|
{
|
|
this.type = type;
|
|
this.typeGhostInterface = typeGhostInterface;
|
|
this.innerclasses = innerclasses;
|
|
this.declaringTypeWrapper = declaringTypeWrapper;
|
|
this.reflectiveModifiers = reflectiveModifiers;
|
|
}
|
|
|
|
internal override TypeWrapper[] InnerClasses
|
|
{
|
|
get
|
|
{
|
|
// TODO compute the innerclasses lazily (and fix JavaTypeImpl to not always compute them)
|
|
return innerclasses;
|
|
}
|
|
}
|
|
|
|
internal override TypeWrapper DeclaringTypeWrapper
|
|
{
|
|
get
|
|
{
|
|
// TODO compute lazily (and fix JavaTypeImpl to not always compute it)
|
|
return declaringTypeWrapper;
|
|
}
|
|
}
|
|
|
|
internal override Modifiers ReflectiveModifiers
|
|
{
|
|
get
|
|
{
|
|
return reflectiveModifiers;
|
|
}
|
|
}
|
|
|
|
internal override FieldWrapper GetFieldImpl(string fieldName, string fieldSig)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
internal override Type Type
|
|
{
|
|
get
|
|
{
|
|
return type;
|
|
}
|
|
}
|
|
|
|
internal override Type TypeAsBaseType
|
|
{
|
|
get
|
|
{
|
|
return typeGhostInterface != null ? typeGhostInterface : type;
|
|
}
|
|
}
|
|
|
|
internal override DynamicImpl Finish(bool forDebugSave)
|
|
{
|
|
return this;
|
|
}
|
|
|
|
internal override MethodBase LinkMethod(MethodWrapper mw)
|
|
{
|
|
// we should never be called, because all methods on a finished type are already linked
|
|
Debug.Assert(false);
|
|
return mw.GetMethod();
|
|
}
|
|
|
|
internal override void LinkField(FieldWrapper fw)
|
|
{
|
|
// we should never be called, because all fields on a finished type are already linked
|
|
Debug.Assert(false);
|
|
}
|
|
}
|
|
|
|
internal override void EmitCheckcast(TypeWrapper context, ILGenerator ilgen)
|
|
{
|
|
if(IsGhost)
|
|
{
|
|
ilgen.Emit(OpCodes.Dup);
|
|
ilgen.Emit(OpCodes.Call, ghostCastMethod);
|
|
ilgen.Emit(OpCodes.Pop);
|
|
}
|
|
else if(IsGhostArray)
|
|
{
|
|
ilgen.Emit(OpCodes.Dup);
|
|
ilgen.Emit(OpCodes.Call, ghostCastArrayMethod);
|
|
}
|
|
else
|
|
{
|
|
base.EmitCheckcast(context, ilgen);
|
|
}
|
|
}
|
|
|
|
internal override void EmitInstanceOf(TypeWrapper context, ILGenerator ilgen)
|
|
{
|
|
if(IsGhost)
|
|
{
|
|
ilgen.Emit(OpCodes.Call, ghostIsInstanceMethod);
|
|
}
|
|
else if(IsGhostArray)
|
|
{
|
|
ilgen.Emit(OpCodes.Call, ghostIsInstanceArrayMethod);
|
|
}
|
|
else
|
|
{
|
|
base.EmitInstanceOf(context, ilgen);
|
|
}
|
|
}
|
|
|
|
internal override MethodBase LinkMethod(MethodWrapper mw)
|
|
{
|
|
mw.AssertLinked();
|
|
return impl.LinkMethod(mw);
|
|
}
|
|
|
|
internal override void LinkField(FieldWrapper fw)
|
|
{
|
|
fw.AssertLinked();
|
|
impl.LinkField(fw);
|
|
}
|
|
}
|
|
|
|
// TODO this is the base class of CompiledTypeWrapper (ikmvc compiled Java types)
|
|
// and DotNetTypeWrapper (.NET types), it should have a better name.
|
|
abstract class LazyTypeWrapper : TypeWrapper
|
|
{
|
|
private bool membersPublished;
|
|
|
|
protected LazyTypeWrapper(Modifiers modifiers, string name, TypeWrapper baseTypeWrapper, ClassLoaderWrapper classLoader)
|
|
: base(modifiers, name, baseTypeWrapper, classLoader)
|
|
{
|
|
}
|
|
|
|
protected abstract void LazyPublishMembers();
|
|
|
|
private void Publish()
|
|
{
|
|
LazyPublishMembers();
|
|
foreach(MethodWrapper mw in GetMethods())
|
|
{
|
|
mw.Link();
|
|
}
|
|
foreach(FieldWrapper fw in GetFields())
|
|
{
|
|
fw.Link();
|
|
}
|
|
}
|
|
|
|
internal override MethodWrapper[] GetMethods()
|
|
{
|
|
lock(this)
|
|
{
|
|
if(!membersPublished)
|
|
{
|
|
membersPublished = true;
|
|
Publish();
|
|
}
|
|
}
|
|
return base.GetMethods();
|
|
}
|
|
|
|
internal override MethodWrapper GetMethodWrapper(MethodDescriptor md, bool inherit)
|
|
{
|
|
lock(this)
|
|
{
|
|
if(!membersPublished)
|
|
{
|
|
membersPublished = true;
|
|
Publish();
|
|
}
|
|
}
|
|
return base.GetMethodWrapper(md, inherit);
|
|
}
|
|
|
|
internal override FieldWrapper[] GetFields()
|
|
{
|
|
lock(this)
|
|
{
|
|
if(!membersPublished)
|
|
{
|
|
membersPublished = true;
|
|
Publish();
|
|
}
|
|
}
|
|
return base.GetFields ();
|
|
}
|
|
|
|
internal override FieldWrapper GetFieldWrapper(string fieldName, string fieldSig)
|
|
{
|
|
lock(this)
|
|
{
|
|
if(!membersPublished)
|
|
{
|
|
membersPublished = true;
|
|
Publish();
|
|
}
|
|
}
|
|
return base.GetFieldWrapper (fieldName, fieldSig);
|
|
}
|
|
|
|
protected sealed override FieldWrapper GetFieldImpl(string fieldName, string fieldSig)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
internal sealed override void Finish(bool forDebugSave)
|
|
{
|
|
// NOTE the whole notion of "finishing" doesn't apply to .NET and statically compiled types,
|
|
// because instances of these types can be created without needing to involve the IKVM runtime
|
|
}
|
|
}
|
|
|
|
sealed class CompiledTypeWrapper : LazyTypeWrapper
|
|
{
|
|
private readonly Type type;
|
|
private TypeWrapper[] interfaces;
|
|
private TypeWrapper[] innerclasses;
|
|
private FieldInfo ghostRefField;
|
|
private Type typeAsBaseType;
|
|
private Type remappedType;
|
|
|
|
internal static string GetName(Type type)
|
|
{
|
|
Debug.Assert(type.Module.IsDefined(typeof(JavaModuleAttribute), false));
|
|
|
|
// look for our custom attribute, that contains the real name of the type (for inner classes)
|
|
Object[] attribs = type.GetCustomAttributes(typeof(InnerClassAttribute), false);
|
|
if(attribs.Length == 1)
|
|
{
|
|
return ((InnerClassAttribute)attribs[0]).InnerClassName;
|
|
}
|
|
return type.FullName;
|
|
}
|
|
|
|
// TODO consider resolving the baseType lazily
|
|
private static TypeWrapper GetBaseTypeWrapper(Type type)
|
|
{
|
|
if(type.IsInterface || type.IsDefined(typeof(GhostInterfaceAttribute), false))
|
|
{
|
|
return null;
|
|
}
|
|
else if(type.BaseType == null)
|
|
{
|
|
// System.Object must appear to be derived from java.lang.Object
|
|
return CoreClasses.java.lang.Object.Wrapper;
|
|
}
|
|
else
|
|
{
|
|
object[] attribs = type.GetCustomAttributes(typeof(RemappedTypeAttribute), false);
|
|
if(attribs.Length == 1)
|
|
{
|
|
if(((RemappedTypeAttribute)attribs[0]).Type == typeof(object))
|
|
{
|
|
return null;
|
|
}
|
|
else
|
|
{
|
|
return CoreClasses.java.lang.Object.Wrapper;
|
|
}
|
|
}
|
|
return ClassLoaderWrapper.GetWrapperFromType(type.BaseType);
|
|
}
|
|
}
|
|
|
|
private static ClassLoaderWrapper GetClassLoader(Type type)
|
|
{
|
|
return ClassLoaderWrapper.IsCoreAssemblyType(type) ? ClassLoaderWrapper.GetBootstrapClassLoader() : ClassLoaderWrapper.GetSystemClassLoader();
|
|
}
|
|
|
|
internal CompiledTypeWrapper(string name, Type type)
|
|
: base(GetModifiers(type), name, GetBaseTypeWrapper(type), GetClassLoader(type))
|
|
{
|
|
Debug.Assert(!(type is TypeBuilder));
|
|
Debug.Assert(!type.IsArray);
|
|
|
|
object[] attribs = type.GetCustomAttributes(typeof(RemappedTypeAttribute), false);
|
|
if(attribs.Length == 1)
|
|
{
|
|
this.typeAsBaseType = type;
|
|
this.remappedType = ((RemappedTypeAttribute)attribs[0]).Type;
|
|
}
|
|
|
|
this.type = type;
|
|
}
|
|
|
|
private static Modifiers GetModifiers(Type type)
|
|
{
|
|
object[] customAttribute = type.GetCustomAttributes(typeof(ModifiersAttribute), false);
|
|
if(customAttribute.Length == 1)
|
|
{
|
|
return ((ModifiersAttribute)customAttribute[0]).Modifiers;
|
|
}
|
|
// only returns public, protected, private, final, static, abstract and interface (as per
|
|
// the documentation of Class.getModifiers())
|
|
Modifiers modifiers = 0;
|
|
if(type.IsPublic)
|
|
{
|
|
modifiers |= Modifiers.Public;
|
|
}
|
|
// TODO do we really need to look for nested attributes? I think all inner classes will have the ModifiersAttribute.
|
|
else if(type.IsNestedPublic)
|
|
{
|
|
modifiers |= Modifiers.Public | Modifiers.Static;
|
|
}
|
|
else if(type.IsNestedPrivate)
|
|
{
|
|
modifiers |= Modifiers.Private | Modifiers.Static;
|
|
}
|
|
else if(type.IsNestedFamily || type.IsNestedFamORAssem)
|
|
{
|
|
modifiers |= Modifiers.Protected | Modifiers.Static;
|
|
}
|
|
else if(type.IsNestedAssembly || type.IsNestedFamANDAssem)
|
|
{
|
|
modifiers |= Modifiers.Static;
|
|
}
|
|
|
|
if(type.IsSealed)
|
|
{
|
|
modifiers |= Modifiers.Final;
|
|
}
|
|
if(type.IsAbstract)
|
|
{
|
|
modifiers |= Modifiers.Abstract;
|
|
}
|
|
if(type.IsInterface)
|
|
{
|
|
modifiers |= Modifiers.Interface;
|
|
}
|
|
return modifiers;
|
|
}
|
|
|
|
internal override bool HasStaticInitializer
|
|
{
|
|
get
|
|
{
|
|
return type.GetField("__<clinit>", BindingFlags.NonPublic | BindingFlags.Static) != null;
|
|
}
|
|
}
|
|
|
|
internal override Assembly Assembly
|
|
{
|
|
get
|
|
{
|
|
return type.Assembly;
|
|
}
|
|
}
|
|
|
|
internal override TypeWrapper[] Interfaces
|
|
{
|
|
get
|
|
{
|
|
if(interfaces == null)
|
|
{
|
|
// NOTE instead of getting the interfaces list from Type, we use a custom
|
|
// attribute to list the implemented interfaces, because Java reflection only
|
|
// reports the interfaces *directly* implemented by the type, not the inherited
|
|
// interfaces. This is significant for serialVersionUID calculation (for example).
|
|
object[] attribs = type.GetCustomAttributes(typeof(ImplementsAttribute), false);
|
|
if(attribs.Length == 1)
|
|
{
|
|
string[] interfaceNames = ((ImplementsAttribute)attribs[0]).Interfaces;
|
|
TypeWrapper[] interfaceWrappers = new TypeWrapper[interfaceNames.Length];
|
|
for(int i = 0; i < interfaceWrappers.Length; i++)
|
|
{
|
|
interfaceWrappers[i] = GetClassLoader().LoadClassByDottedName(interfaceNames[i]);
|
|
}
|
|
this.interfaces = interfaceWrappers;
|
|
}
|
|
else
|
|
{
|
|
interfaces = TypeWrapper.EmptyArray;
|
|
}
|
|
}
|
|
return interfaces;
|
|
}
|
|
}
|
|
|
|
internal override TypeWrapper[] InnerClasses
|
|
{
|
|
get
|
|
{
|
|
if(innerclasses == null)
|
|
{
|
|
Type[] nestedTypes = type.GetNestedTypes(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.DeclaredOnly);
|
|
ArrayList wrappers = new ArrayList();
|
|
for(int i = 0; i < nestedTypes.Length; i++)
|
|
{
|
|
if(!AttributeHelper.IsHideFromJava(nestedTypes[i]))
|
|
{
|
|
wrappers.Add(ClassLoaderWrapper.GetWrapperFromType(nestedTypes[i]));
|
|
}
|
|
}
|
|
innerclasses = (TypeWrapper[])wrappers.ToArray(typeof(TypeWrapper));
|
|
}
|
|
return innerclasses;
|
|
}
|
|
}
|
|
|
|
internal override TypeWrapper DeclaringTypeWrapper
|
|
{
|
|
get
|
|
{
|
|
Type declaringType = type.DeclaringType;
|
|
if(declaringType != null)
|
|
{
|
|
return ClassLoaderWrapper.GetWrapperFromType(declaringType);
|
|
}
|
|
return null;
|
|
}
|
|
}
|
|
|
|
internal override Modifiers ReflectiveModifiers
|
|
{
|
|
get
|
|
{
|
|
object[] customAttribute = type.GetCustomAttributes(typeof(InnerClassAttribute), false);
|
|
if(customAttribute.Length == 1)
|
|
{
|
|
return ((InnerClassAttribute)customAttribute[0]).Modifiers;
|
|
}
|
|
return Modifiers;
|
|
}
|
|
}
|
|
|
|
internal override Type TypeAsBaseType
|
|
{
|
|
get
|
|
{
|
|
if(typeAsBaseType == null)
|
|
{
|
|
if(IsGhost)
|
|
{
|
|
typeAsBaseType = type.GetNestedType("__Interface");
|
|
}
|
|
else
|
|
{
|
|
typeAsBaseType = type;
|
|
}
|
|
}
|
|
return typeAsBaseType;
|
|
}
|
|
}
|
|
|
|
internal override FieldInfo GhostRefField
|
|
{
|
|
get
|
|
{
|
|
if(ghostRefField == null)
|
|
{
|
|
ghostRefField = type.GetField("__<ref>");
|
|
}
|
|
return ghostRefField;
|
|
}
|
|
}
|
|
|
|
private void SigTypePatchUp(string sigtype, ref TypeWrapper type)
|
|
{
|
|
if(sigtype != type.SigName)
|
|
{
|
|
// if type is an array, we know that it is a ghost array, because arrays of unloadable are compiled
|
|
// as object (not as arrays of object)
|
|
if(type.IsArray)
|
|
{
|
|
type = GetClassLoader().FieldTypeWrapperFromSig(sigtype);
|
|
}
|
|
else
|
|
{
|
|
if(sigtype[0] == 'L')
|
|
{
|
|
sigtype = sigtype.Substring(1, sigtype.Length - 2);
|
|
}
|
|
type = new UnloadableTypeWrapper(sigtype);
|
|
}
|
|
}
|
|
}
|
|
|
|
private static void ParseSig(string sig, out string[] sigparam, out string sigret)
|
|
{
|
|
ArrayList list = new ArrayList();
|
|
int pos = 1;
|
|
for(;;)
|
|
{
|
|
switch(sig[pos])
|
|
{
|
|
case 'L':
|
|
{
|
|
int end = sig.IndexOf(';', pos) + 1;
|
|
list.Add(sig.Substring(pos, end - pos));
|
|
pos = end;
|
|
break;
|
|
}
|
|
case '[':
|
|
{
|
|
int skip = 1;
|
|
while(sig[pos + skip] == '[') skip++;
|
|
if(sig[pos + skip] == 'L')
|
|
{
|
|
int end = sig.IndexOf(';', pos) + 1;
|
|
list.Add(sig.Substring(pos, end - pos));
|
|
pos = end;
|
|
}
|
|
else
|
|
{
|
|
skip++;
|
|
list.Add(sig.Substring(pos, skip));
|
|
pos += skip;
|
|
}
|
|
break;
|
|
}
|
|
case ')':
|
|
sigparam = (string[])list.ToArray(typeof(string));
|
|
sigret = sig.Substring(pos + 1);
|
|
return;
|
|
default:
|
|
list.Add(sig.Substring(pos, 1));
|
|
pos++;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
private void GetNameSigFromMethodBase(MethodBase method, out string name, out string sig, out TypeWrapper retType, out TypeWrapper[] paramTypes)
|
|
{
|
|
retType = method is ConstructorInfo ? PrimitiveTypeWrapper.VOID : ClassLoaderWrapper.GetWrapperFromType(((MethodInfo)method).ReturnType);
|
|
ParameterInfo[] parameters = method.GetParameters();
|
|
paramTypes = new TypeWrapper[parameters.Length];
|
|
for(int i = 0; i < parameters.Length; i++)
|
|
{
|
|
paramTypes[i] = ClassLoaderWrapper.GetWrapperFromType(parameters[i].ParameterType);
|
|
}
|
|
if(method.IsDefined(typeof(NameSigAttribute), false))
|
|
{
|
|
NameSigAttribute attr = (NameSigAttribute)method.GetCustomAttributes(typeof(NameSigAttribute), false)[0];
|
|
name = attr.Name;
|
|
sig = attr.Sig;
|
|
string[] sigparams;
|
|
string sigret;
|
|
ParseSig(sig, out sigparams, out sigret);
|
|
// HACK newhelper methods have a return type, but it should be void
|
|
if(name == "<init>")
|
|
{
|
|
retType = PrimitiveTypeWrapper.VOID;
|
|
}
|
|
SigTypePatchUp(sigret, ref retType);
|
|
// if we have a remapped method, the paramTypes array contains an additional entry for "this" so we have
|
|
// to remove that
|
|
if(paramTypes.Length == sigparams.Length + 1)
|
|
{
|
|
TypeWrapper[] temp = paramTypes;
|
|
paramTypes = new TypeWrapper[sigparams.Length];
|
|
Array.Copy(temp, 1, paramTypes, 0, paramTypes.Length);
|
|
}
|
|
Debug.Assert(sigparams.Length == paramTypes.Length);
|
|
for(int i = 0; i < sigparams.Length; i++)
|
|
{
|
|
SigTypePatchUp(sigparams[i], ref paramTypes[i]);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if(method is ConstructorInfo)
|
|
{
|
|
name = method.IsStatic ? "<clinit>" : "<init>";
|
|
}
|
|
else
|
|
{
|
|
name = method.Name;
|
|
}
|
|
System.Text.StringBuilder sb = new System.Text.StringBuilder("(");
|
|
foreach(TypeWrapper tw in paramTypes)
|
|
{
|
|
sb.Append(tw.SigName);
|
|
}
|
|
sb.Append(")");
|
|
sb.Append(retType.SigName);
|
|
sig = sb.ToString();
|
|
}
|
|
}
|
|
|
|
protected override void LazyPublishMembers()
|
|
{
|
|
MemberInfo[] members = type.GetMembers(BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.Instance);
|
|
if(remappedType == null)
|
|
{
|
|
foreach(MemberInfo m in members)
|
|
{
|
|
if(!AttributeHelper.IsHideFromJava(m))
|
|
{
|
|
MethodBase method = m as MethodBase;
|
|
if(method != null)
|
|
{
|
|
string name;
|
|
string sig;
|
|
TypeWrapper retType;
|
|
TypeWrapper[] paramTypes;
|
|
GetNameSigFromMethodBase(method, out name, out sig, out retType, out paramTypes);
|
|
MethodInfo mi = method as MethodInfo;
|
|
bool miranda = mi != null ? AttributeHelper.IsMirandaMethod(mi) : false;
|
|
AddMethod(MethodWrapper.Create(this, new MethodDescriptor(name, sig), method, retType, paramTypes, AttributeHelper.GetModifiers(method, false), miranda));
|
|
}
|
|
else
|
|
{
|
|
FieldInfo field = m as FieldInfo;
|
|
if(field != null)
|
|
{
|
|
AddField(CreateFieldWrapper(field));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
foreach(MemberInfo m in members)
|
|
{
|
|
if(!AttributeHelper.IsHideFromJava(m))
|
|
{
|
|
MethodBase method = m as MethodBase;
|
|
if(method != null &&
|
|
(remappedType.IsSealed || !m.Name.StartsWith("instancehelper_")) &&
|
|
(!remappedType.IsSealed || method.IsStatic))
|
|
{
|
|
AddMethod(CreateRemappedMethodWrapper(method));
|
|
}
|
|
else
|
|
{
|
|
FieldInfo field = m as FieldInfo;
|
|
if(field != null)
|
|
{
|
|
AddField(CreateFieldWrapper(field));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
// if we're a remapped interface, we need to get the methods from the real interface
|
|
if(remappedType.IsInterface)
|
|
{
|
|
Type nestedHelper = type.GetNestedType("__Helper", BindingFlags.Public | BindingFlags.Static);
|
|
foreach(RemappedInterfaceMethodAttribute m in type.GetCustomAttributes(typeof(RemappedInterfaceMethodAttribute), false))
|
|
{
|
|
MethodInfo method = remappedType.GetMethod(m.MappedTo);
|
|
MethodInfo mbHelper = method;
|
|
Modifiers modifiers = AttributeHelper.GetModifiers(method, false);
|
|
string name;
|
|
string sig;
|
|
TypeWrapper retType;
|
|
TypeWrapper[] paramTypes;
|
|
GetNameSigFromMethodBase(method, out name, out sig, out retType, out paramTypes);
|
|
if(nestedHelper != null)
|
|
{
|
|
mbHelper = nestedHelper.GetMethod(m.Name);
|
|
if(mbHelper == null)
|
|
{
|
|
mbHelper = method;
|
|
}
|
|
}
|
|
AddMethod(new CompiledRemappedMethodWrapper(this, new MethodDescriptor(m.Name, sig), method, retType, paramTypes, modifiers, false, mbHelper, null));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private class CompiledRemappedMethodWrapper : SmartMethodWrapper
|
|
{
|
|
private MethodInfo mbHelper;
|
|
private MethodInfo mbNonvirtualHelper;
|
|
|
|
internal CompiledRemappedMethodWrapper(TypeWrapper declaringType, MethodDescriptor md, MethodBase method, TypeWrapper returnType, TypeWrapper[] parameterTypes, Modifiers modifiers, bool hideFromReflection, MethodInfo mbHelper, MethodInfo mbNonvirtualHelper)
|
|
: base(declaringType, md, method, returnType, parameterTypes, modifiers, hideFromReflection ? MemberFlags.HideFromReflection : MemberFlags.None)
|
|
{
|
|
this.mbHelper = mbHelper;
|
|
this.mbNonvirtualHelper = mbNonvirtualHelper;
|
|
}
|
|
|
|
protected override void CallImpl(ILGenerator ilgen)
|
|
{
|
|
MethodBase mb = GetMethod();
|
|
MethodInfo mi = mb as MethodInfo;
|
|
if(mi != null)
|
|
{
|
|
ilgen.Emit(OpCodes.Call, mi);
|
|
}
|
|
else
|
|
{
|
|
ilgen.Emit(OpCodes.Call, (ConstructorInfo)mb);
|
|
}
|
|
}
|
|
|
|
protected override void CallvirtImpl(ILGenerator ilgen)
|
|
{
|
|
Debug.Assert(!mbHelper.IsStatic || mbHelper.Name.StartsWith("instancehelper_") || mbHelper.DeclaringType.Name == "__Helper");
|
|
ilgen.Emit(mbHelper.IsStatic ? OpCodes.Call : OpCodes.Callvirt, mbHelper);
|
|
}
|
|
|
|
protected override void NewobjImpl(ILGenerator ilgen)
|
|
{
|
|
MethodBase mb = GetMethod();
|
|
MethodInfo mi = mb as MethodInfo;
|
|
if(mi != null)
|
|
{
|
|
Debug.Assert(mi.Name == "newhelper");
|
|
ilgen.Emit(OpCodes.Call, mi);
|
|
}
|
|
else
|
|
{
|
|
ilgen.Emit(OpCodes.Newobj, (ConstructorInfo)mb);
|
|
}
|
|
}
|
|
|
|
internal override object Invoke(object obj, object[] args, bool nonVirtual)
|
|
{
|
|
MethodBase mb;
|
|
if(nonVirtual)
|
|
{
|
|
if(DeclaringType.TypeAsBaseType.IsInstanceOfType(obj))
|
|
{
|
|
mb = GetMethod();
|
|
}
|
|
else if(mbNonvirtualHelper != null)
|
|
{
|
|
mb = mbNonvirtualHelper;
|
|
}
|
|
else if(mbHelper != null)
|
|
{
|
|
mb = mbHelper;
|
|
}
|
|
else
|
|
{
|
|
// we can end up here if someone calls a constructor with nonVirtual set (which is pointless, but legal)
|
|
mb = GetMethod();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
mb = mbHelper != null ? mbHelper : GetMethod();
|
|
}
|
|
return InvokeImpl(mb, obj, args, nonVirtual);
|
|
}
|
|
}
|
|
|
|
private MethodWrapper CreateRemappedMethodWrapper(MethodBase mb)
|
|
{
|
|
Modifiers modifiers = AttributeHelper.GetModifiers(mb, false);
|
|
string name;
|
|
string sig;
|
|
TypeWrapper retType;
|
|
TypeWrapper[] paramTypes;
|
|
GetNameSigFromMethodBase(mb, out name, out sig, out retType, out paramTypes);
|
|
MethodInfo mbHelper = mb as MethodInfo;
|
|
MethodInfo mbNonvirtualHelper = null;
|
|
if(!mb.IsStatic && !mb.IsConstructor)
|
|
{
|
|
ParameterInfo[] parameters = mb.GetParameters();
|
|
Type[] argTypes = new Type[parameters.Length + 1];
|
|
argTypes[0] = remappedType;
|
|
for(int i = 0; i < parameters.Length; i++)
|
|
{
|
|
argTypes[i + 1] = parameters[i].ParameterType;
|
|
}
|
|
MethodInfo helper = type.GetMethod("instancehelper_" + mb.Name, BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static, null, argTypes, null);
|
|
if(helper != null)
|
|
{
|
|
mbHelper = helper;
|
|
}
|
|
mbNonvirtualHelper = type.GetMethod("nonvirtualhelper/" + mb.Name, BindingFlags.NonPublic | BindingFlags.Static, null, argTypes, null);
|
|
}
|
|
return new CompiledRemappedMethodWrapper(this, new MethodDescriptor(name, sig), mb, retType, paramTypes, modifiers, false, mbHelper, mbNonvirtualHelper);
|
|
}
|
|
|
|
private FieldWrapper CreateFieldWrapper(FieldInfo field)
|
|
{
|
|
Modifiers modifiers = AttributeHelper.GetModifiers(field, false);
|
|
string name = field.Name;
|
|
TypeWrapper type = ClassLoaderWrapper.GetWrapperFromType(field.FieldType);
|
|
if(field.IsDefined(typeof(NameSigAttribute), false))
|
|
{
|
|
NameSigAttribute attr = (NameSigAttribute)field.GetCustomAttributes(typeof(NameSigAttribute), false)[0];
|
|
name = attr.Name;
|
|
SigTypePatchUp(attr.Sig, ref type);
|
|
}
|
|
|
|
// If the backing field is private, but the modifiers aren't, we've got a final field that
|
|
// has a property accessor method.
|
|
if(field.IsPrivate && ((modifiers & Modifiers.Private) == 0))
|
|
{
|
|
BindingFlags bindingFlags = BindingFlags.DeclaredOnly | BindingFlags.NonPublic | BindingFlags.Public;
|
|
bindingFlags |= field.IsStatic ? BindingFlags.Static : BindingFlags.Instance;
|
|
PropertyInfo prop = field.DeclaringType.GetProperty(field.Name, bindingFlags, null, field.FieldType, Type.EmptyTypes, null);
|
|
MethodInfo getter = prop.GetGetMethod(true);
|
|
return new GetterFieldWrapper(this, type, field, name, type.SigName, modifiers, getter);
|
|
}
|
|
else if(field.IsLiteral)
|
|
{
|
|
return new ConstantFieldWrapper(this, type, name, type.SigName, modifiers, field, null);
|
|
}
|
|
else
|
|
{
|
|
return FieldWrapper.Create(this, type, field, name, type.SigName, modifiers);
|
|
}
|
|
}
|
|
|
|
internal override bool IsGhost
|
|
{
|
|
get
|
|
{
|
|
return type.IsDefined(typeof(GhostInterfaceAttribute), false);
|
|
}
|
|
}
|
|
|
|
internal override bool IsRemapped
|
|
{
|
|
get
|
|
{
|
|
return remappedType != null;
|
|
}
|
|
}
|
|
|
|
internal override Type TypeAsTBD
|
|
{
|
|
get
|
|
{
|
|
return remappedType != null ? remappedType : type;
|
|
}
|
|
}
|
|
|
|
internal override bool IsMapUnsafeException
|
|
{
|
|
get
|
|
{
|
|
return type.IsDefined(typeof(ExceptionIsUnsafeForMappingAttribute), false);
|
|
}
|
|
}
|
|
}
|
|
|
|
sealed class Whidbey
|
|
{
|
|
private static readonly object[] noargs = new object[0];
|
|
private static readonly MethodInfo get_IsGenericTypeDefinition = typeof(Type).GetMethod("get_IsGenericTypeDefinition");
|
|
private static readonly MethodInfo get_IsGenericMethodDefinition = typeof(MethodBase).GetMethod("get_IsGenericMethodDefinition");
|
|
|
|
internal static bool IsGenericTypeDefinition(Type type)
|
|
{
|
|
return get_IsGenericTypeDefinition != null && (bool)get_IsGenericTypeDefinition.Invoke(type, noargs);
|
|
}
|
|
|
|
internal static bool IsGenericMethodDefinition(MethodBase mb)
|
|
{
|
|
return get_IsGenericMethodDefinition != null && (bool)get_IsGenericMethodDefinition.Invoke(mb, noargs);
|
|
}
|
|
}
|
|
|
|
sealed class DotNetTypeWrapper : LazyTypeWrapper
|
|
{
|
|
private const string NamePrefix = "cli.";
|
|
private const string DelegateInterfaceSuffix = "$Method";
|
|
private readonly Type type;
|
|
private TypeWrapper[] innerClasses;
|
|
private TypeWrapper outerClass;
|
|
private TypeWrapper[] interfaces;
|
|
|
|
private static Modifiers GetModifiers(Type type)
|
|
{
|
|
Modifiers modifiers = 0;
|
|
if(type.IsPublic)
|
|
{
|
|
modifiers |= Modifiers.Public;
|
|
}
|
|
else if(type.IsNestedPublic)
|
|
{
|
|
modifiers |= Modifiers.Static;
|
|
if(IsVisible(type))
|
|
{
|
|
modifiers |= Modifiers.Public;
|
|
}
|
|
}
|
|
else if(type.IsNestedPrivate)
|
|
{
|
|
modifiers |= Modifiers.Private | Modifiers.Static;
|
|
}
|
|
else if(type.IsNestedFamily || type.IsNestedFamORAssem)
|
|
{
|
|
modifiers |= Modifiers.Protected | Modifiers.Static;
|
|
}
|
|
else if(type.IsNestedAssembly || type.IsNestedFamANDAssem)
|
|
{
|
|
modifiers |= Modifiers.Static;
|
|
}
|
|
|
|
if(type.IsSealed)
|
|
{
|
|
modifiers |= Modifiers.Final;
|
|
}
|
|
if(type.IsAbstract)
|
|
{
|
|
modifiers |= Modifiers.Abstract;
|
|
}
|
|
if(type.IsInterface)
|
|
{
|
|
modifiers |= Modifiers.Interface;
|
|
}
|
|
return modifiers;
|
|
}
|
|
|
|
// NOTE when this is called on a remapped type, the "warped" underlying type name is returned.
|
|
// E.g. GetName(typeof(object)) returns "cli.System.Object".
|
|
internal static string GetName(Type type)
|
|
{
|
|
Debug.Assert(!type.IsArray && !type.Module.IsDefined(typeof(JavaModuleAttribute), false));
|
|
|
|
if(type.IsDefined(typeof(NoPackagePrefixAttribute), false) || type.Assembly.IsDefined(typeof(NoPackagePrefixAttribute), false))
|
|
{
|
|
// TODO figure out if this is even required
|
|
return type.FullName.Replace('+', '$');
|
|
}
|
|
|
|
return MangleTypeName(type.FullName);
|
|
}
|
|
|
|
private static string MangleTypeName(string name)
|
|
{
|
|
// TODO a fully reversible name mangling should be used (all characters not supported by Java should be escaped)
|
|
return NamePrefix + name.Replace('+', '$');
|
|
}
|
|
|
|
private static string DemangleTypeName(string name)
|
|
{
|
|
Debug.Assert(name.StartsWith(NamePrefix));
|
|
// TODO a fully reversible name mangling should be used (all characters not supported by Java should be escaped)
|
|
name = name.Substring(NamePrefix.Length);
|
|
if(name.EndsWith(DelegateInterfaceSuffix))
|
|
{
|
|
// HACK if we're a delegate nested type, don't replace the $ sign
|
|
return name;
|
|
}
|
|
return name.Replace('$', '+');
|
|
}
|
|
|
|
// this method returns a new TypeWrapper instance for each invocation (doesn't prevent duplicates)
|
|
// the caller is responsible for making sure that only one TypeWrapper with the specified name escapes
|
|
// out into the world
|
|
internal static TypeWrapper CreateDotNetTypeWrapper(string name)
|
|
{
|
|
bool prefixed = name.StartsWith(NamePrefix);
|
|
if(prefixed)
|
|
{
|
|
name = DemangleTypeName(name);
|
|
}
|
|
Type type = LoadTypeFromLoadedAssemblies(name);
|
|
if(type != null)
|
|
{
|
|
if(Whidbey.IsGenericTypeDefinition(type))
|
|
{
|
|
return null;
|
|
}
|
|
if(prefixed || type.IsDefined(typeof(NoPackagePrefixAttribute), false) || type.Assembly.IsDefined(typeof(NoPackagePrefixAttribute), false))
|
|
{
|
|
return new DotNetTypeWrapper(type);
|
|
}
|
|
}
|
|
if(name.EndsWith(DelegateInterfaceSuffix))
|
|
{
|
|
Type delegateType = LoadTypeFromLoadedAssemblies(name.Substring(0, name.Length - DelegateInterfaceSuffix.Length));
|
|
if(delegateType != null && delegateType.IsSubclassOf(typeof(Delegate)))
|
|
{
|
|
ModuleBuilder moduleBuilder = ClassLoaderWrapper.GetBootstrapClassLoader().ModuleBuilder;
|
|
TypeBuilder typeBuilder = moduleBuilder.DefineType(NamePrefix + name, TypeAttributes.Public | TypeAttributes.Interface | TypeAttributes.Abstract);
|
|
AttributeHelper.SetInnerClass(typeBuilder, NamePrefix + name, NamePrefix + delegateType.FullName, "Method", Modifiers.Public | Modifiers.Interface | Modifiers.Static | Modifiers.Abstract);
|
|
MethodInfo invoke = delegateType.GetMethod("Invoke");
|
|
if(invoke != null)
|
|
{
|
|
ParameterInfo[] parameters = invoke.GetParameters();
|
|
Type[] args = new Type[parameters.Length];
|
|
for(int i = 0; i < args.Length; i++)
|
|
{
|
|
// HACK if the delegate has pointer args, we cannot handle them, but it is already
|
|
// too late to refuse to load the class, so we replace pointers with IntPtr.
|
|
// This is not a solution, because if the delegate would be instantiated the generated
|
|
// code would be invalid.
|
|
if(parameters[i].ParameterType.IsPointer)
|
|
{
|
|
args[i] = typeof(IntPtr);
|
|
}
|
|
else
|
|
{
|
|
args[i] = parameters[i].ParameterType;
|
|
}
|
|
}
|
|
typeBuilder.DefineMethod("Invoke", MethodAttributes.Public | MethodAttributes.Abstract | MethodAttributes.Virtual, CallingConventions.Standard, invoke.ReturnType, args);
|
|
return new CompiledTypeWrapper(NamePrefix + name, typeBuilder.CreateType());
|
|
}
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
private static Type LoadTypeFromLoadedAssemblies(string name)
|
|
{
|
|
foreach(Assembly a in AppDomain.CurrentDomain.GetAssemblies())
|
|
{
|
|
// HACK we also look inside Java assemblies, because precompiled delegate interfaces might have ended up there
|
|
if(!(a is AssemblyBuilder))
|
|
{
|
|
Type t = a.GetType(name);
|
|
if(t != null)
|
|
{
|
|
return t;
|
|
}
|
|
// HACK we might be looking for an inner classes
|
|
// (if we remove the mangling of NoPackagePrefix types from GetName, we don't need this anymore)
|
|
t = a.GetType(name.Replace('$', '+'));
|
|
if(t != null)
|
|
{
|
|
return t;
|
|
}
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
internal static TypeWrapper GetWrapperFromDotNetType(Type type)
|
|
{
|
|
// TODO there should be a better way
|
|
return ClassLoaderWrapper.GetBootstrapClassLoader().LoadClassByDottedName(DotNetTypeWrapper.GetName(type));
|
|
}
|
|
|
|
private static TypeWrapper GetBaseTypeWrapper(Type type)
|
|
{
|
|
if(type.IsInterface)
|
|
{
|
|
return null;
|
|
}
|
|
else if(ClassLoaderWrapper.IsRemappedType(type))
|
|
{
|
|
// Remapped types extend their alter ego
|
|
// (e.g. cli.System.Object must appear to be derived from java.lang.Object)
|
|
// except when they're sealed, of course.
|
|
if(type.IsSealed)
|
|
{
|
|
return CoreClasses.java.lang.Object.Wrapper;
|
|
}
|
|
return ClassLoaderWrapper.GetWrapperFromType(type);
|
|
}
|
|
else if(ClassLoaderWrapper.IsRemappedType(type.BaseType))
|
|
{
|
|
return GetWrapperFromDotNetType(type.BaseType);
|
|
}
|
|
else
|
|
{
|
|
return ClassLoaderWrapper.GetWrapperFromType(type.BaseType);
|
|
}
|
|
}
|
|
|
|
internal DotNetTypeWrapper(Type type)
|
|
: base(GetModifiers(type), GetName(type), GetBaseTypeWrapper(type), null)
|
|
{
|
|
Debug.Assert(!(type.IsByRef), type.FullName);
|
|
Debug.Assert(!(type.IsPointer), type.FullName);
|
|
Debug.Assert(!(type.IsArray), type.FullName);
|
|
Debug.Assert(!(type is TypeBuilder), type.FullName);
|
|
Debug.Assert(!(type.Module.IsDefined(typeof(JavaModuleAttribute), false)));
|
|
|
|
this.type = type;
|
|
}
|
|
|
|
internal override ClassLoaderWrapper GetClassLoader()
|
|
{
|
|
return ClassLoaderWrapper.GetSystemClassLoader();
|
|
}
|
|
|
|
private class DelegateMethodWrapper : MethodWrapper
|
|
{
|
|
private ConstructorInfo delegateConstructor;
|
|
private MethodInfo method;
|
|
|
|
internal DelegateMethodWrapper(TypeWrapper declaringType, Type delegateType, TypeWrapper iface)
|
|
: base(declaringType, new MethodDescriptor("<init>", "(" + iface.SigName + ")V"), null, PrimitiveTypeWrapper.VOID, new TypeWrapper[] { iface }, Modifiers.Public, MemberFlags.None)
|
|
{
|
|
this.delegateConstructor = delegateType.GetConstructor(new Type[] { typeof(object), typeof(IntPtr) });
|
|
this.method = iface.TypeAsTBD.GetMethod("Invoke");
|
|
}
|
|
|
|
internal override void EmitNewobj(ILGenerator ilgen)
|
|
{
|
|
ilgen.Emit(OpCodes.Dup);
|
|
ilgen.Emit(OpCodes.Ldvirtftn, method);
|
|
ilgen.Emit(OpCodes.Newobj, delegateConstructor);
|
|
}
|
|
|
|
internal override object Invoke(object obj, object[] args, bool nonVirtual)
|
|
{
|
|
// TODO map exceptions
|
|
return Delegate.CreateDelegate(DeclaringType.TypeAsTBD, args[0], "Invoke");
|
|
}
|
|
}
|
|
|
|
private class ByRefMethodWrapper : SmartMethodWrapper
|
|
{
|
|
private bool[] byrefs;
|
|
private Type[] args;
|
|
|
|
internal ByRefMethodWrapper(Type[] args, bool[] byrefs, TypeWrapper declaringType, MethodDescriptor md, MethodBase method, TypeWrapper returnType, TypeWrapper[] parameterTypes, Modifiers modifiers, bool hideFromReflection)
|
|
: base(declaringType, md, method, returnType, parameterTypes, modifiers, hideFromReflection ? MemberFlags.HideFromReflection : MemberFlags.None)
|
|
{
|
|
this.args = args;
|
|
this.byrefs = byrefs;
|
|
}
|
|
|
|
protected override void CallImpl(ILGenerator ilgen)
|
|
{
|
|
MethodBase mb = GetMethod();
|
|
MethodInfo mi = mb as MethodInfo;
|
|
if(mi != null)
|
|
{
|
|
ilgen.Emit(OpCodes.Call, mi);
|
|
}
|
|
else
|
|
{
|
|
ilgen.Emit(OpCodes.Call, (ConstructorInfo)mb);
|
|
}
|
|
}
|
|
|
|
protected override void CallvirtImpl(ILGenerator ilgen)
|
|
{
|
|
ilgen.Emit(OpCodes.Callvirt, (MethodInfo)GetMethod());
|
|
}
|
|
|
|
protected override void NewobjImpl(ILGenerator ilgen)
|
|
{
|
|
ilgen.Emit(OpCodes.Newobj, (ConstructorInfo)GetMethod());
|
|
}
|
|
|
|
protected override void PreEmit(ILGenerator ilgen)
|
|
{
|
|
LocalBuilder[] locals = new LocalBuilder[args.Length];
|
|
for(int i = args.Length - 1; i >= 0; i--)
|
|
{
|
|
Type type = args[i];
|
|
if(type.IsByRef)
|
|
{
|
|
type = type.Assembly.GetType(type.GetElementType().FullName + "[]", true);
|
|
}
|
|
locals[i] = ilgen.DeclareLocal(type);
|
|
ilgen.Emit(OpCodes.Stloc, locals[i]);
|
|
}
|
|
for(int i = 0; i < args.Length; i++)
|
|
{
|
|
ilgen.Emit(OpCodes.Ldloc, locals[i]);
|
|
if(args[i].IsByRef)
|
|
{
|
|
ilgen.Emit(OpCodes.Ldc_I4_0);
|
|
ilgen.Emit(OpCodes.Ldelema, args[i].GetElementType());
|
|
}
|
|
}
|
|
base.PreEmit(ilgen);
|
|
}
|
|
|
|
internal override object Invoke(object obj, object[] args, bool nonVirtual)
|
|
{
|
|
object[] newargs = (object[])args.Clone();
|
|
for(int i = 0; i < newargs.Length; i++)
|
|
{
|
|
if(byrefs[i])
|
|
{
|
|
newargs[i] = ((Array)args[i]).GetValue(0);
|
|
}
|
|
}
|
|
try
|
|
{
|
|
return base.Invoke(obj, newargs, nonVirtual);
|
|
}
|
|
finally
|
|
{
|
|
for(int i = 0; i < newargs.Length; i++)
|
|
{
|
|
if(byrefs[i])
|
|
{
|
|
((Array)args[i]).SetValue(newargs[i], 0);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
internal static bool IsVisible(Type type)
|
|
{
|
|
return type.IsPublic || (type.IsNestedPublic && IsVisible(type.DeclaringType));
|
|
}
|
|
|
|
private class EnumWrapMethodWrapper : MethodWrapper
|
|
{
|
|
internal EnumWrapMethodWrapper(DotNetTypeWrapper tw, TypeWrapper fieldType)
|
|
: base(tw, new MethodDescriptor("wrap", "(" + fieldType.SigName + ")" + tw.SigName), null, tw, new TypeWrapper[] { fieldType }, Modifiers.Static | Modifiers.Public, MemberFlags.None)
|
|
{
|
|
}
|
|
|
|
internal override void EmitCall(ILGenerator ilgen)
|
|
{
|
|
// NOTE we don't support custom boxing rules for enums
|
|
ilgen.Emit(OpCodes.Box, ((DotNetTypeWrapper)DeclaringType).type);
|
|
}
|
|
|
|
internal override object Invoke(object obj, object[] args, bool nonVirtual)
|
|
{
|
|
return Enum.ToObject(DeclaringType.TypeAsTBD, ((IConvertible)args[0]).ToInt64(null));
|
|
}
|
|
}
|
|
|
|
private class EnumValueFieldWrapper : FieldWrapper
|
|
{
|
|
// NOTE if the reference on the stack is null, we *want* the NullReferenceException, so we don't use TypeWrapper.EmitUnbox
|
|
internal EnumValueFieldWrapper(DotNetTypeWrapper tw, TypeWrapper fieldType)
|
|
: base(tw, fieldType, "Value", fieldType.SigName, Modifiers.Public | Modifiers.Final, null)
|
|
{
|
|
}
|
|
|
|
protected override void EmitGetImpl(ILGenerator ilgen)
|
|
{
|
|
DotNetTypeWrapper tw = (DotNetTypeWrapper)this.DeclaringType;
|
|
ilgen.Emit(OpCodes.Unbox, tw.type);
|
|
ilgen.Emit(OpCodes.Ldobj, tw.type);
|
|
}
|
|
|
|
protected override void EmitSetImpl(ILGenerator ilgen)
|
|
{
|
|
throw new InvalidOperationException();
|
|
}
|
|
|
|
internal override void SetValue(object obj, object val)
|
|
{
|
|
// NOTE even though the field is final, JNI reflection can still be used to set its value!
|
|
// NOTE the CLI spec says that an enum has exactly one instance field, so we take advantage of that fact.
|
|
FieldInfo f = DeclaringType.TypeAsTBD.GetFields(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance)[0];
|
|
f.SetValue(obj, val);
|
|
}
|
|
|
|
internal override object GetValue(object obj)
|
|
{
|
|
if(FieldTypeWrapper == PrimitiveTypeWrapper.LONG)
|
|
{
|
|
return ((IConvertible)obj).ToInt64(null);
|
|
}
|
|
else
|
|
{
|
|
return ((IConvertible)obj).ToInt32(null);
|
|
}
|
|
}
|
|
}
|
|
|
|
internal override Assembly Assembly
|
|
{
|
|
get
|
|
{
|
|
return type.Assembly;
|
|
}
|
|
}
|
|
|
|
private class ValueTypeDefaultCtor : MethodWrapper
|
|
{
|
|
internal ValueTypeDefaultCtor(DotNetTypeWrapper tw)
|
|
: base(tw, new MethodDescriptor("<init>", "()V"), null, PrimitiveTypeWrapper.VOID, TypeWrapper.EmptyArray, Modifiers.Public, MemberFlags.None)
|
|
{
|
|
}
|
|
|
|
internal override void EmitNewobj(ILGenerator ilgen)
|
|
{
|
|
LocalBuilder local = ilgen.DeclareLocal(DeclaringType.TypeAsTBD);
|
|
ilgen.Emit(OpCodes.Ldloc, local);
|
|
ilgen.Emit(OpCodes.Box, DeclaringType.TypeAsTBD);
|
|
}
|
|
|
|
internal override object Invoke(object obj, object[] args, bool nonVirtual)
|
|
{
|
|
if(obj == null)
|
|
{
|
|
obj = Activator.CreateInstance(DeclaringType.TypeAsTBD);
|
|
}
|
|
return obj;
|
|
}
|
|
}
|
|
|
|
protected override void LazyPublishMembers()
|
|
{
|
|
// special support for enums
|
|
if(type.IsEnum)
|
|
{
|
|
// TODO handle unsigned underlying type
|
|
TypeWrapper fieldType = ClassLoaderWrapper.GetWrapperFromType(Enum.GetUnderlyingType(type));
|
|
FieldInfo[] fields = type.GetFields(BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.Static);
|
|
for(int i = 0; i < fields.Length; i++)
|
|
{
|
|
if(fields[i].FieldType == type)
|
|
{
|
|
string name = fields[i].Name;
|
|
if(name == "Value")
|
|
{
|
|
name = "_Value";
|
|
}
|
|
else if(name.StartsWith("_") && name.EndsWith("Value"))
|
|
{
|
|
name = "_" + name;
|
|
}
|
|
AddField(new ConstantFieldWrapper(this, fieldType, name, fieldType.SigName, Modifiers.Public | Modifiers.Static | Modifiers.Final, fields[i], null));
|
|
}
|
|
}
|
|
AddField(new EnumValueFieldWrapper(this, fieldType));
|
|
AddMethod(new EnumWrapMethodWrapper(this, fieldType));
|
|
}
|
|
else
|
|
{
|
|
FieldInfo[] fields = type.GetFields(BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.Instance);
|
|
for(int i = 0; i < fields.Length; i++)
|
|
{
|
|
// TODO for remapped types, instance fields need to be converted to static getter/setter methods
|
|
if(fields[i].FieldType.IsPointer)
|
|
{
|
|
// skip, pointer fields are not supported
|
|
}
|
|
else
|
|
{
|
|
// TODO handle name/signature clash
|
|
AddField(CreateFieldWrapperDotNet(AttributeHelper.GetModifiers(fields[i], true), fields[i].Name, fields[i].FieldType, fields[i]));
|
|
}
|
|
}
|
|
|
|
// special case for delegate constructors!
|
|
if(IsDelegate)
|
|
{
|
|
TypeWrapper iface = InnerClasses[0];
|
|
Debug.Assert(iface is CompiledTypeWrapper);
|
|
iface.Finish();
|
|
AddMethod(new DelegateMethodWrapper(this, type, iface));
|
|
}
|
|
|
|
bool fabricateDefaultCtor = type.IsValueType;
|
|
|
|
ConstructorInfo[] constructors = type.GetConstructors(BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.Instance);
|
|
for(int i = 0; i < constructors.Length; i++)
|
|
{
|
|
MethodDescriptor md = MakeMethodDescriptor(constructors[i]);
|
|
if(md != null)
|
|
{
|
|
if(fabricateDefaultCtor && !constructors[i].IsStatic && md.Signature == "()V")
|
|
{
|
|
fabricateDefaultCtor = false;
|
|
}
|
|
// TODO handle name/signature clash
|
|
AddMethod(CreateMethodWrapper(md, constructors[i], false));
|
|
}
|
|
}
|
|
|
|
if(fabricateDefaultCtor)
|
|
{
|
|
// Value types have an implicit default ctor
|
|
AddMethod(new ValueTypeDefaultCtor(this));
|
|
}
|
|
|
|
MethodInfo[] methods = type.GetMethods(BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.Instance);
|
|
for(int i = 0; i < methods.Length; i++)
|
|
{
|
|
if(methods[i].IsStatic && type.IsInterface)
|
|
{
|
|
// skip, Java cannot deal with static methods on interfaces
|
|
}
|
|
else
|
|
{
|
|
MethodDescriptor md = MakeMethodDescriptor(methods[i]);
|
|
if(md != null)
|
|
{
|
|
if(!methods[i].IsStatic && !methods[i].IsPrivate && BaseTypeWrapper != null)
|
|
{
|
|
MethodWrapper baseMethod = BaseTypeWrapper.GetMethodWrapper(md, true);
|
|
if(baseMethod != null && baseMethod.IsFinal && !baseMethod.IsStatic && !baseMethod.IsPrivate)
|
|
{
|
|
continue;
|
|
}
|
|
}
|
|
// TODO handle name/signature clash
|
|
AddMethod(CreateMethodWrapper(md, methods[i], false));
|
|
}
|
|
}
|
|
}
|
|
|
|
// HACK private interface implementations need to be published as well
|
|
// (otherwise the type appears abstract while it isn't)
|
|
if(!type.IsAbstract)
|
|
{
|
|
Type[] interfaces = type.GetInterfaces();
|
|
for(int i = 0; i < interfaces.Length; i++)
|
|
{
|
|
if(interfaces[i].IsPublic)
|
|
{
|
|
InterfaceMapping map = type.GetInterfaceMap(interfaces[i]);
|
|
for(int j = 0; j < map.InterfaceMethods.Length; j++)
|
|
{
|
|
if(!map.TargetMethods[j].IsPublic && map.TargetMethods[j].DeclaringType == type)
|
|
{
|
|
MethodDescriptor md = MakeMethodDescriptor(map.InterfaceMethods[j]);
|
|
if(md != null)
|
|
{
|
|
if(BaseTypeWrapper != null)
|
|
{
|
|
MethodWrapper baseMethod = BaseTypeWrapper.GetMethodWrapper(md, true);
|
|
if(baseMethod != null && !baseMethod.IsStatic && baseMethod.IsPublic)
|
|
{
|
|
continue;
|
|
}
|
|
}
|
|
// TODO handle name/signature clash
|
|
AddMethod(CreateMethodWrapper(md, map.InterfaceMethods[j], true));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// for non-final remapped types, we need to add all the virtual methods in our alter ego (which
|
|
// appears as our base class) and make them final (to prevent Java code from overriding these
|
|
// methods, which don't really exist).
|
|
if(ClassLoaderWrapper.IsRemappedType(type) && !type.IsSealed && !type.IsInterface)
|
|
{
|
|
// Finish the type, to make sure the methods are populated
|
|
this.BaseTypeWrapper.Finish();
|
|
Hashtable h = new Hashtable();
|
|
TypeWrapper baseTypeWrapper = this.BaseTypeWrapper;
|
|
while(baseTypeWrapper != null)
|
|
{
|
|
foreach(MethodWrapper m in baseTypeWrapper.GetMethods())
|
|
{
|
|
if(!m.IsStatic && !m.IsFinal && (m.IsPublic || m.IsProtected) && m.Name != "<init>")
|
|
{
|
|
if(!h.ContainsKey(m.Name + m.Signature))
|
|
{
|
|
h.Add(m.Name + m.Signature, "");
|
|
// TODO handle name/sig clash (what should we do?)
|
|
AddMethod(new BaseFinalMethodWrapper(this, m));
|
|
}
|
|
}
|
|
}
|
|
baseTypeWrapper = baseTypeWrapper.BaseTypeWrapper;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private class BaseFinalMethodWrapper : MethodWrapper
|
|
{
|
|
private MethodWrapper m;
|
|
|
|
internal BaseFinalMethodWrapper(DotNetTypeWrapper tw, MethodWrapper m)
|
|
: base(tw, m.Descriptor, m.GetMethod(), m.ReturnType, m.GetParameters(), m.Modifiers | Modifiers.Final, MemberFlags.None)
|
|
{
|
|
this.m = m;
|
|
}
|
|
|
|
internal override void EmitCall(ILGenerator ilgen)
|
|
{
|
|
// we direct EmitCall to EmitCallvirt, because we always want to end up at the instancehelper method
|
|
// (EmitCall would go to our alter ego .NET type and that wouldn't be legal)
|
|
m.EmitCallvirt(ilgen);
|
|
}
|
|
|
|
internal override void EmitCallvirt(ILGenerator ilgen)
|
|
{
|
|
m.EmitCallvirt(ilgen);
|
|
}
|
|
|
|
internal override object Invoke(object obj, object[] args, bool nonVirtual)
|
|
{
|
|
return m.Invoke(obj, args, nonVirtual);
|
|
}
|
|
}
|
|
|
|
private MethodDescriptor MakeMethodDescriptor(MethodBase mb)
|
|
{
|
|
if(Whidbey.IsGenericMethodDefinition(mb))
|
|
{
|
|
return null;
|
|
}
|
|
System.Text.StringBuilder sb = new System.Text.StringBuilder();
|
|
sb.Append('(');
|
|
ParameterInfo[] parameters = mb.GetParameters();
|
|
TypeWrapper[] args = new TypeWrapper[parameters.Length];
|
|
for(int i = 0; i < parameters.Length; i++)
|
|
{
|
|
Type type = parameters[i].ParameterType;
|
|
if(type.IsPointer)
|
|
{
|
|
return null;
|
|
}
|
|
if(type.IsByRef)
|
|
{
|
|
if(type.GetElementType().IsPointer)
|
|
{
|
|
return null;
|
|
}
|
|
type = type.Assembly.GetType(type.GetElementType().FullName + "[]", true);
|
|
if(mb.IsAbstract)
|
|
{
|
|
// Since we cannot override methods with byref arguments, we don't report abstract
|
|
// methods with byref args.
|
|
return null;
|
|
}
|
|
}
|
|
TypeWrapper tw = ClassLoaderWrapper.GetWrapperFromType(type);
|
|
args[i] = tw;
|
|
sb.Append(tw.SigName);
|
|
}
|
|
sb.Append(')');
|
|
if(mb is ConstructorInfo)
|
|
{
|
|
TypeWrapper ret = PrimitiveTypeWrapper.VOID;
|
|
string name;
|
|
if(mb.IsStatic)
|
|
{
|
|
name = "<clinit>";
|
|
}
|
|
else
|
|
{
|
|
name = "<init>";
|
|
}
|
|
sb.Append(ret.SigName);
|
|
return new MethodDescriptor(name, sb.ToString());
|
|
}
|
|
else
|
|
{
|
|
Type type = ((MethodInfo)mb).ReturnType;
|
|
if(type.IsPointer || type.IsByRef)
|
|
{
|
|
return null;
|
|
}
|
|
TypeWrapper ret = ClassLoaderWrapper.GetWrapperFromType(type);
|
|
sb.Append(ret.SigName);
|
|
return new MethodDescriptor(mb.Name, sb.ToString());
|
|
}
|
|
}
|
|
|
|
internal override TypeWrapper[] Interfaces
|
|
{
|
|
get
|
|
{
|
|
lock(this)
|
|
{
|
|
if(interfaces == null)
|
|
{
|
|
Type[] interfaceTypes = type.GetInterfaces();
|
|
interfaces = new TypeWrapper[interfaceTypes.Length];
|
|
for(int i = 0; i < interfaces.Length; i++)
|
|
{
|
|
interfaces[i] = ClassLoaderWrapper.GetWrapperFromType(interfaceTypes[i]);
|
|
}
|
|
}
|
|
return interfaces;
|
|
}
|
|
}
|
|
}
|
|
|
|
private bool IsDelegate
|
|
{
|
|
get
|
|
{
|
|
// HACK non-public delegates do not get the special treatment (because they are likely to refer to
|
|
// non-public types in the arg list and they're not really useful anyway)
|
|
// NOTE we don't have to check in what assembly the type lives, because this is a DotNetTypeWrapper,
|
|
// we know that it is a different assembly.
|
|
return !type.IsAbstract && type.IsSubclassOf(typeof(MulticastDelegate)) && IsVisible(type);
|
|
}
|
|
}
|
|
|
|
internal override TypeWrapper[] InnerClasses
|
|
{
|
|
get
|
|
{
|
|
lock(this)
|
|
{
|
|
if(innerClasses == null)
|
|
{
|
|
if(IsDelegate)
|
|
{
|
|
innerClasses = new TypeWrapper[] { GetClassLoader().LoadClassByDottedName(Name + DelegateInterfaceSuffix) };
|
|
}
|
|
else
|
|
{
|
|
Type[] nestedTypes = type.GetNestedTypes(BindingFlags.Public | BindingFlags.NonPublic);
|
|
ArrayList list = new ArrayList(nestedTypes.Length);
|
|
for(int i = 0; i < nestedTypes.Length; i++)
|
|
{
|
|
if(!Whidbey.IsGenericTypeDefinition(nestedTypes[i]))
|
|
{
|
|
list.Add(ClassLoaderWrapper.GetWrapperFromType(nestedTypes[i]));
|
|
}
|
|
}
|
|
innerClasses = (TypeWrapper[])list.ToArray(typeof(TypeWrapper));
|
|
}
|
|
}
|
|
}
|
|
return innerClasses;
|
|
}
|
|
}
|
|
|
|
internal override TypeWrapper DeclaringTypeWrapper
|
|
{
|
|
get
|
|
{
|
|
if(outerClass == null)
|
|
{
|
|
Type outer = type.DeclaringType;
|
|
if(outer != null)
|
|
{
|
|
outerClass = ClassLoaderWrapper.GetWrapperFromType(outer);
|
|
}
|
|
}
|
|
return outerClass;
|
|
}
|
|
}
|
|
|
|
internal override Modifiers ReflectiveModifiers
|
|
{
|
|
get
|
|
{
|
|
if(DeclaringTypeWrapper != null)
|
|
{
|
|
return Modifiers | Modifiers.Static;
|
|
}
|
|
return Modifiers;
|
|
}
|
|
}
|
|
|
|
private FieldWrapper CreateFieldWrapperDotNet(Modifiers modifiers, string name, Type fieldType, FieldInfo field)
|
|
{
|
|
TypeWrapper type = ClassLoaderWrapper.GetWrapperFromType(fieldType);
|
|
if(field.IsLiteral)
|
|
{
|
|
return new ConstantFieldWrapper(this, type, name, type.SigName, modifiers, field, null);
|
|
}
|
|
else
|
|
{
|
|
return FieldWrapper.Create(this, type, field, name, type.SigName, modifiers);
|
|
}
|
|
}
|
|
|
|
private MethodWrapper CreateMethodWrapper(MethodDescriptor md, MethodBase mb, bool privateInterfaceImplHack)
|
|
{
|
|
Modifiers mods = AttributeHelper.GetModifiers(mb, true);
|
|
if(md.Name == "Finalize" && md.Signature == "()V" && !mb.IsStatic &&
|
|
TypeAsBaseType.IsSubclassOf(CoreClasses.java.lang.Object.Wrapper.TypeAsBaseType))
|
|
{
|
|
// TODO if the .NET also has a "finalize" method, we need to hide that one (or rename it, or whatever)
|
|
MethodWrapper mw = new SimpleCallMethodWrapper(this, new MethodDescriptor("finalize", "()V"), (MethodInfo)mb, null, null, mods, false, OpCodes.Call, OpCodes.Callvirt);
|
|
mw.SetDeclaredExceptions(new string[] { "java.lang.Throwable" });
|
|
return mw;
|
|
}
|
|
ParameterInfo[] parameters = mb.GetParameters();
|
|
Type[] args = new Type[parameters.Length];
|
|
bool hasByRefArgs = false;
|
|
bool[] byrefs = null;
|
|
for(int i = 0; i < parameters.Length; i++)
|
|
{
|
|
args[i] = parameters[i].ParameterType;
|
|
if(parameters[i].ParameterType.IsByRef)
|
|
{
|
|
if(byrefs == null)
|
|
{
|
|
byrefs = new bool[args.Length];
|
|
}
|
|
byrefs[i] = true;
|
|
hasByRefArgs = true;
|
|
}
|
|
}
|
|
if(privateInterfaceImplHack)
|
|
{
|
|
mods &= ~Modifiers.Abstract;
|
|
mods |= Modifiers.Final;
|
|
}
|
|
if(hasByRefArgs)
|
|
{
|
|
if(!(mb is ConstructorInfo) && !mb.IsStatic)
|
|
{
|
|
mods |= Modifiers.Final;
|
|
}
|
|
// TODO pass in the argument and return types
|
|
return new ByRefMethodWrapper(args, byrefs, this, md, mb, null, null, mods, false);
|
|
}
|
|
else
|
|
{
|
|
if(mb is ConstructorInfo)
|
|
{
|
|
// TODO pass in the argument and return types
|
|
return new SmartConstructorMethodWrapper(this, md, (ConstructorInfo)mb, null, mods, false);
|
|
}
|
|
else
|
|
{
|
|
// TODO pass in the argument and return types
|
|
return new SmartCallMethodWrapper(this, md, (MethodInfo)mb, null, null, mods, false, OpCodes.Call, OpCodes.Callvirt);
|
|
}
|
|
}
|
|
}
|
|
|
|
internal override Type TypeAsTBD
|
|
{
|
|
get
|
|
{
|
|
return type;
|
|
}
|
|
}
|
|
|
|
internal override bool IsRemapped
|
|
{
|
|
get
|
|
{
|
|
return ClassLoaderWrapper.IsRemappedType(type);
|
|
}
|
|
}
|
|
|
|
internal override void EmitInstanceOf(TypeWrapper context, ILGenerator ilgen)
|
|
{
|
|
if(IsRemapped)
|
|
{
|
|
TypeWrapper shadow = ClassLoaderWrapper.GetWrapperFromTypeFast(type);
|
|
MethodInfo method = shadow.TypeAsBaseType.GetMethod("__<instanceof>");
|
|
if(method != null)
|
|
{
|
|
ilgen.Emit(OpCodes.Call, method);
|
|
return;
|
|
}
|
|
}
|
|
ilgen.Emit(OpCodes.Isinst, type);
|
|
ilgen.Emit(OpCodes.Ldnull);
|
|
ilgen.Emit(OpCodes.Cgt_Un);
|
|
}
|
|
|
|
internal override void EmitCheckcast(TypeWrapper context, ILGenerator ilgen)
|
|
{
|
|
if(IsRemapped)
|
|
{
|
|
TypeWrapper shadow = ClassLoaderWrapper.GetWrapperFromTypeFast(type);
|
|
MethodInfo method = shadow.TypeAsBaseType.GetMethod("__<checkcast>");
|
|
if(method != null)
|
|
{
|
|
ilgen.Emit(OpCodes.Call, method);
|
|
return;
|
|
}
|
|
}
|
|
ilgen.Emit(OpCodes.Castclass, type);
|
|
}
|
|
}
|
|
|
|
sealed class ArrayTypeWrapper : TypeWrapper
|
|
{
|
|
private static TypeWrapper[] interfaces;
|
|
private static MethodInfo clone;
|
|
private Type type;
|
|
|
|
internal ArrayTypeWrapper(Type type, Modifiers modifiers, string name, ClassLoaderWrapper classLoader)
|
|
: base(modifiers, name, CoreClasses.java.lang.Object.Wrapper, classLoader)
|
|
{
|
|
this.type = type;
|
|
if(clone == null)
|
|
{
|
|
clone = typeof(Array).GetMethod("Clone");
|
|
}
|
|
MethodWrapper mw = new SimpleCallMethodWrapper(this, new MethodDescriptor("clone", "()Ljava.lang.Object;"), clone, CoreClasses.java.lang.Object.Wrapper, TypeWrapper.EmptyArray, Modifiers.Public, true, OpCodes.Callvirt, OpCodes.Callvirt);
|
|
mw.Link();
|
|
AddMethod(mw);
|
|
}
|
|
|
|
internal override Assembly Assembly
|
|
{
|
|
get
|
|
{
|
|
return type.Assembly;
|
|
}
|
|
}
|
|
|
|
internal override string SigName
|
|
{
|
|
get
|
|
{
|
|
// for arrays the signature name is the same as the normal name
|
|
return Name;
|
|
}
|
|
}
|
|
|
|
internal override TypeWrapper[] Interfaces
|
|
{
|
|
get
|
|
{
|
|
if(interfaces == null)
|
|
{
|
|
TypeWrapper[] tw = new TypeWrapper[2];
|
|
tw[0] = ClassLoaderWrapper.LoadClassCritical("java.lang.Cloneable");
|
|
tw[1] = ClassLoaderWrapper.LoadClassCritical("java.io.Serializable");
|
|
interfaces = tw;
|
|
}
|
|
return interfaces;
|
|
}
|
|
}
|
|
|
|
internal override TypeWrapper[] InnerClasses
|
|
{
|
|
get
|
|
{
|
|
return TypeWrapper.EmptyArray;
|
|
}
|
|
}
|
|
|
|
internal override TypeWrapper DeclaringTypeWrapper
|
|
{
|
|
get
|
|
{
|
|
return null;
|
|
}
|
|
}
|
|
|
|
internal override Type TypeAsTBD
|
|
{
|
|
get
|
|
{
|
|
return type;
|
|
}
|
|
}
|
|
|
|
protected override FieldWrapper GetFieldImpl(string fieldName, string fieldSig)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
private bool IsFinished
|
|
{
|
|
get
|
|
{
|
|
Type elem = type.GetElementType();
|
|
while(elem.IsArray)
|
|
{
|
|
elem = elem.GetElementType();
|
|
}
|
|
return !(elem is TypeBuilder);
|
|
}
|
|
}
|
|
|
|
internal override void Finish(bool forDebugSave)
|
|
{
|
|
lock(this)
|
|
{
|
|
// TODO optimize this
|
|
if(!IsFinished)
|
|
{
|
|
TypeWrapper elementTypeWrapper = ElementTypeWrapper;
|
|
Type elementType = elementTypeWrapper.TypeAsArrayType;
|
|
elementTypeWrapper.Finish();
|
|
type = elementType.Assembly.GetType(elementType.FullName + "[]", true);
|
|
ClassLoaderWrapper.SetWrapperForType(type, this);
|
|
}
|
|
}
|
|
}
|
|
}
|