Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP
Fetching contributors…

Cannot retrieve contributors at this time

6058 lines (5802 sloc) 207.115 kb
/*
Copyright (C) 2002-2012 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.Generic;
#if STATIC_COMPILER
using IKVM.Reflection;
using IKVM.Reflection.Emit;
using Type = IKVM.Reflection.Type;
using DynamicOrAotTypeWrapper = IKVM.Internal.AotTypeWrapper;
#else
using System.Reflection;
using System.Reflection.Emit;
using DynamicOrAotTypeWrapper = IKVM.Internal.DynamicTypeWrapper;
#endif
using System.Diagnostics;
using System.Security;
using System.Security.Permissions;
using IKVM.Attributes;
namespace IKVM.Internal
{
#if STATIC_COMPILER
abstract class DynamicTypeWrapper : TypeWrapper
#else
class DynamicTypeWrapper : TypeWrapper
#endif
{
#if STATIC_COMPILER
protected readonly CompilerClassLoader classLoader;
#else
protected readonly ClassLoaderWrapper classLoader;
#endif
private volatile DynamicImpl impl;
private readonly TypeWrapper baseTypeWrapper;
private TypeWrapper[] interfaces;
private readonly string sourceFileName;
#if !STATIC_COMPILER
private byte[][] lineNumberTables;
#endif
private MethodBase automagicSerializationCtor;
private static TypeWrapper LoadTypeWrapper(ClassLoaderWrapper classLoader, string name)
{
TypeWrapper tw = classLoader.LoadClassByDottedNameFast(name);
if (tw == null)
{
throw new NoClassDefFoundError(name);
}
return tw;
}
#if STATIC_COMPILER
internal DynamicTypeWrapper(ClassFile f, CompilerClassLoader classLoader)
#else
internal DynamicTypeWrapper(ClassFile f, ClassLoaderWrapper classLoader)
#endif
: base(f.Modifiers, f.Name)
{
Profiler.Count("DynamicTypeWrapper");
this.classLoader = classLoader;
this.IsInternal = f.IsInternal;
this.sourceFileName = f.SourceFileAttribute;
this.baseTypeWrapper = f.IsInterface ? null : LoadTypeWrapper(classLoader, f.SuperClass);
if (BaseTypeWrapper != null)
{
if (!BaseTypeWrapper.IsAccessibleFrom(this))
{
throw new IllegalAccessError("Class " + f.Name + " cannot access its superclass " + BaseTypeWrapper.Name);
}
#if !STATIC_COMPILER
if (!BaseTypeWrapper.IsPublic && !ReflectUtil.IsFromAssembly(BaseTypeWrapper.TypeAsBaseType, classLoader.GetTypeWrapperFactory().ModuleBuilder.Assembly))
{
// NOTE this can only happen if evil code calls ClassLoader.defineClass() on an assembly class loader (which we allow for compatibility with other slightly less evil code)
throw new IllegalAccessError("Class " + f.Name + " cannot access its non-public superclass " + BaseTypeWrapper.Name + " from another assembly");
}
#endif
if (BaseTypeWrapper.IsFinal)
{
throw new VerifyError("Class " + f.Name + " extends final class " + BaseTypeWrapper.Name);
}
if (BaseTypeWrapper.IsInterface)
{
throw new IncompatibleClassChangeError("Class " + f.Name + " has interface " + BaseTypeWrapper.Name + " as superclass");
}
if (BaseTypeWrapper.TypeAsTBD == Types.Delegate)
{
throw new VerifyError(BaseTypeWrapper.Name + " cannot be used as a base class");
}
// NOTE defining value types, enums is not supported in IKVM v1
if (BaseTypeWrapper.TypeAsTBD == Types.ValueType || BaseTypeWrapper.TypeAsTBD == Types.Enum)
{
throw new VerifyError("Defining value types in Java is not implemented in IKVM v1");
}
if (IsDelegate)
{
VerifyDelegate(f);
}
#if CLASSGC
if (JVM.classUnloading && BaseTypeWrapper.TypeAsBaseType == typeof(ContextBoundObject))
{
throw new VerifyError("Extending ContextBoundObject is not supported in dynamic mode with class GC enabled.");
}
#endif
}
#if CLASSGC
if (JVM.classUnloading)
{
VerifyRunAndCollect(f);
}
#endif
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 !STATIC_COMPILER
if (!iface.IsPublic && !ReflectUtil.IsFromAssembly(iface.TypeAsBaseType, classLoader.GetTypeWrapperFactory().ModuleBuilder.Assembly))
{
string proxyName = DynamicClassLoader.GetProxyHelperName(iface.TypeAsTBD);
Type proxyType = ReflectUtil.GetAssembly(iface.TypeAsBaseType).GetType(proxyName);
// FXBUG we need to check if the type returned is actually correct, because .NET 2.0 has a bug that
// causes it to return typeof(IFoo) for GetType("__<Proxy>+IFoo")
if (proxyType == null || proxyType.FullName != proxyName)
{
// NOTE this happens when you call Proxy.newProxyInstance() on a non-public .NET interface
// (for ikvmc compiled Java types, ikvmc generates public proxy stubs).
// NOTE we don't currently check interfaces inherited from other interfaces because mainstream .NET languages
// don't allow public interfaces extending non-public interfaces.
throw new IllegalAccessError("Class " + f.Name + " cannot access its non-public superinterface " + iface.Name + " from another assembly");
}
}
#endif
if (!iface.IsInterface)
{
throw new IncompatibleClassChangeError("Implementing class");
}
this.interfaces[i] = iface;
}
impl = new JavaTypeImpl(f, this);
}
#if CLASSGC
private static void VerifyRunAndCollect(ClassFile f)
{
if (f.Annotations != null)
{
foreach (object[] ann in f.Annotations)
{
if (ann[1].Equals("Lcli/System/Runtime/InteropServices/ComImportAttribute$Annotation;"))
{
throw new VerifyError("ComImportAttribute is not supported in dynamic mode with class GC enabled.");
}
}
}
foreach (ClassFile.Field field in f.Fields)
{
if (field.Annotations != null)
{
foreach (object[] ann in field.Annotations)
{
if (ann[1].Equals("Lcli/System/ThreadStaticAttribute$Annotation;"))
{
throw new VerifyError("ThreadStaticAttribute is not supported in dynamic mode with class GC enabled.");
}
if (ann[1].Equals("Lcli/System/ContextStaticAttribute$Annotation;"))
{
throw new VerifyError("ContextStaticAttribute is not supported in dynamic mode with class GC enabled.");
}
}
}
}
foreach (ClassFile.Method method in f.Methods)
{
if (method.Annotations != null)
{
foreach (object[] ann in method.Annotations)
{
if (ann[1].Equals("Lcli/System/Runtime/InteropServices/DllImportAttribute$Annotation;"))
{
throw new VerifyError("DllImportAttribute is not supported in dynamic mode with class GC enabled.");
}
}
}
}
}
#endif
private void VerifyDelegate(ClassFile f)
{
if (!f.IsFinal)
{
throw new VerifyError("Delegate must be final");
}
ClassFile.Method invoke = null;
ClassFile.Method beginInvoke = null;
ClassFile.Method endInvoke = null;
ClassFile.Method constructor = null;
foreach (ClassFile.Method m in f.Methods)
{
if (m.Name == "Invoke")
{
if (invoke != null)
{
throw new VerifyError("Delegate may only have a single Invoke method");
}
invoke = m;
}
else if (m.Name == "BeginInvoke")
{
if (beginInvoke != null)
{
throw new VerifyError("Delegate may only have a single BeginInvoke method");
}
beginInvoke = m;
}
else if (m.Name == "EndInvoke")
{
if (endInvoke != null)
{
throw new VerifyError("Delegate may only have a single EndInvoke method");
}
endInvoke = m;
}
else if (m.Name == "<init>")
{
if (constructor != null)
{
throw new VerifyError("Delegate may only have a single constructor");
}
constructor = m;
}
else if (m.IsNative)
{
throw new VerifyError("Delegate may not have any native methods besides Invoke, BeginInvoke and EndInvoke");
}
}
if (invoke == null || constructor == null)
{
throw new VerifyError("Delegate must have a constructor and an Invoke method");
}
if (!invoke.IsPublic || !invoke.IsNative || invoke.IsFinal || invoke.IsStatic)
{
throw new VerifyError("Delegate Invoke method must be a public native non-final instance method");
}
if ((beginInvoke != null && endInvoke == null) || (beginInvoke == null && endInvoke != null))
{
throw new VerifyError("Delegate must have both BeginInvoke and EndInvoke or neither");
}
if (!constructor.IsPublic)
{
throw new VerifyError("Delegate constructor must be public");
}
if (constructor.Instructions.Length < 3
|| constructor.Instructions[0].NormalizedOpCode != NormalizedByteCode.__aload
|| constructor.Instructions[0].NormalizedArg1 != 0
|| constructor.Instructions[1].NormalizedOpCode != NormalizedByteCode.__invokespecial
|| constructor.Instructions[2].NormalizedOpCode != NormalizedByteCode.__return)
{
throw new VerifyError("Delegate constructor must be empty");
}
if (f.Fields.Length != 0)
{
throw new VerifyError("Delegate may not declare any fields");
}
TypeWrapper iface = classLoader.LoadClassByDottedNameFast(f.Name + DotNetTypeWrapper.DelegateInterfaceSuffix);
DelegateInnerClassCheck(iface != null);
DelegateInnerClassCheck(iface.IsInterface);
DelegateInnerClassCheck(iface.IsPublic);
DelegateInnerClassCheck(iface.GetClassLoader() == classLoader);
MethodWrapper[] methods = iface.GetMethods();
DelegateInnerClassCheck(methods.Length == 1 && methods[0].Name == "Invoke");
if (methods[0].Signature != invoke.Signature)
{
throw new VerifyError("Delegate Invoke method signature must be identical to inner interface Invoke method signature");
}
if (iface.Interfaces.Length != 0)
{
throw new VerifyError("Delegate inner interface may not extend any interfaces");
}
if (constructor.Signature != "(" + iface.SigName + ")V")
{
throw new VerifyError("Delegate constructor must take a single argument of type inner Method interface");
}
if (beginInvoke != null && beginInvoke.Signature != invoke.Signature.Substring(0, invoke.Signature.IndexOf(')')) + "Lcli.System.AsyncCallback;Ljava.lang.Object;)Lcli.System.IAsyncResult;")
{
throw new VerifyError("Delegate BeginInvoke method has incorrect signature");
}
if (endInvoke != null && endInvoke.Signature != "(Lcli.System.IAsyncResult;)" + invoke.Signature.Substring(invoke.Signature.IndexOf(')') + 1))
{
throw new VerifyError("Delegate EndInvoke method has incorrect signature");
}
}
private static void DelegateInnerClassCheck(bool cond)
{
if (!cond)
{
throw new VerifyError("Delegate must have a public inner interface named Method with a single method named Invoke");
}
}
private bool IsDelegate
{
get
{
TypeWrapper baseTypeWrapper = BaseTypeWrapper;
return baseTypeWrapper != null && baseTypeWrapper.TypeAsTBD == Types.MulticastDelegate;
}
}
internal sealed override TypeWrapper BaseTypeWrapper
{
get { return baseTypeWrapper; }
}
internal override ClassLoaderWrapper GetClassLoader()
{
return classLoader;
}
internal override Modifiers ReflectiveModifiers
{
get
{
return impl.ReflectiveModifiers;
}
}
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 void Finish()
{
// we don't need locking, because Finish is Thread safe
impl = impl.Finish();
}
internal void CreateStep1()
{
((JavaTypeImpl)impl).CreateStep1();
}
internal void CreateStep2()
{
((JavaTypeImpl)impl).CreateStep2();
}
private bool IsSerializable
{
get
{
return this.IsSubTypeOf(ClassLoaderWrapper.LoadClassCritical("java.io.Serializable"));
}
}
private abstract class DynamicImpl
{
internal abstract Type Type { get; }
internal abstract TypeWrapper[] InnerClasses { get; }
internal abstract TypeWrapper DeclaringTypeWrapper { get; }
internal abstract Modifiers ReflectiveModifiers { get; }
internal abstract DynamicImpl Finish();
internal abstract MethodBase LinkMethod(MethodWrapper mw);
internal abstract FieldInfo LinkField(FieldWrapper fw);
internal abstract void EmitRunClassConstructor(CodeEmitter ilgen);
internal abstract string GetGenericSignature();
internal abstract string[] GetEnclosingMethod();
internal abstract string GetGenericMethodSignature(int index);
internal abstract string GetGenericFieldSignature(int index);
internal abstract object[] GetDeclaredAnnotations();
internal abstract object GetMethodDefaultValue(int index);
internal abstract object[] GetMethodAnnotations(int index);
internal abstract object[][] GetParameterAnnotations(int index);
internal abstract object[] GetFieldAnnotations(int index);
internal abstract MethodInfo GetFinalizeMethod();
}
private sealed class JavaTypeImpl : DynamicImpl
{
private readonly ClassFile classFile;
private readonly DynamicOrAotTypeWrapper wrapper;
private TypeBuilder typeBuilder;
private MethodWrapper[] methods;
private MethodWrapper[][] baseMethods;
private FieldWrapper[] fields;
private FinishedTypeImpl finishedType;
private bool finishInProgress;
private MethodBuilder clinitMethod;
private MethodBuilder finalizeMethod;
#if STATIC_COMPILER
private DynamicTypeWrapper outerClassWrapper;
private AnnotationBuilder annotationBuilder;
private TypeBuilder enumBuilder;
private Dictionary<string, TypeWrapper> nestedTypeNames; // only keys are used, values are always null
#endif
internal JavaTypeImpl(ClassFile f, DynamicTypeWrapper wrapper)
{
Tracer.Info(Tracer.Compiler, "constructing JavaTypeImpl for " + f.Name);
this.classFile = f;
this.wrapper = (DynamicOrAotTypeWrapper)wrapper;
}
internal void CreateStep1()
{
// process all methods
bool hasclinit = wrapper.BaseTypeWrapper == null ? false : wrapper.BaseTypeWrapper.HasStaticInitializer;
methods = new MethodWrapper[classFile.Methods.Length];
baseMethods = new MethodWrapper[classFile.Methods.Length][];
for (int i = 0; i < methods.Length; i++)
{
ClassFile.Method m = classFile.Methods[i];
if (m.IsClassInitializer)
{
#if STATIC_COMPILER
bool noop;
if (IsSideEffectFreeStaticInitializerOrNoop(m, out noop))
{
// because we cannot affect serialVersionUID computation (which is the only way the presence of a <clinit> can surface)
// we cannot do this optimization if the class is serializable but doesn't have a serialVersionUID
if (noop && (!wrapper.IsSerializable || classFile.HasSerialVersionUID))
{
methods[i] = new DummyMethodWrapper(wrapper);
continue;
}
}
else
{
hasclinit = true;
}
#else
hasclinit = true;
#endif
}
MemberFlags flags = MemberFlags.None;
if (m.IsInternal)
{
flags |= MemberFlags.InternalAccess;
}
// we only support HasCallerID instance methods on final types, because we don't support interface stubs with CallerID
if (m.HasCallerIDAnnotation
&& (m.IsStatic || classFile.IsFinal)
&& CoreClasses.java.lang.Object.Wrapper.InternalsVisibleTo(wrapper))
{
flags |= MemberFlags.CallerID;
}
if (wrapper.IsGhost)
{
methods[i] = new GhostMethodWrapper(wrapper, m.Name, m.Signature, null, null, null, null, m.Modifiers, flags);
}
else if (m.IsConstructor && wrapper.IsDelegate)
{
methods[i] = new DelegateConstructorMethodWrapper(wrapper, m);
}
else
{
if (!classFile.IsInterface && !m.IsStatic && !m.IsPrivate && !m.IsConstructor)
{
bool explicitOverride = false;
baseMethods[i] = FindBaseMethods(m, out explicitOverride);
if (explicitOverride)
{
flags |= MemberFlags.ExplicitOverride;
}
}
methods[i] = new TypicalMethodWrapper(wrapper, m.Name, m.Signature, null, null, null, m.Modifiers, flags);
}
}
wrapper.HasStaticInitializer = hasclinit;
if (wrapper.IsAbstract && (!wrapper.IsInterface || wrapper.IsPublic))
{
List<MethodWrapper> methodsArray = new List<MethodWrapper>(methods);
List<MethodWrapper[]> baseMethodsArray = new List<MethodWrapper[]>(baseMethods);
AddMirandaMethods(methodsArray, baseMethodsArray, wrapper);
methods = methodsArray.ToArray();
baseMethods = baseMethodsArray.ToArray();
}
if (!wrapper.IsInterface)
{
AddDelegateInvokeStubs(wrapper, ref methods);
}
wrapper.SetMethods(methods);
fields = new FieldWrapper[classFile.Fields.Length];
for (int i = 0; i < fields.Length; i++)
{
ClassFile.Field fld = classFile.Fields[i];
if (fld.IsStaticFinalConstant)
{
TypeWrapper fieldType = null;
#if !STATIC_COMPILER
fieldType = ClassLoaderWrapper.GetBootstrapClassLoader().FieldTypeWrapperFromSig(fld.Signature);
#endif
fields[i] = new ConstantFieldWrapper(wrapper, fieldType, fld.Name, fld.Signature, fld.Modifiers, null, fld.ConstantValue, MemberFlags.None);
}
else if (fld.IsProperty)
{
fields[i] = new DynamicPropertyFieldWrapper(wrapper, fld);
}
else
{
fields[i] = FieldWrapper.Create(wrapper, null, null, fld.Name, fld.Signature, new ExModifiers(fld.Modifiers, fld.IsInternal));
}
}
#if STATIC_COMPILER
wrapper.AddMapXmlFields(ref fields);
#endif
wrapper.SetFields(fields);
}
internal void CreateStep2()
{
#if STATIC_COMPILER
if (typeBuilder != null)
{
// in the static compiler we need to create the TypeBuilder from outer to inner
// and to avoid having to sort the classes this way, we instead call CreateStep2
// on demand for outer wrappers and this necessitates us to keep track of
// whether we've already been called
return;
}
#endif
// this method is not allowed to throw exceptions (if it does, the runtime will abort)
bool hasclinit = wrapper.HasStaticInitializer;
string mangledTypeName = wrapper.classLoader.GetTypeWrapperFactory().AllocMangledName(wrapper);
ClassFile f = classFile;
try
{
TypeAttributes typeAttribs = 0;
if (f.IsAbstract)
{
typeAttribs |= TypeAttributes.Abstract;
}
if (f.IsFinal)
{
typeAttribs |= TypeAttributes.Sealed;
}
if (!hasclinit)
{
typeAttribs |= TypeAttributes.BeforeFieldInit;
}
#if STATIC_COMPILER
bool cantNest = false;
bool setModifiers = false;
TypeBuilder outer = null;
// we only compile inner classes as nested types in the static compiler, because it has a higher cost
// and doesn't buy us anything in dynamic mode (and if fact, due to an FXBUG it would make handling
// the TypeResolve event very hard)
ClassFile.InnerClass outerClass = getOuterClass();
if (outerClass.outerClass != 0)
{
string outerClassName = classFile.GetConstantPoolClass(outerClass.outerClass);
if (!CheckInnerOuterNames(f.Name, outerClassName))
{
Tracer.Warning(Tracer.Compiler, "Incorrect InnerClasses attribute on {0}", f.Name);
}
else
{
try
{
outerClassWrapper = wrapper.classLoader.LoadClassByDottedNameFast(outerClassName) as DynamicTypeWrapper;
}
catch (RetargetableJavaException x)
{
Tracer.Warning(Tracer.Compiler, "Unable to load outer class {0} for inner class {1} ({2}: {3})", outerClassName, f.Name, x.GetType().Name, x.Message);
}
if (outerClassWrapper != null)
{
// make sure the relationship is reciprocal (otherwise we run the risk of
// baking the outer type before the inner type) and that the inner and outer
// class live in the same class loader (when doing a multi target compilation,
// it is possible to split the two classes acros assemblies)
JavaTypeImpl oimpl = outerClassWrapper.impl as JavaTypeImpl;
if (oimpl != null && outerClassWrapper.GetClassLoader() == wrapper.GetClassLoader())
{
ClassFile outerClassFile = oimpl.classFile;
ClassFile.InnerClass[] outerInnerClasses = outerClassFile.InnerClasses;
if (outerInnerClasses == null)
{
outerClassWrapper = null;
}
else
{
bool ok = false;
for (int i = 0; i < outerInnerClasses.Length; i++)
{
if (outerInnerClasses[i].outerClass != 0
&& outerClassFile.GetConstantPoolClass(outerInnerClasses[i].outerClass) == outerClassFile.Name
&& outerInnerClasses[i].innerClass != 0
&& outerClassFile.GetConstantPoolClass(outerInnerClasses[i].innerClass) == f.Name)
{
ok = true;
break;
}
}
if (!ok)
{
outerClassWrapper = null;
}
}
}
else
{
outerClassWrapper = null;
}
if (outerClassWrapper != null)
{
outerClassWrapper.CreateStep2();
outer = oimpl.typeBuilder;
}
else
{
Tracer.Warning(Tracer.Compiler, "Non-reciprocal inner class {0}", f.Name);
}
}
}
}
if (f.IsPublic)
{
if (outer != null)
{
if (outerClassWrapper.IsPublic)
{
typeAttribs |= TypeAttributes.NestedPublic;
}
else
{
// We're a public type nested inside a non-public type, this means that we can't compile this type as a nested type,
// because that would mean it wouldn't be visible outside the assembly.
cantNest = true;
typeAttribs |= TypeAttributes.Public;
}
}
else
{
typeAttribs |= TypeAttributes.Public;
}
}
else if (outer != null)
{
typeAttribs |= TypeAttributes.NestedAssembly;
}
#else // STATIC_COMPILER
if (f.IsPublic)
{
typeAttribs |= TypeAttributes.Public;
}
#endif // STATIC_COMPILER
if (f.IsInterface)
{
typeAttribs |= TypeAttributes.Interface | TypeAttributes.Abstract;
#if STATIC_COMPILER
// if any "meaningless" bits are set, preserve them
setModifiers |= (f.Modifiers & (Modifiers)0x99CE) != 0;
// by default we assume interfaces are abstract, so in the exceptional case we need a ModifiersAttribute
setModifiers |= (f.Modifiers & Modifiers.Abstract) == 0;
if (outer != null && !cantNest)
{
if (wrapper.IsGhost)
{
// TODO this is low priority, since the current Java class library doesn't define any ghost interfaces
// as inner classes
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)
{
typeBuilder = wrapper.DefineGhostType(mangledTypeName, typeAttribs);
}
else
{
typeBuilder = wrapper.classLoader.GetTypeWrapperFactory().ModuleBuilder.DefineType(mangledTypeName, typeAttribs);
}
}
#else // STATIC_COMPILER
typeBuilder = wrapper.classLoader.GetTypeWrapperFactory().ModuleBuilder.DefineType(mangledTypeName, typeAttribs);
#endif // STATIC_COMPILER
}
else
{
typeAttribs |= TypeAttributes.Class;
#if STATIC_COMPILER
// if any "meaningless" bits are set, preserve them
setModifiers |= (f.Modifiers & (Modifiers)0x99CE) != 0;
// by default we assume ACC_SUPER for classes, so in the exceptional case we need a ModifiersAttribute
setModifiers |= !f.IsSuper;
if (f.IsEffectivelyFinal)
{
setModifiers = true;
typeAttribs |= TypeAttributes.Sealed;
Tracer.Info(Tracer.Compiler, "Sealing type {0}", f.Name);
}
if (outer != null && !cantNest)
{
// 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
#endif // STATIC_COMPILER
{
typeBuilder = wrapper.classLoader.GetTypeWrapperFactory().ModuleBuilder.DefineType(mangledTypeName, typeAttribs);
}
}
#if STATIC_COMPILER
// When we're statically compiling, we associate the typeBuilder with the wrapper. This enables types in referenced assemblies to refer back to
// types that we're currently compiling (i.e. a cyclic dependency between the currently assembly we're compiling and a referenced assembly).
wrapper.GetClassLoader().SetWrapperForType(typeBuilder, wrapper);
if (outer != null && cantNest)
{
AttributeHelper.SetNonNestedOuterClass(typeBuilder, outerClassWrapper.Name);
AttributeHelper.SetNonNestedInnerClass(outer, f.Name);
}
if (outer == null && mangledTypeName != wrapper.Name)
{
// HACK we abuse the InnerClassAttribute to record to real name
AttributeHelper.SetInnerClass(typeBuilder, wrapper.Name, wrapper.Modifiers);
}
if (typeBuilder.FullName != wrapper.Name
&& wrapper.Name.Replace('$', '+') != typeBuilder.FullName)
{
wrapper.classLoader.AddNameMapping(wrapper.Name, typeBuilder.FullName);
}
if (f.IsAnnotation && Annotation.HasRetentionPolicyRuntime(f.Annotations))
{
annotationBuilder = new AnnotationBuilder(this, outer);
wrapper.SetAnnotation(annotationBuilder);
}
// For Java 5 Enum types, we generate a nested .NET enum.
// This is primarily to support annotations that take enum parameters.
if (f.IsEnum && f.IsPublic)
{
CompilerClassLoader ccl = wrapper.classLoader;
string name = "__Enum";
while (!ccl.ReserveName(f.Name + "$" + name))
{
name += "_";
}
enumBuilder = typeBuilder.DefineNestedType(name, TypeAttributes.Class | TypeAttributes.Sealed | TypeAttributes.NestedPublic | TypeAttributes.Serializable, Types.Enum);
AttributeHelper.HideFromJava(enumBuilder);
enumBuilder.DefineField("value__", Types.Int32, FieldAttributes.Public | FieldAttributes.SpecialName | FieldAttributes.RTSpecialName);
for (int i = 0; i < f.Fields.Length; i++)
{
if (f.Fields[i].IsEnum)
{
FieldBuilder fieldBuilder = enumBuilder.DefineField(f.Fields[i].Name, enumBuilder, FieldAttributes.Public | FieldAttributes.Static | FieldAttributes.Literal);
fieldBuilder.SetConstant(i);
}
}
wrapper.SetEnumType(enumBuilder);
}
TypeWrapper[] interfaces = wrapper.Interfaces;
string[] implements = new string[interfaces.Length];
for (int i = 0; i < implements.Length; i++)
{
implements[i] = interfaces[i].Name;
}
if (outer != null)
{
Modifiers innerClassModifiers = outerClass.accessFlags;
string innerClassName = classFile.GetConstantPoolClass(outerClass.innerClass);
if (innerClassName == classFile.Name && innerClassName == outerClassWrapper.Name + "$" + typeBuilder.Name)
{
innerClassName = null;
}
AttributeHelper.SetInnerClass(typeBuilder, innerClassName, innerClassModifiers);
}
else if (outerClass.innerClass != 0)
{
AttributeHelper.SetInnerClass(typeBuilder, null, outerClass.accessFlags);
}
AttributeHelper.SetImplementsAttribute(typeBuilder, interfaces);
if (classFile.DeprecatedAttribute)
{
AttributeHelper.SetDeprecatedAttribute(typeBuilder);
}
if (classFile.GenericSignature != null)
{
AttributeHelper.SetSignatureAttribute(typeBuilder, classFile.GenericSignature);
}
if (classFile.EnclosingMethod != null)
{
AttributeHelper.SetEnclosingMethodAttribute(typeBuilder, classFile.EnclosingMethod[0], classFile.EnclosingMethod[1], classFile.EnclosingMethod[2]);
}
if (wrapper.classLoader.EmitStackTraceInfo)
{
if (f.SourceFileAttribute != null)
{
if (f.SourceFileAttribute != typeBuilder.Name + ".java")
{
AttributeHelper.SetSourceFile(typeBuilder, f.SourceFileAttribute);
}
}
else
{
AttributeHelper.SetSourceFile(typeBuilder, null);
}
}
// NOTE in Whidbey we can (and should) use CompilerGeneratedAttribute to mark Synthetic types
if (setModifiers || classFile.IsInternal || (classFile.Modifiers & (Modifiers.Synthetic | Modifiers.Annotation | Modifiers.Enum)) != 0)
{
AttributeHelper.SetModifiers(typeBuilder, classFile.Modifiers, classFile.IsInternal);
}
#endif // STATIC_COMPILER
if (hasclinit)
{
// We create a empty method that we can use to trigger our .cctor
// (previously we used RuntimeHelpers.RunClassConstructor, but that is slow and requires additional privileges)
MethodAttributes attribs = MethodAttributes.Static | MethodAttributes.SpecialName;
if (classFile.IsAbstract)
{
bool hasfields = false;
// If we have any public static fields, the cctor trigger must (and may) be public as well
foreach (ClassFile.Field fld in classFile.Fields)
{
if (fld.IsPublic && fld.IsStatic)
{
hasfields = true;
break;
}
}
attribs |= hasfields ? MethodAttributes.Public : MethodAttributes.FamORAssem;
}
else
{
attribs |= MethodAttributes.Public;
}
clinitMethod = typeBuilder.DefineMethod("__<clinit>", attribs, null, null);
clinitMethod.GetILGenerator().Emit(OpCodes.Ret);
// FXBUG on .NET 2.0 RTM x64 the JIT sometimes throws an InvalidProgramException while trying to inline this method,
// so we prevent inlining for now (it also turns out that on x86 not inlining this method actually has a positive perf impact in some cases...)
// http://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=285772
clinitMethod.SetImplementationFlags(clinitMethod.GetMethodImplementationFlags() | MethodImplAttributes.NoInlining);
}
if (HasStructLayoutAttributeAnnotation(classFile))
{
// when we have a StructLayoutAttribute, field order is significant,
// so we link all fields here to make sure they are created in class file order.
foreach (FieldWrapper fw in fields)
{
fw.Link();
}
}
}
#if STATIC_COMPILER
finally { }
#else
catch (Exception x)
{
JVM.CriticalFailure("Exception during JavaTypeImpl.CreateStep2", x);
}
#endif
}
private sealed class DelegateConstructorMethodWrapper : MethodWrapper
{
private MethodBuilder constructor;
private MethodInfo invoke;
internal DelegateConstructorMethodWrapper(DynamicTypeWrapper tw, ClassFile.Method m)
: base(tw, m.Name, m.Signature, null, null, null, m.Modifiers, MemberFlags.None)
{
}
internal void DoLink(TypeBuilder typeBuilder)
{
MethodAttributes attribs = MethodAttributes.HideBySig | MethodAttributes.Public;
constructor = ReflectUtil.DefineConstructor(typeBuilder, attribs, new Type[] { Types.Object, Types.IntPtr });
constructor.SetImplementationFlags(MethodImplAttributes.Runtime);
MethodWrapper mw = GetParameters()[0].GetMethods()[0];
mw.Link();
invoke = (MethodInfo)mw.GetMethod();
}
internal override void EmitNewobj(CodeEmitter ilgen)
{
ilgen.Emit(OpCodes.Dup);
ilgen.Emit(OpCodes.Ldvirtftn, invoke);
ilgen.Emit(OpCodes.Newobj, constructor);
}
}
private static bool HasStructLayoutAttributeAnnotation(ClassFile c)
{
if (c.Annotations != null)
{
foreach (object[] annot in c.Annotations)
{
if ("Lcli/System/Runtime/InteropServices/StructLayoutAttribute$Annotation;".Equals(annot[1]))
{
return true;
}
}
}
return false;
}
#if STATIC_COMPILER
private ClassFile.InnerClass getOuterClass()
{
ClassFile.InnerClass[] innerClasses = classFile.InnerClasses;
if (innerClasses != null)
{
for (int j = 0; j < innerClasses.Length; j++)
{
if (innerClasses[j].innerClass != 0
&& classFile.GetConstantPoolClass(innerClasses[j].innerClass) == classFile.Name)
{
return innerClasses[j];
}
}
}
return new ClassFile.InnerClass();
}
private bool IsSideEffectFreeStaticInitializerOrNoop(ClassFile.Method m, out bool noop)
{
if (m.ExceptionTable.Length != 0)
{
noop = false;
return false;
}
noop = true;
for (int i = 0; i < m.Instructions.Length; i++)
{
NormalizedByteCode bc = m.Instructions[i].NormalizedOpCode;
if (bc == NormalizedByteCode.__getstatic || bc == NormalizedByteCode.__putstatic)
{
ClassFile.ConstantPoolItemFieldref fld = classFile.SafeGetFieldref(m.Instructions[i].Arg1);
if (fld == null || fld.Class != classFile.Name)
{
noop = false;
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 == NormalizedByteCode.__getstatic && "L[".IndexOf(fld.Signature[0]) != -1)
{
noop = false;
return false;
}
if (bc == NormalizedByteCode.__putstatic)
{
ClassFile.Field field = classFile.GetField(fld.Name, fld.Signature);
if (field == null)
{
noop = false;
return false;
}
if (!field.IsFinal || !field.IsStatic || !field.IsProperty || field.PropertySetter != null)
{
noop = false;
}
}
}
else if (bc == NormalizedByteCode.__areturn ||
bc == NormalizedByteCode.__ireturn ||
bc == NormalizedByteCode.__lreturn ||
bc == NormalizedByteCode.__freturn ||
bc == NormalizedByteCode.__dreturn)
{
noop = false;
return false;
}
else if (ByteCodeMetaData.CanThrowException(bc))
{
noop = false;
return false;
}
else if (bc == NormalizedByteCode.__aconst_null
|| bc == NormalizedByteCode.__return
|| bc == NormalizedByteCode.__nop)
{
// valid instructions in a potential noop <clinit>
}
else
{
noop = 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, wrapper.classLoader);
return true;
}
catch (VerifyError)
{
return false;
}
}
#endif // STATIC_COMPILER
private MethodWrapper GetMethodWrapperDuringCtor(TypeWrapper lookup, IList<MethodWrapper> methods, string name, string sig)
{
if (lookup == wrapper)
{
foreach (MethodWrapper mw in methods)
{
if (mw.Name == name && mw.Signature == sig)
{
return mw;
}
}
if (lookup.BaseTypeWrapper == null)
{
return null;
}
else
{
return lookup.BaseTypeWrapper.GetMethodWrapper(name, sig, true);
}
}
else
{
return lookup.GetMethodWrapper(name, sig, true);
}
}
private void AddMirandaMethods(List<MethodWrapper> methods, List<MethodWrapper[]> baseMethods, TypeWrapper tw)
{
foreach (TypeWrapper iface in tw.Interfaces)
{
if (iface.IsPublic && this.wrapper.IsInterface)
{
// for interfaces, we only need miranda methods for non-public interfaces that we extend
continue;
}
AddMirandaMethods(methods, baseMethods, iface);
foreach (MethodWrapper ifmethod in iface.GetMethods())
{
// skip <clinit>
if (!ifmethod.IsStatic)
{
TypeWrapper lookup = wrapper;
while (lookup != null)
{
MethodWrapper mw = GetMethodWrapperDuringCtor(lookup, methods, ifmethod.Name, ifmethod.Signature);
if (mw == null)
{
mw = new TypicalMethodWrapper(wrapper, ifmethod.Name, ifmethod.Signature, null, null, null, Modifiers.Public | Modifiers.Abstract, MemberFlags.HideFromReflection | MemberFlags.MirandaMethod);
methods.Add(mw);
baseMethods.Add(new MethodWrapper[] { ifmethod });
break;
}
if (!mw.IsStatic || mw.DeclaringType == wrapper)
{
break;
}
lookup = mw.DeclaringType.BaseTypeWrapper;
}
}
}
}
}
private void AddDelegateInvokeStubs(TypeWrapper tw, ref MethodWrapper[] methods)
{
foreach (TypeWrapper iface in tw.Interfaces)
{
if (iface.IsFakeNestedType
&& iface.GetMethods().Length == 1
&& iface.GetMethods()[0].IsDelegateInvokeWithByRefParameter)
{
MethodWrapper mw = new DelegateInvokeStubMethodWrapper(wrapper, iface.DeclaringTypeWrapper.TypeAsBaseType, iface.GetMethods()[0].Signature);
if (GetMethodWrapperDuringCtor(wrapper, methods, mw.Name, mw.Signature) == null)
{
Array.Resize(ref methods, methods.Length + 1);
methods[methods.Length - 1] = mw;
}
}
AddDelegateInvokeStubs(iface, ref methods);
}
}
private sealed class DelegateInvokeStubMethodWrapper : MethodWrapper
{
private readonly Type delegateType;
internal DelegateInvokeStubMethodWrapper(TypeWrapper declaringType, Type delegateType, string sig)
: base(declaringType, DotNetTypeWrapper.GetDelegateInvokeStubName(delegateType), sig, null, null, null, Modifiers.Public | Modifiers.Final, MemberFlags.HideFromReflection)
{
this.delegateType = delegateType;
}
internal MethodInfo DoLink(TypeBuilder tb)
{
MethodWrapper mw = this.DeclaringType.GetMethodWrapper("Invoke", this.Signature, true);
MethodInfo invoke = delegateType.GetMethod("Invoke");
ParameterInfo[] parameters = invoke.GetParameters();
Type[] parameterTypes = new Type[parameters.Length];
for (int i = 0; i < parameterTypes.Length; i++)
{
parameterTypes[i] = parameters[i].ParameterType;
}
MethodBuilder mb = tb.DefineMethod(this.Name, MethodAttributes.Public, invoke.ReturnType, parameterTypes);
AttributeHelper.HideFromReflection(mb);
CodeEmitter ilgen = CodeEmitter.Create(mb);
if (mw == null || mw.IsStatic || !mw.IsPublic)
{
ilgen.EmitThrow(mw == null || mw.IsStatic ? "java.lang.AbstractMethodError" : "java.lang.IllegalAccessError", DeclaringType.Name + ".Invoke" + Signature);
ilgen.DoEmit();
return mb;
}
CodeEmitterLocal[] byrefs = new CodeEmitterLocal[parameters.Length];
for (int i = 0; i < parameters.Length; i++)
{
if (parameters[i].ParameterType.IsByRef)
{
Type elemType = parameters[i].ParameterType.GetElementType();
CodeEmitterLocal local = ilgen.DeclareLocal(ArrayTypeWrapper.MakeArrayType(elemType, 1));
byrefs[i] = local;
ilgen.Emit(OpCodes.Ldc_I4_1);
ilgen.Emit(OpCodes.Newarr, elemType);
ilgen.Emit(OpCodes.Stloc, local);
ilgen.Emit(OpCodes.Ldloc, local);
ilgen.Emit(OpCodes.Ldc_I4_0);
ilgen.EmitLdarg(i + 1);
ilgen.Emit(OpCodes.Ldobj, elemType);
ilgen.Emit(OpCodes.Stelem, elemType);
}
}
ilgen.BeginExceptionBlock();
ilgen.Emit(OpCodes.Ldarg_0);
for (int i = 0; i < parameters.Length; i++)
{
if (byrefs[i] != null)
{
ilgen.Emit(OpCodes.Ldloc, byrefs[i]);
}
else
{
ilgen.EmitLdarg(i + 1);
}
}
mw.Link();
mw.EmitCallvirt(ilgen);
CodeEmitterLocal returnValue = null;
if (mw.ReturnType != PrimitiveTypeWrapper.VOID)
{
returnValue = ilgen.DeclareLocal(mw.ReturnType.TypeAsSignatureType);
ilgen.Emit(OpCodes.Stloc, returnValue);
}
CodeEmitterLabel exit = ilgen.DefineLabel();
ilgen.EmitLeave(exit);
ilgen.BeginFinallyBlock();
for (int i = 0; i < parameters.Length; i++)
{
if (byrefs[i] != null)
{
Type elemType = byrefs[i].LocalType.GetElementType();
ilgen.EmitLdarg(i + 1);
ilgen.Emit(OpCodes.Ldloc, byrefs[i]);
ilgen.Emit(OpCodes.Ldc_I4_0);
ilgen.Emit(OpCodes.Ldelem, elemType);
ilgen.Emit(OpCodes.Stobj, elemType);
}
}
ilgen.Emit(OpCodes.Endfinally);
ilgen.EndExceptionBlock();
ilgen.MarkLabel(exit);
if (returnValue != null)
{
ilgen.Emit(OpCodes.Ldloc, returnValue);
}
ilgen.Emit(OpCodes.Ret);
ilgen.DoEmit();
return mb;
}
}
#if STATIC_COMPILER
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.StartsWith(outer);
}
private string GetInnerClassName(string outer, string inner)
{
Debug.Assert(CheckInnerOuterNames(inner, outer));
if (nestedTypeNames == null)
{
nestedTypeNames = new Dictionary<string, TypeWrapper>();
}
return DynamicClassLoader.TypeNameMangleImpl(nestedTypeNames, inner.Substring(outer.Length + 1), null);
}
#endif // STATIC_COMPILER
private int GetMethodIndex(MethodWrapper mw)
{
for (int i = 0; i < methods.Length; i++)
{
if (methods[i] == mw)
{
return i;
}
}
throw new InvalidOperationException();
}
private static void CheckLoaderConstraints(MethodWrapper mw, MethodWrapper baseMethod)
{
#if !STATIC_COMPILER
if (JVM.FinishingForDebugSave)
{
// when we're finishing types to save a debug image (in dynamic mode) we don't care about loader constraints anymore
// (and we can't throw a LinkageError, because that would prevent the debug image from being saved)
return;
}
#endif
if (mw.ReturnType != baseMethod.ReturnType)
{
if (mw.ReturnType.IsUnloadable || baseMethod.ReturnType.IsUnloadable)
{
// unloadable types can never cause a loader constraint violation
if (mw.ReturnType.IsUnloadable && baseMethod.ReturnType.IsUnloadable)
{
((UnloadableTypeWrapper)mw.ReturnType).SetCustomModifier(((UnloadableTypeWrapper)baseMethod.ReturnType).CustomModifier);
}
}
else
{
#if STATIC_COMPILER
StaticCompiler.LinkageError("Method \"{2}.{3}{4}\" has a return type \"{0}\" and tries to override method \"{5}.{3}{4}\" that has a return type \"{1}\"", mw.ReturnType, baseMethod.ReturnType, mw.DeclaringType.Name, mw.Name, mw.Signature, baseMethod.DeclaringType.Name);
#endif
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 (here[i].IsUnloadable || there[i].IsUnloadable)
{
// unloadable types can never cause a loader constraint violation
if (here[i].IsUnloadable && there[i].IsUnloadable)
{
((UnloadableTypeWrapper)here[i]).SetCustomModifier(((UnloadableTypeWrapper)there[i]).CustomModifier);
}
}
else
{
#if STATIC_COMPILER
StaticCompiler.LinkageError("Method \"{2}.{3}{4}\" has an argument type \"{0}\" and tries to override method \"{5}.{3}{4}\" that has an argument type \"{1}\"", here[i], there[i], mw.DeclaringType.Name, mw.Name, mw.Signature, baseMethod.DeclaringType.Name);
#endif
throw new LinkageError("Loader constraints violated");
}
}
}
}
private int GetFieldIndex(FieldWrapper fw)
{
for (int i = 0; i < fields.Length; i++)
{
if (fields[i] == fw)
{
return i;
}
}
throw new InvalidOperationException();
}
internal override FieldInfo LinkField(FieldWrapper fw)
{
if (fw is DynamicPropertyFieldWrapper)
{
((DynamicPropertyFieldWrapper)fw).DoLink(typeBuilder);
return null;
}
int fieldIndex = GetFieldIndex(fw);
#if STATIC_COMPILER
// for compatibility with broken Java code that assumes that reflection returns the fields in class declaration
// order, we emit the fields in class declaration order in the .NET metadata (and then when we retrieve them
// using .NET reflection, we sort on metadata token.)
if (fieldIndex > 0)
{
if (!fields[fieldIndex - 1].IsLinked)
{
for (int i = 0; i < fieldIndex; i++)
{
fields[i].Link();
}
}
}
if (fieldIndex >= classFile.Fields.Length)
{
// this must be a field defined in map.xml
FieldAttributes fieldAttribs = 0;
if (fw.IsPublic)
{
fieldAttribs |= FieldAttributes.Public;
}
else if (fw.IsProtected)
{
fieldAttribs |= FieldAttributes.FamORAssem;
}
else if (fw.IsPrivate)
{
fieldAttribs |= FieldAttributes.Private;
}
else
{
fieldAttribs |= FieldAttributes.Assembly;
}
if (fw.IsStatic)
{
fieldAttribs |= FieldAttributes.Static;
}
if (fw.IsFinal)
{
fieldAttribs |= FieldAttributes.InitOnly;
}
return DefineField(fw.Name, fw.FieldTypeWrapper, fieldAttribs, fw.IsVolatile);
}
#endif // STATIC_COMPILER
FieldBuilder field;
ClassFile.Field fld = classFile.Fields[fieldIndex];
string realFieldName = fld.Name;
FieldAttributes attribs = 0;
MethodAttributes methodAttribs = MethodAttributes.HideBySig;
#if STATIC_COMPILER
bool setModifiers = fld.IsInternal || (fld.Modifiers & (Modifiers.Synthetic | Modifiers.Enum)) != 0;
#endif
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)
if (fld.IsStaticFinalConstant)
{
Profiler.Count("Static Final Constant");
attribs |= FieldAttributes.Literal;
field = DefineField(fld.Name, fw.FieldTypeWrapper, attribs, false);
field.SetConstant(fld.ConstantValue);
}
else
{
#if STATIC_COMPILER
if (wrapper.IsPublic && wrapper.NeedsType2AccessStub(fw))
{
// this field is going to get a type 2 access stub, so we hide the actual field
attribs &= ~FieldAttributes.FieldAccessMask;
attribs |= FieldAttributes.Assembly;
// instead of adding HideFromJava we rename the field to avoid confusing broken compilers
// see https://sourceforge.net/tracker/?func=detail&atid=525264&aid=3056721&group_id=69637
// additional note: now that we maintain the ordering of the fields, we need to recognize
// these fields so that we know where to insert the corresponding accessor property FieldWrapper.
realFieldName = NamePrefix.Type2AccessStubBackingField + fld.Name;
}
else if (fld.IsFinal)
{
if (wrapper.IsInterface || wrapper.classLoader.StrictFinalFieldSemantics)
{
attribs |= FieldAttributes.InitOnly;
}
else
{
setModifiers = true;
}
}
#else
if (fld.IsFinal && wrapper.IsInterface)
{
attribs |= FieldAttributes.InitOnly;
}
#endif
field = DefineField(realFieldName, fw.FieldTypeWrapper, attribs, fld.IsVolatile);
}
if (fld.IsTransient)
{
CustomAttributeBuilder transientAttrib = new CustomAttributeBuilder(JVM.Import(typeof(NonSerializedAttribute)).GetConstructor(Type.EmptyTypes), new object[0]);
field.SetCustomAttribute(transientAttrib);
}
#if STATIC_COMPILER
{
// 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, fld.IsInternal);
}
if (fld.DeprecatedAttribute)
{
AttributeHelper.SetDeprecatedAttribute(field);
}
if (fld.GenericSignature != null)
{
AttributeHelper.SetSignatureAttribute(field, fld.GenericSignature);
}
}
#endif // STATIC_COMPILER
return field;
}
private FieldBuilder DefineField(string name, TypeWrapper tw, FieldAttributes attribs, bool isVolatile)
{
Type[] modreq = isVolatile ? new Type[] { Types.IsVolatile } : Type.EmptyTypes;
return typeBuilder.DefineField(name, tw.TypeAsSignatureType, modreq, wrapper.GetModOpt(tw, false), attribs);
}
internal override void EmitRunClassConstructor(CodeEmitter ilgen)
{
if (clinitMethod != null)
{
ilgen.Emit(OpCodes.Call, clinitMethod);
}
}
internal override DynamicImpl Finish()
{
if (wrapper.BaseTypeWrapper != null)
{
wrapper.BaseTypeWrapper.Finish();
}
// 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();
}
// 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);
for (int i = 0; i < fields.Length; i++)
{
fields[i].Link();
}
for (int i = 0; i < methods.Length; i++)
{
methods[i].Link();
}
// this is the correct lock, FinishCore doesn't call any user code and mutates global state,
// so it needs to be protected by a lock.
lock (this)
{
FinishedTypeImpl impl;
try
{
// call FinishCore in the finally to avoid Thread.Abort interrupting the thread
}
finally
{
impl = FinishCore();
}
return impl;
}
}
private FinishedTypeImpl FinishCore()
{
// 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;
}
if (finishInProgress)
{
throw new InvalidOperationException("Recursive finish attempt for " + wrapper.Name);
}
finishInProgress = true;
Tracer.Info(Tracer.Compiler, "Finishing: {0}", wrapper.Name);
Profiler.Enter("JavaTypeImpl.Finish.Core");
try
{
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
List<TypeWrapper> wrappers = new List<TypeWrapper>();
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);
}
}
}
innerClassesTypeWrappers = wrappers.ToArray();
#if STATIC_COMPILER
// before we bake our type, we need to link any inner annotations to allow them to create their attribute type (as a nested type)
foreach (TypeWrapper tw in innerClassesTypeWrappers)
{
DynamicTypeWrapper dtw = tw as DynamicTypeWrapper;
if (dtw != null)
{
JavaTypeImpl impl = dtw.impl as JavaTypeImpl;
if (impl != null)
{
if (impl.annotationBuilder != null)
{
impl.annotationBuilder.Link();
}
}
}
}
#endif //STATIC_COMPILER
}
#if STATIC_COMPILER
if (annotationBuilder != null)
{
CustomAttributeBuilder cab = new CustomAttributeBuilder(JVM.LoadType(typeof(AnnotationAttributeAttribute)).GetConstructor(new Type[] { Types.String }), new object[] { annotationBuilder.AttributeTypeName });
typeBuilder.SetCustomAttribute(cab);
}
if (!wrapper.IsInterface && wrapper.IsMapUnsafeException)
{
// mark all exceptions that are unsafe for mapping with a custom attribute,
// so that at runtime we can quickly assertain if an exception type can be
// caught without filtering
AttributeHelper.SetExceptionIsUnsafeForMapping(typeBuilder);
}
#endif
FinishContext context = new FinishContext(classFile, wrapper, typeBuilder);
Type type = context.FinishImpl();
#if STATIC_COMPILER
if (annotationBuilder != null)
{
annotationBuilder.Finish(this);
}
if (enumBuilder != null)
{
enumBuilder.CreateType();
}
#endif
MethodInfo finishedClinitMethod = clinitMethod;
#if !STATIC_COMPILER
if (finishedClinitMethod != null)
{
// In dynamic mode, we may need to emit a call to this method from a DynamicMethod which doesn't support calling unfinished methods,
// so we must resolve to the real method here.
finishedClinitMethod = type.GetMethod("__<clinit>", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
}
#endif
finishedType = new FinishedTypeImpl(type, innerClassesTypeWrappers, declaringTypeWrapper, wrapper.ReflectiveModifiers, Metadata.Create(classFile), finishedClinitMethod, finalizeMethod);
return finishedType;
}
#if !STATIC_COMPILER
catch (Exception x)
{
JVM.CriticalFailure("Exception during finishing of: " + wrapper.Name, x);
return null;
}
#endif
finally
{
Profiler.Leave("JavaTypeImpl.Finish.Core");
}
}
#if STATIC_COMPILER
private bool IsValidAnnotationElementType(string type)
{
if (type[0] == '[')
{
type = type.Substring(1);
}
switch (type)
{
case "Z":
case "B":
case "S":
case "C":
case "I":
case "J":
case "F":
case "D":
case "Ljava.lang.String;":
case "Ljava.lang.Class;":
return true;
}
if (type.StartsWith("L") && type.EndsWith(";"))
{
try
{
TypeWrapper tw = wrapper.GetClassLoader().LoadClassByDottedNameFast(type.Substring(1, type.Length - 2));
if (tw != null)
{
if ((tw.Modifiers & Modifiers.Annotation) != 0)
{
return true;
}
if ((tw.Modifiers & Modifiers.Enum) != 0)
{
TypeWrapper enumType = ClassLoaderWrapper.GetBootstrapClassLoader().LoadClassByDottedNameFast("java.lang.Enum");
if (enumType != null && tw.IsSubTypeOf(enumType))
{
return true;
}
}
}
}
catch
{
}
}
return false;
}
sealed class AnnotationBuilder : Annotation
{
private JavaTypeImpl impl;
private TypeBuilder outer;
private TypeBuilder annotationTypeBuilder;
private TypeBuilder attributeTypeBuilder;
private MethodBuilder defineConstructor;
internal AnnotationBuilder(JavaTypeImpl o, TypeBuilder outer)
{
this.impl = o;
this.outer = outer;
}
internal void Link()
{
if (impl == null)
{
return;
}
JavaTypeImpl o = impl;
impl = null;
// Make sure the annotation type only has valid methods
for (int i = 0; i < o.methods.Length; i++)
{
if (!o.methods[i].IsStatic)
{
if (!o.methods[i].Signature.StartsWith("()"))
{
return;
}
if (!o.IsValidAnnotationElementType(o.methods[i].Signature.Substring(2)))
{
return;
}
}
}
// we only set annotationTypeBuilder if we're valid
annotationTypeBuilder = o.typeBuilder;
TypeWrapper annotationAttributeBaseType = ClassLoaderWrapper.LoadClassCritical("ikvm.internal.AnnotationAttributeBase");
// make sure we don't clash with another class name
CompilerClassLoader ccl = o.wrapper.classLoader;
string name = o.classFile.Name;
while (!ccl.ReserveName(name + "Attribute"))
{
name += "_";
}
TypeAttributes typeAttributes = TypeAttributes.Class | TypeAttributes.Sealed;
if (o.outerClassWrapper != null)
{
if (o.wrapper.IsPublic)
{
typeAttributes |= TypeAttributes.NestedPublic;
}
else
{
typeAttributes |= TypeAttributes.NestedAssembly;
}
attributeTypeBuilder = outer.DefineNestedType(o.GetInnerClassName(o.outerClassWrapper.Name, name + "Attribute"), typeAttributes, annotationAttributeBaseType.TypeAsBaseType);
}
else
{
if (o.wrapper.IsPublic)
{
typeAttributes |= TypeAttributes.Public;
}
else
{
typeAttributes |= TypeAttributes.NotPublic;
}
attributeTypeBuilder = o.wrapper.classLoader.GetTypeWrapperFactory().ModuleBuilder.DefineType(name + "Attribute", typeAttributes, annotationAttributeBaseType.TypeAsBaseType);
}
if (o.wrapper.IsPublic)
{
// In the Java world, the class appears as a non-public proxy class
AttributeHelper.SetModifiers(attributeTypeBuilder, Modifiers.Final, false);
}
// NOTE we "abuse" the InnerClassAttribute to add a custom attribute to name the class "$Proxy[Annotation]" in the Java world
int dotindex = o.classFile.Name.LastIndexOf('.') + 1;
AttributeHelper.SetInnerClass(attributeTypeBuilder, o.classFile.Name.Substring(0, dotindex) + "$Proxy" + o.classFile.Name.Substring(dotindex), Modifiers.Final);
attributeTypeBuilder.AddInterfaceImplementation(o.typeBuilder);
AttributeHelper.SetImplementsAttribute(attributeTypeBuilder, new TypeWrapper[] { o.wrapper });
if (o.classFile.Annotations != null)
{
CustomAttributeBuilder attributeUsageAttribute = null;
bool hasAttributeUsageAttribute = false;
foreach (object[] def in o.classFile.Annotations)
{
if (def[1].Equals("Ljava/lang/annotation/Target;") && !hasAttributeUsageAttribute)
{
for (int i = 2; i < def.Length; i += 2)
{
if (def[i].Equals("value"))
{
object[] val = def[i + 1] as object[];
if (val != null
&& val.Length > 0
&& val[0].Equals(AnnotationDefaultAttribute.TAG_ARRAY))
{
AttributeTargets targets = 0;
for (int j = 1; j < val.Length; j++)
{
object[] eval = val[j] as object[];
if (eval != null
&& eval.Length == 3
&& eval[0].Equals(AnnotationDefaultAttribute.TAG_ENUM)
&& eval[1].Equals("Ljava/lang/annotation/ElementType;"))
{
switch ((string)eval[2])
{
case "ANNOTATION_TYPE":
targets |= AttributeTargets.Interface;
break;
case "CONSTRUCTOR":
targets |= AttributeTargets.Constructor;
break;
case "FIELD":
targets |= AttributeTargets.Field;
break;
case "LOCAL_VARIABLE":
break;
case "METHOD":
targets |= AttributeTargets.Method;
break;
case "PACKAGE":
targets |= AttributeTargets.Interface;
break;
case "PARAMETER":
targets |= AttributeTargets.Parameter;
break;
case "TYPE":
targets |= AttributeTargets.Class | AttributeTargets.Interface | AttributeTargets.Struct | AttributeTargets.Delegate | AttributeTargets.Enum;
break;
}
}
}
attributeUsageAttribute = new CustomAttributeBuilder(JVM.Import(typeof(AttributeUsageAttribute)).GetConstructor(new Type[] { JVM.Import(typeof(AttributeTargets)) }), new object[] { targets });
}
}
}
}
else
{
// apply any .NET custom attributes that are on the annotation to the custom attribute we synthesize
// (for example, to allow AttributeUsageAttribute to be overridden)
Annotation annotation = Annotation.Load(o.wrapper.GetClassLoader(), def);
if (annotation != null && annotation.IsCustomAttribute)
{
annotation.Apply(o.wrapper.GetClassLoader(), attributeTypeBuilder, def);
}
if (def[1].Equals("Lcli/System/AttributeUsageAttribute$Annotation;"))
{
hasAttributeUsageAttribute = true;
}
}
}
if (attributeUsageAttribute != null && !hasAttributeUsageAttribute)
{
attributeTypeBuilder.SetCustomAttribute(attributeUsageAttribute);
}
}
defineConstructor = ReflectUtil.DefineConstructor(attributeTypeBuilder, MethodAttributes.Public, new Type[] { JVM.Import(typeof(object[])) });
AttributeHelper.SetEditorBrowsableNever(defineConstructor);
}
private static Type TypeWrapperToAnnotationParameterType(TypeWrapper tw)
{
bool isArray = false;
if (tw.IsArray)
{
isArray = true;
tw = tw.ElementTypeWrapper;
}
if (tw.Annotation != null)
{
// we don't support Annotation args
return null;
}
else
{
Type argType;
if (tw == CoreClasses.java.lang.Class.Wrapper)
{
argType = Types.Type;
}
else if (tw.EnumType != null)
{
argType = tw.EnumType;
}
else
{
argType = tw.TypeAsSignatureType;
}
if (isArray)
{
argType = ArrayTypeWrapper.MakeArrayType(argType, 1);
}
return argType;
}
}
internal string AttributeTypeName
{
get
{
Link();
if (attributeTypeBuilder != null)
{
return attributeTypeBuilder.FullName;
}
return null;
}
}
private static void EmitSetValueCall(TypeWrapper annotationAttributeBaseType, CodeEmitter ilgen, string name, TypeWrapper tw, int argIndex)
{
ilgen.Emit(OpCodes.Ldarg_0);
ilgen.Emit(OpCodes.Ldstr, name);
ilgen.EmitLdarg(argIndex);
if (tw.TypeAsSignatureType.IsValueType)
{
ilgen.Emit(OpCodes.Box, tw.TypeAsSignatureType);
}
else if (tw.EnumType != null)
{
ilgen.Emit(OpCodes.Box, tw.EnumType);
}
MethodWrapper setValueMethod = annotationAttributeBaseType.GetMethodWrapper("setValue", "(Ljava.lang.String;Ljava.lang.Object;)V", false);
setValueMethod.Link();
setValueMethod.EmitCall(ilgen);
}
internal void Finish(JavaTypeImpl o)
{
Link();
if (annotationTypeBuilder == null)
{
// not a valid annotation type
return;
}
TypeWrapper annotationAttributeBaseType = ClassLoaderWrapper.LoadClassCritical("ikvm.internal.AnnotationAttributeBase");
annotationAttributeBaseType.Finish();
int requiredArgCount = 0;
int valueArg = -1;
bool unsupported = false;
for (int i = 0; i < o.methods.Length; i++)
{
if (!o.methods[i].IsStatic)
{
if (valueArg == -1 && o.methods[i].Name == "value")
{
valueArg = i;
}
if (o.classFile.Methods[i].AnnotationDefault == null)
{
if (TypeWrapperToAnnotationParameterType(o.methods[i].ReturnType) == null)
{
unsupported = true;
break;
}
requiredArgCount++;
}
}
}
MethodBuilder defaultConstructor = ReflectUtil.DefineConstructor(attributeTypeBuilder, unsupported || requiredArgCount > 0 ? MethodAttributes.Private : MethodAttributes.Public, Type.EmptyTypes);
CodeEmitter ilgen;
if (!unsupported)
{
if (requiredArgCount > 0)
{
Type[] args = new Type[requiredArgCount];
for (int i = 0, j = 0; i < o.methods.Length; i++)
{
if (!o.methods[i].IsStatic)
{
if (o.classFile.Methods[i].AnnotationDefault == null)
{
args[j++] = TypeWrapperToAnnotationParameterType(o.methods[i].ReturnType);
}
}
}
MethodBuilder reqArgConstructor = ReflectUtil.DefineConstructor(attributeTypeBuilder, MethodAttributes.Public, args);
AttributeHelper.HideFromJava(reqArgConstructor);
ilgen = CodeEmitter.Create(reqArgConstructor);
ilgen.Emit(OpCodes.Ldarg_0);
ilgen.Emit(OpCodes.Call, defaultConstructor);
for (int i = 0, j = 0; i < o.methods.Length; i++)
{
if (!o.methods[i].IsStatic)
{
if (o.classFile.Methods[i].AnnotationDefault == null)
{
reqArgConstructor.DefineParameter(++j, ParameterAttributes.None, o.methods[i].Name);
EmitSetValueCall(annotationAttributeBaseType, ilgen, o.methods[i].Name, o.methods[i].ReturnType, j);
}
}
}
ilgen.Emit(OpCodes.Ret);
ilgen.DoEmit();
}
else if (valueArg != -1)
{
// We don't have any required parameters, but we do have an optional "value" parameter,
// so we create an additional constructor (the default constructor will be public in this case)
// that accepts the value parameter.
Type argType = TypeWrapperToAnnotationParameterType(o.methods[valueArg].ReturnType);
if (argType != null)
{
MethodBuilder cb = ReflectUtil.DefineConstructor(attributeTypeBuilder, MethodAttributes.Public, new Type[] { argType });
AttributeHelper.HideFromJava(cb);
cb.DefineParameter(1, ParameterAttributes.None, "value");
ilgen = CodeEmitter.Create(cb);
ilgen.Emit(OpCodes.Ldarg_0);
ilgen.Emit(OpCodes.Call, defaultConstructor);
EmitSetValueCall(annotationAttributeBaseType, ilgen, "value", o.methods[valueArg].ReturnType, 1);
ilgen.Emit(OpCodes.Ret);
ilgen.DoEmit();
}
}
}
ilgen = CodeEmitter.Create(defaultConstructor);
ilgen.Emit(OpCodes.Ldarg_0);
o.wrapper.EmitClassLiteral(ilgen);
annotationAttributeBaseType.GetMethodWrapper("<init>", "(Ljava.lang.Class;)V", false).EmitCall(ilgen);
ilgen.Emit(OpCodes.Ret);
ilgen.DoEmit();
ilgen = CodeEmitter.Create(defineConstructor);
ilgen.Emit(OpCodes.Ldarg_0);
ilgen.Emit(OpCodes.Call, defaultConstructor);
ilgen.Emit(OpCodes.Ldarg_0);
ilgen.Emit(OpCodes.Ldarg_1);
annotationAttributeBaseType.GetMethodWrapper("setDefinition", "([Ljava.lang.Object;)V", false).EmitCall(ilgen);
ilgen.Emit(OpCodes.Ret);
ilgen.DoEmit();
MethodWrapper getValueMethod = annotationAttributeBaseType.GetMethodWrapper("getValue", "(Ljava.lang.String;)Ljava.lang.Object;", false);
MethodWrapper getByteValueMethod = annotationAttributeBaseType.GetMethodWrapper("getByteValue", "(Ljava.lang.String;)B", false);
MethodWrapper getBooleanValueMethod = annotationAttributeBaseType.GetMethodWrapper("getBooleanValue", "(Ljava.lang.String;)Z", false);
MethodWrapper getCharValueMethod = annotationAttributeBaseType.GetMethodWrapper("getCharValue", "(Ljava.lang.String;)C", false);
MethodWrapper getShortValueMethod = annotationAttributeBaseType.GetMethodWrapper("getShortValue", "(Ljava.lang.String;)S", false);
MethodWrapper getIntValueMethod = annotationAttributeBaseType.GetMethodWrapper("getIntValue", "(Ljava.lang.String;)I", false);
MethodWrapper getFloatValueMethod = annotationAttributeBaseType.GetMethodWrapper("getFloatValue", "(Ljava.lang.String;)F", false);
MethodWrapper getLongValueMethod = annotationAttributeBaseType.GetMethodWrapper("getLongValue", "(Ljava.lang.String;)J", false);
MethodWrapper getDoubleValueMethod = annotationAttributeBaseType.GetMethodWrapper("getDoubleValue", "(Ljava.lang.String;)D", false);
for (int i = 0; i < o.methods.Length; i++)
{
// skip <clinit>
if (!o.methods[i].IsStatic)
{
MethodBuilder mb = o.methods[i].GetDefineMethodHelper().DefineMethod(o.wrapper, attributeTypeBuilder, o.methods[i].Name, MethodAttributes.Private | MethodAttributes.Virtual | MethodAttributes.Final | MethodAttributes.NewSlot);
attributeTypeBuilder.DefineMethodOverride(mb, (MethodInfo)o.methods[i].GetMethod());
ilgen = CodeEmitter.Create(mb);
ilgen.Emit(OpCodes.Ldarg_0);
ilgen.Emit(OpCodes.Ldstr, o.methods[i].Name);
if (o.methods[i].ReturnType.IsPrimitive)
{
if (o.methods[i].ReturnType == PrimitiveTypeWrapper.BYTE)
{
getByteValueMethod.EmitCall(ilgen);
}
else if (o.methods[i].ReturnType == PrimitiveTypeWrapper.BOOLEAN)
{
getBooleanValueMethod.EmitCall(ilgen);
}
else if (o.methods[i].ReturnType == PrimitiveTypeWrapper.CHAR)
{
getCharValueMethod.EmitCall(ilgen);
}
else if (o.methods[i].ReturnType == PrimitiveTypeWrapper.SHORT)
{
getShortValueMethod.EmitCall(ilgen);
}
else if (o.methods[i].ReturnType == PrimitiveTypeWrapper.INT)
{
getIntValueMethod.EmitCall(ilgen);
}
else if (o.methods[i].ReturnType == PrimitiveTypeWrapper.FLOAT)
{
getFloatValueMethod.EmitCall(ilgen);
}
else if (o.methods[i].ReturnType == PrimitiveTypeWrapper.LONG)
{
getLongValueMethod.EmitCall(ilgen);
}
else if (o.methods[i].ReturnType == PrimitiveTypeWrapper.DOUBLE)
{
getDoubleValueMethod.EmitCall(ilgen);
}
else
{
throw new InvalidOperationException();
}
}
else
{
getValueMethod.EmitCall(ilgen);
o.methods[i].ReturnType.EmitCheckcast(null, ilgen);
}
ilgen.Emit(OpCodes.Ret);
ilgen.DoEmit();
if (o.classFile.Methods[i].AnnotationDefault != null
&& !(o.methods[i].Name == "value" && requiredArgCount == 0))
{
// now add a .NET property for this annotation optional parameter
Type argType = TypeWrapperToAnnotationParameterType(o.methods[i].ReturnType);
if (argType != null)
{
PropertyBuilder pb = attributeTypeBuilder.DefineProperty(o.methods[i].Name, PropertyAttributes.None, argType, Type.EmptyTypes);
AttributeHelper.HideFromJava(pb);
MethodBuilder setter = attributeTypeBuilder.DefineMethod("set_" + o.methods[i].Name, MethodAttributes.Public, Types.Void, new Type[] { argType });
AttributeHelper.HideFromJava(setter);
pb.SetSetMethod(setter);
ilgen = CodeEmitter.Create(setter);
EmitSetValueCall(annotationAttributeBaseType, ilgen, o.methods[i].Name, o.methods[i].ReturnType, 1);
ilgen.Emit(OpCodes.Ret);
ilgen.DoEmit();
MethodBuilder getter = attributeTypeBuilder.DefineMethod("get_" + o.methods[i].Name, MethodAttributes.Public, argType, Type.EmptyTypes);
AttributeHelper.HideFromJava(getter);
pb.SetGetMethod(getter);
// TODO implement the getter method
ilgen = CodeEmitter.Create(getter);
ilgen.ThrowException(JVM.Import(typeof(NotImplementedException)));
ilgen.DoEmit();
}
}
}
}
attributeTypeBuilder.CreateType();
}
internal override void Apply(ClassLoaderWrapper loader, TypeBuilder tb, object annotation)
{
Link();
if (annotationTypeBuilder != null)
{
annotation = QualifyClassNames(loader, annotation);
tb.SetCustomAttribute(new CustomAttributeBuilder(defineConstructor.__AsConstructorInfo(), new object[] { annotation }));
}
}
internal override void Apply(ClassLoaderWrapper loader, MethodBuilder mb, object annotation)
{
Link();
if (annotationTypeBuilder != null)
{
annotation = QualifyClassNames(loader, annotation);
mb.SetCustomAttribute(new CustomAttributeBuilder(defineConstructor.__AsConstructorInfo(), new object[] { annotation }));
}
}
internal override void Apply(ClassLoaderWrapper loader, FieldBuilder fb, object annotation)
{
Link();
if (annotationTypeBuilder != null)
{
annotation = QualifyClassNames(loader, annotation);
fb.SetCustomAttribute(new CustomAttributeBuilder(defineConstructor.__AsConstructorInfo(), new object[] { annotation }));
}
}
internal override void Apply(ClassLoaderWrapper loader, ParameterBuilder pb, object annotation)
{
Link();
if (annotationTypeBuilder != null)
{
annotation = QualifyClassNames(loader, annotation);
pb.SetCustomAttribute(new CustomAttributeBuilder(defineConstructor.__AsConstructorInfo(), new object[] { annotation }));
}
}
internal override void Apply(ClassLoaderWrapper loader, AssemblyBuilder ab, object annotation)
{
Link();
if (annotationTypeBuilder != null)
{
annotation = QualifyClassNames(loader, annotation);
ab.SetCustomAttribute(new CustomAttributeBuilder(defineConstructor.__AsConstructorInfo(), new object[] { annotation }));
}
}
internal override void Apply(ClassLoaderWrapper loader, PropertyBuilder pb, object annotation)
{
Link();
if (annotationTypeBuilder != null)
{
annotation = QualifyClassNames(loader, annotation);
pb.SetCustomAttribute(new CustomAttributeBuilder(defineConstructor.__AsConstructorInfo(), new object[] { annotation }));
}
}
internal override bool IsCustomAttribute
{
get { return false; }
}
}
#endif // STATIC_COMPILER
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
{
Modifiers mods;
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)
{
// the mask comes from RECOGNIZED_INNER_CLASS_MODIFIERS in src/hotspot/share/vm/classfile/classFileParser.cpp
// (minus ACC_SUPER)
mods = innerclasses[i].accessFlags & (Modifiers)0x761F;
if (classFile.IsInterface)
{
mods |= Modifiers.Abstract;
}
return mods;
}
}
}
}
// the mask comes from JVM_RECOGNIZED_CLASS_MODIFIERS in src/hotspot/share/vm/prims/jvm.h
// (minus ACC_SUPER)
mods = classFile.Modifiers & (Modifiers)0x7611;
if (classFile.IsInterface)
{
mods |= Modifiers.Abstract;
}
return mods;
}
}
// this finds all methods that the specified name/sig is going to be overriding
private MethodWrapper[] FindBaseMethods(ClassFile.Method m, out bool explicitOverride)
{
Debug.Assert(!classFile.IsInterface);
Debug.Assert(m.Name != "<init>");
// starting with Java 7 the algorithm changed
return classFile.MajorVersion >= 51
? FindBaseMethods7(m.Name, m.Signature, m.IsFinal && !m.IsPublic && !m.IsProtected, out explicitOverride)
: FindBaseMethodsLegacy(m.Name, m.Signature, out explicitOverride);
}
private MethodWrapper[] FindBaseMethods7(string name, string sig, bool packageFinal, out bool explicitOverride)
{
// NOTE this implements the (completely broken) OpenJDK 7 b147 HotSpot behavior,
// not the algorithm specified in section 5.4.5 of the JavaSE7 JVM spec
// see http://weblog.ikvm.net/PermaLink.aspx?guid=bde44d8b-7ba9-4e0e-b3a6-b735627118ff and subsequent posts
explicitOverride = false;
MethodWrapper topPublicOrProtectedMethod = null;
TypeWrapper tw = wrapper.BaseTypeWrapper;
while (tw != null)
{
MethodWrapper baseMethod = tw.GetMethodWrapper(name, sig, true);
if (baseMethod == null)
{
break;
}
else if (baseMethod.IsAccessStub)
{
// ignore
}
else if (!baseMethod.IsStatic && (baseMethod.IsPublic || baseMethod.IsProtected))
{
topPublicOrProtectedMethod = baseMethod;
}
tw = baseMethod.DeclaringType.BaseTypeWrapper;
}
tw = wrapper.BaseTypeWrapper;
while (tw != null)
{
MethodWrapper baseMethod = tw.GetMethodWrapper(name, sig, true);
if (baseMethod == null)
{
break;
}
else if (baseMethod.IsAccessStub)
{
// ignore
}
else if (baseMethod.IsPrivate)
{
// skip
}
else if (baseMethod.IsFinal && (baseMethod.IsPublic || baseMethod.IsProtected || baseMethod.DeclaringType.IsPackageAccessibleFrom(wrapper)))
{
throw new VerifyError("final method " + baseMethod.Name + baseMethod.Signature + " in " + baseMethod.DeclaringType.Name + " is overridden in " + wrapper.Name);
}
else if (baseMethod.IsStatic)
{
// skip
}
else if (topPublicOrProtectedMethod == null && !baseMethod.IsPublic && !baseMethod.IsProtected && !baseMethod.DeclaringType.IsPackageAccessibleFrom(wrapper))
{
// this is a package private method that we're not overriding (unless its vtable stream interleaves ours, which is a case we handle below)
explicitOverride = true;
}
else if (topPublicOrProtectedMethod != null && baseMethod.IsFinal && !baseMethod.IsPublic && !baseMethod.IsProtected && !baseMethod.DeclaringType.IsPackageAccessibleFrom(wrapper))
{
// this is package private final method that we would override had it not been final, but which is ignored by HotSpot (instead of throwing a VerifyError)
explicitOverride = true;
}
else if (topPublicOrProtectedMethod == null)
{
if (explicitOverride)
{
List<MethodWrapper> list = new List<MethodWrapper>();
list.Add(baseMethod);
// we might still have to override package methods from another package if the vtable streams are interleaved with ours
tw = wrapper.BaseTypeWrapper;
while (tw != null)
{
MethodWrapper baseMethod2 = tw.GetMethodWrapper(name, sig, true);
if (baseMethod2 == null || baseMethod2 == baseMethod)
{
break;
}
MethodWrapper baseMethod3 = GetPackageBaseMethod(baseMethod.DeclaringType.BaseTypeWrapper, name, sig, baseMethod2.DeclaringType);
if (baseMethod3 != null)
{
if (baseMethod2.IsFinal)
{
baseMethod2 = baseMethod3;
}
bool found = false;
foreach (MethodWrapper mw in list)
{
if (mw.DeclaringType.IsPackageAccessibleFrom(baseMethod2.DeclaringType))
{
// we should only add each package once
found = true;
break;
}
}
if (!found)
{
list.Add(baseMethod2);
}
}
tw = baseMethod2.DeclaringType.BaseTypeWrapper;
}
return list.ToArray();
}
else
{
return new MethodWrapper[] { baseMethod };
}
}
else
{
if (packageFinal)
{
// when a package final method overrides a public or protected method, HotSpot does not mark that vtable slot as final,
// so we need an explicit override to force the MethodAttributes.NewSlot flag, otherwise the CLR won't allow us
// to override the original method in subsequent derived types
explicitOverride = true;
}
int majorVersion = 0;
if (!baseMethod.IsPublic && !baseMethod.IsProtected &&
((TryGetClassFileVersion(baseMethod.DeclaringType, ref majorVersion) && majorVersion < 51)
// if TryGetClassFileVersion fails, we know that it is safe to call GetMethod() so we look at the actual method attributes here,
// because access widing ensures that if the method had overridden the top level method it would also be public or protected
|| (majorVersion == 0 && (LinkAndGetMethod(baseMethod).Attributes & MethodAttributes.MemberAccessMask) == MethodAttributes.Assembly)))
{
// the method we're overriding is not public or protected, but there is a public or protected top level method,
// this means that baseMethod is part of a class with a major version < 51, so we have to explicitly override the top level method as well
// (we don't need to look for another package method to override, because by necessity baseMethod is already in our package)
return new MethodWrapper[] { baseMethod, topPublicOrProtectedMethod };
}
else if (!topPublicOrProtectedMethod.DeclaringType.IsPackageAccessibleFrom(wrapper))
{
// check if there is another method (in the same package) that we should override
tw = topPublicOrProtectedMethod.DeclaringType.BaseTypeWrapper;
while (tw != null)
{
MethodWrapper baseMethod2 = tw.GetMethodWrapper(name, sig, true);
if (baseMethod2 == null)
{
break;
}
if (baseMethod2.IsAccessStub)
{
// ignore
}
else if (baseMethod2.DeclaringType.IsPackageAccessibleFrom(wrapper) && !baseMethod2.IsPrivate)
{
if (baseMethod2.IsFinal)
{
throw new VerifyError("final method " + baseMethod2.Name + baseMethod2.Signature + " in " + baseMethod2.DeclaringType.Name + " is overridden in " + wrapper.Name);
}
if (!baseMethod2.IsStatic)
{
if (baseMethod2.IsPublic || baseMethod2.IsProtected)
{
break;
}
return new MethodWrapper[] { baseMethod, baseMethod2 };
}
}
tw = baseMethod2.DeclaringType.BaseTypeWrapper;
}
}
return new MethodWrapper[] { baseMethod };
}
tw = baseMethod.DeclaringType.BaseTypeWrapper;
}
return null;
}
private static MethodBase LinkAndGetMethod(MethodWrapper mw)
{
mw.Link();
return mw.GetMethod();
}
private static bool TryGetClassFileVersion(TypeWrapper tw, ref int majorVersion)
{
DynamicTypeWrapper dtw = tw as DynamicTypeWrapper;
if (dtw != null)
{
JavaTypeImpl impl = dtw.impl as JavaTypeImpl;
if (impl != null)
{
majorVersion = impl.classFile.MajorVersion;
return true;
}
}
return false;
}
private static MethodWrapper GetPackageBaseMethod(TypeWrapper tw, string name, string sig, TypeWrapper package)
{
while (tw != null)
{
MethodWrapper mw = tw.GetMethodWrapper(name, sig, true);
if (mw == null)
{
break;
}
if (mw.DeclaringType.IsPackageAccessibleFrom(package))
{
return mw.IsFinal ? null : mw;
}
tw = mw.DeclaringType.BaseTypeWrapper;
}
return null;
}
private MethodWrapper[] FindBaseMethodsLegacy(string name, string sig, out bool explicitOverride)
{
explicitOverride = false;
TypeWrapper tw = wrapper.BaseTypeWrapper;
while (tw != null)
{
MethodWrapper baseMethod = tw.GetMethodWrapper(name, sig, true);
if (baseMethod == null)
{
return null;
}
else if (baseMethod.IsAccessStub)
{
// ignore
}
// here are the complex rules for determining whether this method overrides the method we found
// RULE 1: final methods may not be overridden
// (note that we intentionally not check IsStatic here!)
else if (baseMethod.IsFinal
&& !baseMethod.IsPrivate
&& (baseMethod.IsPublic || baseMethod.IsProtected || baseMethod.DeclaringType.IsPackageAccessibleFrom(wrapper)))
{
throw new VerifyError("final method " + baseMethod.Name + baseMethod.Signature + " in " + baseMethod.DeclaringType.Name + " is overridden in " + wrapper.Name);
}
// RULE 1a: static methods are ignored (other than the RULE 1 check)
else if (baseMethod.IsStatic)
{
}
// 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])
else 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;
}
if (!baseMethod.DeclaringType.IsPackageAccessibleFrom(wrapper))
{
// check if there is another method (in the same package) that we should override
tw = baseMethod.DeclaringType.BaseTypeWrapper;
while (tw != null)
{
MethodWrapper baseMethod2 = tw.GetMethodWrapper(name, sig, true);
if (baseMethod2 == null)
{
break;
}
if (baseMethod2.IsAccessStub)
{
// ignore
}
else if (baseMethod2.DeclaringType.IsPackageAccessibleFrom(wrapper) && !baseMethod2.IsPrivate)
{
if (baseMethod2.IsFinal)
{
throw new VerifyError("final method " + baseMethod2.Name + baseMethod2.Signature + " in " + baseMethod2.DeclaringType.Name + " is overridden in " + wrapper.Name);
}
if (!baseMethod2.IsStatic)
{
if (baseMethod2.IsPublic || baseMethod2.IsProtected)
{
break;
}
return new MethodWrapper[] { baseMethod, baseMethod2 };
}
}
tw = baseMethod2.DeclaringType.BaseTypeWrapper;
}
}
return new MethodWrapper[] { baseMethod };
}
// RULE 3: private and static methods are ignored
else if (!baseMethod.IsPrivate)
{
// RULE 4: package methods can only be overridden in the same package
if (baseMethod.DeclaringType.IsPackageAccessibleFrom(wrapper)
|| (baseMethod.IsInternal && baseMethod.DeclaringType.InternalsVisibleTo(wrapper)))
{
return new MethodWrapper[] { 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 static MethodInfo GetBaseFinalizeMethod(TypeWrapper wrapper)
{
for (; ; )
{
// HACK we get called during method linking (which is probably a bad idea) and
// it is possible for the base type not to be finished yet, so we look at the
// private state of the unfinished base types to find the finalize method.
DynamicTypeWrapper dtw = wrapper as DynamicTypeWrapper;
if (dtw == null)
{
break;
}
MethodWrapper mw = dtw.GetMethodWrapper(StringConstants.FINALIZE, StringConstants.SIG_VOID, false);
if (mw != null)
{
mw.Link();
}
MethodInfo finalizeImpl = dtw.impl.GetFinalizeMethod();
if (finalizeImpl != null)
{
return finalizeImpl;
}
wrapper = wrapper.BaseTypeWrapper;
}
if (wrapper == CoreClasses.java.lang.Object.Wrapper || wrapper == CoreClasses.java.lang.Throwable.Wrapper)
{
return Types.Object.GetMethod("Finalize", BindingFlags.NonPublic | BindingFlags.Instance);
}
Type type = wrapper.TypeAsBaseType;
MethodInfo baseFinalize = type.GetMethod("__<Finalize>", BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance, null, Type.EmptyTypes, null);
if (baseFinalize != null)
{
return baseFinalize;
}
while (type != null)
{
foreach (MethodInfo m in type.GetMethods(BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly))
{
if (m.Name == "Finalize"
&& m.ReturnType == Types.Void
&& m.GetParameters().Length == 0)
{
if (m.GetBaseDefinition().DeclaringType == Types.Object)
{
return m;
}
}
}
type = type.BaseType;
}
return null;
}
private MethodAttributes GetPropertyAccess(MethodWrapper mw)
{
string sig = mw.ReturnType.SigName;
if (sig == "V")
{
sig = mw.GetParameters()[0].SigName;
}
int access = -1;
foreach (ClassFile.Field field in classFile.Fields)
{
if (field.IsProperty
&& field.IsStatic == mw.IsStatic
&& field.Signature == sig
&& (field.PropertyGetter == mw.Name || field.PropertySetter == mw.Name))
{
int nacc;
if (field.IsPublic)
{
nacc = 3;
}
else if (field.IsProtected)
{
nacc = 2;
}
else if (field.IsPrivate)
{
nacc = 0;
}
else
{
nacc = 1;
}
if (nacc > access)
{
access = nacc;
}
}
}
switch (access)
{
case 0:
return MethodAttributes.Private;
case 1:
return MethodAttributes.Assembly;
case 2:
return MethodAttributes.FamORAssem;
case 3:
return MethodAttributes.Public;
default:
throw new InvalidOperationException();
}
}
internal override MethodBase LinkMethod(MethodWrapper mw)
{
if (mw is DelegateConstructorMethodWrapper)
{
((DelegateConstructorMethodWrapper)mw).DoLink(typeBuilder);
return null;
}
if (mw is DelegateInvokeStubMethodWrapper)
{
return ((DelegateInvokeStubMethodWrapper)mw).DoLink(typeBuilder);
}
Debug.Assert(mw != null);
int index = GetMethodIndex(mw);
if (baseMethods[index] != null)
{
foreach (MethodWrapper baseMethod in baseMethods[index])
{
baseMethod.Link();
CheckLoaderConstraints(mw, baseMethod);
}
}
Debug.Assert(mw.GetMethod() == null);
methods[index].AssertLinked();
Profiler.Enter("JavaTypeImpl.GenerateMethod");
try
{
if (index >= classFile.Methods.Length)
{
if (methods[index].IsMirandaMethod)
{
// We're a Miranda method
Debug.Assert(baseMethods[index].Length == 1 && baseMethods[index][0].DeclaringType.IsInterface);
MethodBuilder mb = methods[index].GetDefineMethodHelper().DefineMethod(wrapper, typeBuilder, methods[index].Name, MethodAttributes.HideBySig | MethodAttributes.NewSlot | MethodAttributes.Public | MethodAttributes.Virtual | MethodAttributes.Abstract | MethodAttributes.CheckAccessOnOverride);
AttributeHelper.HideFromReflection(mb);
if (CheckRequireOverrideStub(methods[index], baseMethods[index][0]))
{
wrapper.GenerateOverrideStub(typeBuilder, baseMethods[index][0], mb, methods[index]);
}
// if we changed the name or if the interface method name is remapped, we need to add an explicit methodoverride.
else if (!baseMethods[index][0].IsDynamicOnly && methods[index].Name != baseMethods[index][0].RealName)
{
typeBuilder.DefineMethodOverride(mb, (MethodInfo)baseMethods[index][0].GetMethod());
}
return mb;
}
else
{
throw new InvalidOperationException();
}
}
ClassFile.Method m = classFile.Methods[index];
MethodBuilder method;
bool setModifiers = false;
if (methods[index].HasCallerID && (m.Modifiers & Modifiers.VarArgs) != 0)
{
// the implicit callerID parameter was added at the end so that means we shouldn't use ParamArrayAttribute,
// so we need to explicitly record that the method is varargs
setModifiers = true;
}
if (m.IsConstructor)
{
method = GenerateConstructor(methods[index]);
// strictfp is the only modifier that a constructor can have
if (m.IsStrictfp)
{
setModifiers = true;
}
}
else if (m.IsClassInitializer)
{
method = ReflectUtil.DefineTypeInitializer(typeBuilder);
}
else
{
method = GenerateMethod(index, m, ref setModifiers);
}
string[] exceptions = m.ExceptionsAttribute;
methods[index].SetDeclaredExceptions(exceptions);
#if STATIC_COMPILER
AttributeHelper.SetThrowsAttribute(method, exceptions);
if (setModifiers || m.IsInternal || (m.Modifiers & (Modifiers.Synthetic | Modifiers.Bridge)) != 0)
{
AttributeHelper.SetModifiers(method, m.Modifiers, m.IsInternal);
}
if ((m.Modifiers & (Modifiers.Synthetic | Modifiers.Bridge)) != 0
&& (m.IsPublic || m.IsProtected)
&& wrapper.IsPublic
&& !IsAccessBridge(classFile, m))
{
AttributeHelper.SetEditorBrowsableNever(method);
// TODO on WHIDBEY apply CompilerGeneratedAttribute
}
if (m.DeprecatedAttribute)
{
AttributeHelper.SetDeprecatedAttribute(method);
}
if (m.GenericSignature != null)
{
AttributeHelper.SetSignatureAttribute(method, m.GenericSignature);
}
#else // STATIC_COMPILER
if (setModifiers)
{
// shut up the compiler
}
#endif // STATIC_COMPILER
return method;
}
finally
{
Profiler.Leave("JavaTypeImpl.GenerateMethod");
}
}
private MethodBuilder GenerateConstructor(MethodWrapper mw)
{
MethodBuilder cb = mw.GetDefineMethodHelper().DefineConstructor(wrapper, typeBuilder, GetMethodAccess(mw) | MethodAttributes.HideBySig);
cb.SetImplementationFlags(MethodImplAttributes.NoInlining);
return cb;
}
private MethodBuilder GenerateMethod(int index, ClassFile.Method m, ref bool setModifiers)
{
MethodAttributes attribs = MethodAttributes.HideBySig;
if (m.IsNative)
{
if (wrapper.IsPInvokeMethod(m))
{
// this doesn't appear to be necessary, but we use the flag in Finish to know
// that we shouldn't emit a method body
attribs |= MethodAttributes.PinvokeImpl;
}
else
{
setModifiers = true;
}
}
if (methods[index].IsPropertyAccessor)
{
attribs |= GetPropertyAccess(methods[index]);
attribs |= MethodAttributes.SpecialName;
setModifiers = true;
}
else
{
attribs |= GetMethodAccess(methods[index]);
}
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)
{
if (classFile.IsPublic && !classFile.IsFinal && !(m.IsPublic || m.IsProtected))
{
setModifiers = true;
}
else
{
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;
if (m.IsSynchronized)
{
setModifiers = true;
}
}
else if (!m.IsPrivate)
{
attribs |= MethodAttributes.Virtual | MethodAttributes.CheckAccessOnOverride;
}
string name = m.Name;
#if STATIC_COMPILER
if ((m.Modifiers & Modifiers.Bridge) != 0 && (m.IsPublic || m.IsProtected) && wrapper.IsPublic)
{
string sigbase = m.Signature.Substring(0, m.Signature.LastIndexOf(')') + 1);
foreach (MethodWrapper mw in methods)
{
if (mw.Name == m.Name && mw.Signature.StartsWith(sigbase) && mw.Signature != m.Signature)
{
// To prevent bridge methods with covariant return types from confusing
// other .NET compilers (like C#), we rename the bridge method.
name = NamePrefix.Bridge + name;
break;
}
}
}
#endif
if ((attribs & MethodAttributes.Virtual) != 0 && !classFile.IsInterface)
{
if (baseMethods[index] == null || (baseMethods[index].Length == 1 && baseMethods[index][0].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
bool hasPublicBaseMethod = false;
foreach (MethodWrapper baseMethodWrapper in baseMethods[index])
{
MethodBase baseMethod = baseMethodWrapper.GetMethod();
if ((baseMethod.IsPublic && !m.IsPublic) ||
((baseMethod.IsFamily || baseMethod.IsFamilyOrAssembly) && !m.IsPublic && !m.IsProtected) ||
(!m.IsPublic && !m.IsProtected && !baseMethodWrapper.DeclaringType.IsPackageAccessibleFrom(wrapper)))
{
hasPublicBaseMethod |= baseMethod.IsPublic;
attribs &= ~MethodAttributes.MemberAccessMask;
attribs |= hasPublicBaseMethod ? MethodAttributes.Public : MethodAttributes.FamORAssem;
setModifiers = true;
}
}
}
}
MethodBuilder mb = null;
#if STATIC_COMPILER
mb = wrapper.DefineGhostMethod(name, attribs, methods[index]);
#endif
if (mb == null)
{
bool needFinalize = false;
bool needDispatch = false;
MethodInfo baseFinalize = null;
if (baseMethods[index] != null && ReferenceEquals(m.Name, StringConstants.FINALIZE) && ReferenceEquals(m.Signature, StringConstants.SIG_VOID))
{
baseFinalize = GetBaseFinalizeMethod(wrapper.BaseTypeWrapper);
if (baseMethods[index][0].DeclaringType == CoreClasses.java.lang.Object.Wrapper)
{
// This type is the first type in the hierarchy to introduce a finalize method
// (other than the one in java.lang.Object obviously), so we need to override
// the real Finalize method and emit a dispatch call to our finalize method.
needFinalize = true;
needDispatch = true;
}
else if (m.IsFinal)
{
// One of our base classes already has a finalize method, so we already are
// hooked into the real Finalize, but we need to override it again, to make it
// final (so that non-Java types cannot override it either).
needFinalize = true;
needDispatch = false;
// If the base class finalize was optimized away, we need a dispatch call after all.
if (baseFinalize.DeclaringType == Types.Object)
{
needDispatch = true;
}
}
else
{
// One of our base classes already has a finalize method, but it may have been an empty
// method so that the hookup to the real Finalize was optimized away, we need to check
// for that.
if (baseFinalize.DeclaringType == Types.Object)
{
needFinalize = true;
needDispatch = true;
}
}
if (needFinalize &&
!m.IsAbstract && !m.IsNative &&
(!m.IsFinal || classFile.IsFinal) &&
m.Instructions.Length > 0 &&
m.Instructions[0].NormalizedOpCode == NormalizedByteCode.__return)
{
// we've got an empty finalize method, so we don't need to override the real finalizer
// (not having a finalizer makes a huge perf difference)
needFinalize = false;
}
}
bool newslot = baseMethods[index] != null
&& (methods[index].IsExplicitOverride || baseMethods[index][0].RealName != name || CheckRequireOverrideStub(methods[index], baseMethods[index][0]))
&& !needFinalize;
if (newslot)
{
attribs |= MethodAttributes.NewSlot;
}
mb = methods[index].GetDefineMethodHelper().DefineMethod(wrapper, typeBuilder, name, attribs);
if (baseMethods[index] != null && !needFinalize)
{
bool subsequent = false;
foreach (MethodWrapper baseMethod in baseMethods[index])
{
if (CheckRequireOverrideStub(methods[index], baseMethod))
{
wrapper.GenerateOverrideStub(typeBuilder, baseMethod, mb, methods[index]);
}
else if (subsequent || methods[index].IsExplicitOverride || baseMethod.RealName != name)
{
typeBuilder.DefineMethodOverride(mb, (MethodInfo)baseMethod.GetMethod());
}
// the non-primary base methods always need an explicit method override
subsequent = true;
}
}
// 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)
{
string finalizeName = baseFinalize.Name;
MethodWrapper mwClash = wrapper.GetMethodWrapper(finalizeName, StringConstants.SIG_VOID, true);
if (mwClash != null && mwClash.GetMethod() != baseFinalize)
{
finalizeName = "__<Finalize>";
}
MethodAttributes attr = MethodAttributes.HideBySig | MethodAttributes.Virtual;
// make sure we don't reduce accessibility
attr |= baseFinalize.IsPublic ? MethodAttributes.Public : MethodAttributes.Family;
if (m.IsFinal)
{
attr |= MethodAttributes.Final;
}
finalizeMethod = typeBuilder.DefineMethod(finalizeName, attr, CallingConventions.Standard, Types.Void, Type.EmptyTypes);
if (finalizeName != baseFinalize.Name)
{
typeBuilder.DefineMethodOverride(finalizeMethod, baseFinalize);
}
AttributeHelper.HideFromJava(finalizeMethod);
CodeEmitter ilgen = CodeEmitter.Create(finalizeMethod);
ilgen.Emit(OpCodes.Call, ByteCodeHelperMethods.SkipFinalizer);
CodeEmitterLabel skip = ilgen.DefineLabel();
ilgen.EmitBrtrue(skip);
if (needDispatch)
{
ilgen.BeginExceptionBlock();
ilgen.Emit(OpCodes.Ldarg_0);
ilgen.Emit(OpCodes.Callvirt, mb);
ilgen.EmitLeave(skip);
ilgen.BeginCatchBlock(Types.Object);
ilgen.EmitLeave(skip);
ilgen.EndExceptionBlock();
}
else
{
ilgen.Emit(OpCodes.Ldarg_0);
ilgen.Emit(OpCodes.Call, baseFinalize);
}
ilgen.MarkLabel(skip);
ilgen.Emit(OpCodes.Ret);
ilgen.DoEmit();
}
#if STATIC_COMPILER
if (classFile.Methods[index].AnnotationDefault != null)
{
CustomAttributeBuilder cab = new CustomAttributeBuilder(StaticCompiler.GetRuntimeType("IKVM.Attributes.AnnotationDefaultAttribute").GetConstructor(new Type[] { Types.Object }), new object[] { classFile.Methods[index].AnnotationDefault });
mb.SetCustomAttribute(cab);
}
#endif // STATIC_COMPILER
}
if ((methods[index].Modifiers & (Modifiers.Synchronized | Modifiers.Static)) == Modifiers.Synchronized)
{
mb.SetImplementationFlags(mb.GetMethodImplementationFlags() | MethodImplAttributes.Synchronized);
}
return mb;
}
private static MethodAttributes GetMethodAccess(MethodWrapper mw)
{
switch (mw.Modifiers & Modifiers.AccessMask)
{
case Modifiers.Private:
return MethodAttributes.Private;
case Modifiers.Protected:
return MethodAttributes.FamORAssem;
case Modifiers.Public:
return MethodAttributes.Public;
default:
return MethodAttributes.Assembly;
}
}
#if STATIC_COMPILER
// The classic example of an access bridge is StringBuilder.length(), the JDK 6 compiler
// generates this to work around a reflection problem (which otherwise wouldn't surface the
// length() method, because it is defined in the non-public base class AbstractStringBuilder.)
private static bool IsAccessBridge(ClassFile classFile, ClassFile.Method m)
{
// HACK this is a pretty gross hack
// We look at the method body to figure out if the bridge method calls another method with the exact
// same name/signature and if that is the case, we assume that it is an access bridge.
// This code is based on the javac algorithm in addBridgeIfNeeded(...) in com/sun/tools/javac/comp/TransTypes.java.
if ((m.Modifiers & (Modifiers.Abstract | Modifiers.Native | Modifiers.Public | Modifiers.Bridge)) == (Modifiers.Public | Modifiers.Bridge))
{
foreach (ClassFile.Method.Instruction instr in m.Instructions)
{
if (instr.NormalizedOpCode == NormalizedByteCode.__invokespecial)
{
ClassFile.ConstantPoolItemMI cpi = classFile.SafeGetMethodref(instr.Arg1);
return cpi != null && cpi.Name == m.Name && cpi.Signature == m.Signature;
}
}
}
return false;
}
#endif // STATIC_COMPILER
internal override Type Type
{
get
{
return typeBuilder;
}
}
internal override string GetGenericSignature()
{
Debug.Fail("Unreachable code");
return null;
}
internal override string[] GetEnclosingMethod()
{
Debug.Fail("Unreachable code");
return null;
}
internal override string GetGenericMethodSignature(int index)
{
Debug.Fail("Unreachable code");
return null;
}
internal override string GetGenericFieldSignature(int index)
{
Debug.Fail("Unreachable code");
return null;
}
internal override object[] GetDeclaredAnnotations()
{
Debug.Fail("Unreachable code");
return null;
}
internal override object GetMethodDefaultValue(int index)
{
Debug.Fail("Unreachable code");
return null;
}
internal override object[] GetMethodAnnotations(int index)
{
Debug.Fail("Unreachable code");
return null;
}
internal override object[][] GetParameterAnnotations(int index)
{
Debug.Fail("Unreachable code");
return null;
}
internal override object[] GetFieldAnnotations(int index)
{
Debug.Fail("Unreachable code");
return null;
}
internal override MethodInfo GetFinalizeMethod()
{
return finalizeMethod;
}
}
private sealed class Metadata
{
private string[][] genericMetaData;
private object[][] annotations;
private Metadata(string[][] genericMetaData, object[][] annotations)
{
this.genericMetaData = genericMetaData;
this.annotations = annotations;
}
internal static Metadata Create(ClassFile classFile)
{
if (classFile.MajorVersion < 49)
{
return null;
}
string[][] genericMetaData = null;
object[][] annotations = null;
for (int i = 0; i < classFile.Methods.Length; i++)
{
if (classFile.Methods[i].GenericSignature != null)
{
if (genericMetaData == null)
{
genericMetaData = new string[4][];
}
if (genericMetaData[0] == null)
{
genericMetaData[0] = new string[classFile.Methods.Length];
}
genericMetaData[0][i] = classFile.Methods[i].GenericSignature;
}
if (classFile.Methods[i].Annotations != null)
{
if (annotations == null)
{
annotations = new object[5][];
}
if (annotations[1] == null)
{
annotations[1] = new object[classFile.Methods.Length];
}
annotations[1][i] = classFile.Methods[i].Annotations;
}
if (classFile.Methods[i].ParameterAnnotations != null)
{
if (annotations == null)
{
annotations = new object[5][];
}
if (annotations[2] == null)
{
annotations[2] = new object[classFile.Methods.Length];
}
annotations[2][i] = classFile.Methods[i].ParameterAnnotations;
}
if (classFile.Methods[i].AnnotationDefault != null)
{
if (annotations == null)
{
annotations = new object[5][];
}
if (annotations[3] == null)
{
annotations[3] = new object[classFile.Methods.Length];
}
annotations[3][i] = classFile.Methods[i].AnnotationDefault;
}
}
for (int i = 0; i < classFile.Fields.Length; i++)
{
if (classFile.Fields[i].GenericSignature != null)
{
if (genericMetaData == null)
{
genericMetaData = new string[4][];
}
if (genericMetaData[1] == null)
{
genericMetaData[1] = new string[classFile.Fields.Length];
}
genericMetaData[1][i] = classFile.Fields[i].GenericSignature;
}
if (classFile.Fields[i].Annotations != null)
{
if (annotations == null)
{
annotations = new object[5][];
}
if (annotations[4] == null)
{
annotations[4] = new object[classFile.Fields.Length][];
}
annotations[4][i] = classFile.Fields[i].Annotations;
}
}
if (classFile.EnclosingMethod != null)
{
if (genericMetaData == null)
{
genericMetaData = new string[4][];
}
genericMetaData[2] = classFile.EnclosingMethod;
}
if (classFile.GenericSignature != null)
{
if (genericMetaData == null)
{
genericMetaData = new string[4][];
}
genericMetaData[3] = new string[] { classFile.GenericSignature };
}
if (classFile.Annotations != null)
{
if (annotations == null)
{
annotations = new object[5][];
}
annotations[0] = classFile.Annotations;
}
if (genericMetaData != null || annotations != null)
{
return new Metadata(genericMetaData, annotations);
}
return null;
}
internal static string GetGenericSignature(Metadata m)
{
if (m != null && m.genericMetaData != null && m.genericMetaData[3] != null)
{
return m.genericMetaData[3][0];
}
return null;
}
internal static string[] GetEnclosingMethod(Metadata m)
{
if (m != null && m.genericMetaData != null)
{
return m.genericMetaData[2];
}
return null;
}
internal static string GetGenericMethodSignature(Metadata m, int index)
{
if (m != null && m.genericMetaData != null && m.genericMetaData[0] != null)
{
return m.genericMetaData[0][index];
}
return null;
}
internal static string GetGenericFieldSignature(Metadata m, int index)
{
if (m != null && m.genericMetaData != null && m.genericMetaData[1] != null)
{
return m.genericMetaData[1][index];
}
return null;
}
internal static object[] GetAnnotations(Metadata m)
{
if (m != null && m.annotations != null)
{
return m.annotations[0];
}
return null;
}
internal static object[] GetMethodAnnotations(Metadata m, int index)
{
if (m != null && m.annotations != null && m.annotations[1] != null)
{
return (object[])m.annotations[1][index];
}
return null;
}
internal static object[][] GetMethodParameterAnnotations(Metadata m, int index)
{
if (m != null && m.annotations != null && m.annotations[2] != null)
{
return (object[][])m.annotations[2][index];
}
return null;
}
internal static object GetMethodDefaultValue(Metadata m, int index)
{
if (m != null && m.annotations != null && m.annotations[3] != null)
{
return m.annotations[3][index];
}
return null;
}
// note that unlike GetGenericFieldSignature, the index is simply the field index
internal static object[] GetFieldAnnotations(Metadata m, int index)
{
if (m != null && m.annotations != null && m.annotations[4] != null)
{
return (object[])m.annotations[4][index];
}
return null;
}
}
private sealed class FinishedTypeImpl : DynamicImpl
{
private Type type;
private TypeWrapper[] innerclasses;
private TypeWrapper declaringTypeWrapper;
private Modifiers reflectiveModifiers;
private MethodInfo clinitMethod;
private MethodInfo finalizeMethod;
private Metadata metadata;
internal FinishedTypeImpl(Type type, TypeWrapper[] innerclasses, TypeWrapper declaringTypeWrapper, Modifiers reflectiveModifiers, Metadata metadata, MethodInfo clinitMethod, MethodInfo finalizeMethod)
{
this.type = type;
this.innerclasses = innerclasses;
this.declaringTypeWrapper = declaringTypeWrapper;
this.reflectiveModifiers = reflectiveModifiers;
this.clinitMethod = clinitMethod;
this.finalizeMethod = finalizeMethod;
this.metadata = metadata;
}
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 Type Type
{
get
{
return type;
}
}
internal override void EmitRunClassConstructor(CodeEmitter ilgen)
{
if (clinitMethod != null)
{
ilgen.Emit(OpCodes.Call, clinitMethod);
}
}
internal override DynamicImpl Finish()
{
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 FieldInfo LinkField(FieldWrapper fw)
{
// we should never be called, because all fields on a finished type are already linked
Debug.Assert(false);
return fw.GetField();
}
internal override string GetGenericSignature()
{
return Metadata.GetGenericSignature(metadata);
}
internal override string[] GetEnclosingMethod()
{
return Metadata.GetEnclosingMethod(metadata);
}
internal override string GetGenericMethodSignature(int index)
{
return Metadata.GetGenericMethodSignature(metadata, index);
}
internal override string GetGenericFieldSignature(int index)
{
return Metadata.GetGenericFieldSignature(metadata, index);
}
internal override object[] GetDeclaredAnnotations()
{
return Metadata.GetAnnotations(metadata);
}
internal override object GetMethodDefaultValue(int index)
{
return Metadata.GetMethodDefaultValue(metadata, index);
}
internal override object[] GetMethodAnnotations(int index)
{
return Metadata.GetMethodAnnotations(metadata, index);
}
internal override object[][] GetParameterAnnotations(int index)
{
return Metadata.GetMethodParameterAnnotations(metadata, index);
}
internal override object[] GetFieldAnnotations(int index)
{
return Metadata.GetFieldAnnotations(metadata, index);
}
internal override MethodInfo GetFinalizeMethod()
{
return finalizeMethod;
}
}
internal sealed class FinishContext
{
private readonly ClassFile classFile;
private readonly DynamicOrAotTypeWrapper wrapper;
private readonly TypeBuilder typeBuilder;
private List<TypeBuilder> nestedTypeBuilders;
private MethodInfo callerIDMethod;
private List<Item> items;
private Dictionary<FieldWrapper, MethodBuilder> arfuMap;
private struct Item
{
internal int key;
internal object value;
}
internal FinishContext(ClassFile classFile, DynamicOrAotTypeWrapper wrapper, TypeBuilder typeBuilder)
{
this.classFile = classFile;
this.wrapper = wrapper;
this.typeBuilder = typeBuilder;
}
internal T GetValue<T>(int key)
where T : class, new()
{
if (items == null)
{
items = new List<Item>();
}
for (int i = 0; i < items.Count; i++)
{
T value;
if (items[i].key == key && (value = items[i].value as T) != null)
{
return value;
}
}
Item item;
item.key = key;
T val = new T();
item.value = val;
items.Add(item);
return val;
}
internal void EmitCallerID(CodeEmitter ilgen)
{
if (callerIDMethod == null)
{
CreateGetCallerID();
}
ilgen.Emit(OpCodes.Call, callerIDMethod);
}
private void CreateGetCallerID()
{
TypeWrapper tw = CoreClasses.ikvm.@internal.CallerID.Wrapper;
FieldBuilder callerIDField = typeBuilder.DefineField("__<callerID>", tw.TypeAsSignatureType, FieldAttributes.Private | FieldAttributes.Static | FieldAttributes.SpecialName);
MethodBuilder mb = typeBuilder.DefineMethod("__<GetCallerID>", MethodAttributes.Private | MethodAttributes.Static | MethodAttributes.SpecialName, tw.TypeAsSignatureType, Type.EmptyTypes);
callerIDMethod = mb;
CodeEmitter ilgen = CodeEmitter.Create(mb);
ilgen.Emit(OpCodes.Ldsfld, callerIDField);
CodeEmitterLabel done = ilgen.DefineLabel();
ilgen.EmitBrtrue(done);
EmitCallerIDInitialization(ilgen, callerIDField);
ilgen.MarkLabel(done);
ilgen.Emit(OpCodes.Ldsfld, callerIDField);
ilgen.Emit(OpCodes.Ret);
ilgen.DoEmit();
}
private void RegisterNestedTypeBuilder(TypeBuilder tb)
{
if (nestedTypeBuilders == null)
{
nestedTypeBuilders = new List<TypeBuilder>();
}
nestedTypeBuilders.Add(tb);
}
internal Type FinishImpl()
{
MethodWrapper[] methods = wrapper.GetMethods();
FieldWrapper[] fields = wrapper.GetFields();
#if STATIC_COMPILER
wrapper.FinishGhost(typeBuilder, methods);
#endif // STATIC_COMPILER
if (!classFile.IsInterface)
{
// set the base type (this needs to be done before we emit any methods, because in the static compiler
// GetBaseTypeForDefineType() has the side effect of inserting the __WorkaroundBaseClass__ when necessary)
typeBuilder.SetParent(wrapper.GetBaseTypeForDefineType());
}
// 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 && !mi.DeclaringType.IsInterface)
{
bool needStub = false;
bool needRename = false;
if (mw.IsPublic || mw.IsProtected)
{
MethodWrapper fmw = wrapper.GetMethodWrapper(mw.Name, mw.Signature, true);
while (fmw != mw && (fmw.IsStatic || fmw.IsPrivate))
{
needRename = true;
fmw = fmw.DeclaringType.BaseTypeWrapper.GetMethodWrapper(mw.Name, mw.Signature, true);
}
if (fmw == mw && fmw.DeclaringType != wrapper)
{
needStub = true;
}
}
else
{
MethodWrapper fmw = wrapper.GetMethodWrapper(mw.Name, mw.Signature, true);
while (fmw != mw && (fmw.IsStatic || fmw.IsPrivate || !(mw.DeclaringType.IsPackageAccessibleFrom(fmw.DeclaringType) || (mw.IsInternal && mw.DeclaringType.InternalsVisibleTo(fmw.DeclaringType)))))
{
needRename = true;
fmw = fmw.DeclaringType.BaseTypeWrapper.GetMethodWrapper(mw.Name, mw.Signature, true);
}
if (fmw == mw && fmw.DeclaringType != wrapper)
{
needStub = true;
}
}
if (needStub)
{
// 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.
string name = mi.Name;
MethodAttributes attr = mi.Attributes & ~(MethodAttributes.Abstract | MethodAttributes.NewSlot);
if (needRename)
{
name = "__<>" + name + "/" + mi.DeclaringType.FullName;
attr = MethodAttributes.Private | MethodAttributes.Virtual | MethodAttributes.NewSlot;
}
MethodBuilder mb = mw.GetDefineMethodHelper().DefineMethod(wrapper, typeBuilder, name, attr);
if (needRename)
{
typeBuilder.DefineMethodOverride(mb, mi);
}
AttributeHelper.HideFromJava(mb);
CodeEmitter ilgen = CodeEmitter.Create(mb);
ilgen.EmitThrow("java.lang.AbstractMethodError", mw.DeclaringType.Name + "." + mw.Name + mw.Signature);
ilgen.DoEmit();
}
}
}
parent = parent.BaseTypeWrapper;
}
}
Dictionary<MethodKey, MethodInfo> invokespecialstubcache = new Dictionary<MethodKey, MethodInfo>();
bool basehasclinit = wrapper.BaseTypeWrapper != null && wrapper.BaseTypeWrapper.HasStaticInitializer;
int clinitIndex = -1;
bool hasConstructor = false;
for (int i = 0; i < classFile.Methods.Length; i++)
{
ClassFile.Method m = classFile.Methods[i];
MethodBuilder mb = (MethodBuilder)methods[i].GetMethod();
if (mb == null)
{
// method doesn't really exist (e.g. delegate constructor or <clinit> that is optimized away)
if (m.IsConstructor)
{
hasConstructor = true;
}
}
else if (m.IsClassInitializer)
{
// we handle the <clinit> after we've done the other methods,
// to make it easier to inject code needed by the other methods
clinitIndex = i;
continue;
}
else if (m.IsConstructor)
{
hasConstructor = true;
CodeEmitter ilGenerator = CodeEmitter.Create(mb);
CompileConstructorBody(this, ilGenerator, i, invokespecialstubcache);
}
else
{
if (m.IsAbstract)
{
bool stub = false;
if (!classFile.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
stub = true;
}
else if (classFile.IsPublic && !classFile.IsFinal && !(m.IsPublic || m.IsProtected))
{
// We have an abstract package accessible method in our public class. To allow a class in another
// assembly to subclass this class, we must fake the abstractness of this method.
stub = true;
}
if (stub)
{
CodeEmitter ilGenerator = CodeEmitter.Create(mb);
TraceHelper.EmitMethodTrace(ilGenerator, classFile.Name + "." + m.Name + m.Signature);
ilGenerator.EmitThrow("java.lang.AbstractMethodError", classFile.Name + "." + m.Name + m.Signature);
ilGenerator.DoEmit();
}
}
else if (m.IsNative)
{
if ((mb.Attributes & MethodAttributes.PinvokeImpl) != 0)
{
continue;
}
if (wrapper.IsDelegate)
{
mb.SetImplementationFlags(mb.GetMethodImplementationFlags() | MethodImplAttributes.Runtime);
continue;
}
Profiler.Enter("JavaTypeImpl.Finish.Native");
try
{
CodeEmitter ilGenerator = CodeEmitter.Create(mb);
TraceHelper.EmitMethodTrace(ilGenerator, classFile.Name + "." + m.Name + m.Signature);
#if STATIC_COMPILER
// do we have an implementation in map.xml?
if (wrapper.EmitMapXmlMethodPrologueAndOrBody(ilGenerator, classFile, m))
{
ilGenerator.DoEmit();
continue;
}
#endif
// see if there exists a "managed JNI" class for this type
Type nativeCodeType = null;
#if STATIC_COMPILER
nativeCodeType = StaticCompiler.GetType(wrapper.GetClassLoader(), "IKVM.NativeCode." + classFile.Name.Replace('$', '+'));
if (nativeCodeType == null)
{
// simple JNI like class name mangling
nativeCodeType = StaticCompiler.GetType(wrapper.GetClassLoader(), "Java_" + classFile.Name.Replace('.', '_'));
}
#endif
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.EmitLdarg(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 (wrapper.classLoader.NoJNI)
{
// 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);
ilGenerator.EmitThrow("java.lang.UnsatisfiedLinkError", "Native method not implemented (compiled with -nojni): " + classFile.Name + "." + m.Name + m.Signature);
}
#if STATIC_COMPILER
else if (StaticCompiler.runtimeJniAssembly == null)
{
Console.Error.WriteLine("Error: Native method not implemented: {0}.{1}{2}", classFile.Name, m.Name, m.Signature);
StaticCompiler.errorCount++;
}
#endif
else
{
if (JVM.IsSaveDebugImage)
{
#if !STATIC_COMPILER
JniProxyBuilder.Generate(this, ilGenerator, wrapper, methods[i], typeBuilder, classFile, m, args);
#endif // !STATIC_COMPILER
}
else
{
JniBuilder.Generate(this, ilGenerator, wrapper, methods[i], typeBuilder, classFile, m, args, false);
}
}
}
ilGenerator.DoEmit();
}
finally
{
Profiler.Leave("JavaTypeImpl.Finish.Native");
}
}
else
{
CodeEmitter ilGenerator = CodeEmitter.Create(mb);
TraceHelper.EmitMethodTrace(ilGenerator, classFile.Name + "." + m.Name + m.Signature);
#if STATIC_COMPILER
// do we have an implementation in map.xml?
if (wrapper.EmitMapXmlMethodPrologueAndOrBody(ilGenerator, classFile, m))
{
ilGenerator.DoEmit();
continue;
}
#endif // STATIC_COMPILER
bool nonleaf = false;
Compiler.Compile(this, wrapper, methods[i], classFile, m, ilGenerator, ref nonleaf, invokespecialstubcache);
ilGenerator.CheckLabels();
ilGenerator.DoEmit();
if (nonleaf)
{
mb.SetImplementationFlags(mb.GetMethodImplementationFlags() | MethodImplAttributes.NoInlining);
}
#if STATIC_COMPILER
ilGenerator.EmitLineNumberTable((MethodBuilder)methods[i].GetMethod());
#else // STATIC_COMPILER
byte[] linenumbers = ilGenerator.GetLineNumberTable();
if (linenumbers != null)
{
if (wrapper.lineNumberTables == null)
{
wrapper.lineNumberTables = new byte[methods.Length][];
}
wrapper.lineNumberTables[i] = linenumbers;
}
#endif // STATIC_COMPILER
}
}
}
if (clinitIndex != -1 || (basehasclinit && !classFile.IsInterface) || classFile.HasInitializedFields)
{
MethodBuilder cb;
if (clinitIndex != -1)
{
cb = (MethodBuilder)methods[clinitIndex].GetMethod();
}
else
{
cb = ReflectUtil.DefineTypeInitializer(typeBuilder);
AttributeHelper.HideFromJava(cb);
}
CodeEmitter ilGenerator = CodeEmitter.Create(cb);
// before we call the base class initializer, we need to set the non-final static ConstantValue fields
EmitConstantValueInitialization(fields, ilGenerator);
if (basehasclinit)
{
wrapper.BaseTypeWrapper.EmitRunClassConstructor(ilGenerator);
}
if (clinitIndex != -1)
{
CompileConstructorBody(this, ilGenerator, clinitIndex, invokespecialstubcache);
}
else
{
ilGenerator.Emit(OpCodes.Ret);
ilGenerator.DoEmit();
}
ilGenerator.CheckLabels();
}
// add all interfaces that we implement (including the magic ones) and handle ghost conversions
ImplementInterfaces(wrapper.Interfaces, new List<TypeWrapper>());
// NOTE non-final fields aren't allowed in interfaces so we don't have to initialize constant fields
if (!classFile.IsInterface)
{
// if a class has no constructor, we generate one otherwise Ref.Emit will create a default ctor
// and that has several problems:
// - base type may not have an accessible default constructor
// - Ref.Emit uses BaseType.GetConstructors() which may trigger a TypeResolve event
// - we don't want the synthesized constructor to show up in Java
if (!hasConstructor)
{
CodeEmitter ilgen = CodeEmitter.Create(ReflectUtil.DefineConstructor(typeBuilder, MethodAttributes.PrivateScope, Type.EmptyTypes));
ilgen.Emit(OpCodes.Ldnull);
ilgen.Emit(OpCodes.Throw);
ilgen.DoEmit();
}
// 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)
Dictionary<TypeWrapper, TypeWrapper> doneSet = new Dictionary<TypeWrapper, TypeWrapper>();
TypeWrapper[] interfaces = wrapper.Interfaces;
for (int i = 0; i < interfaces.Length; i++)
{
ImplementInterfaceMethodStubs(doneSet, interfaces[i], false);
}
// 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++)
{
ImplementInterfaceMethodStubs(doneSet, baseTypeWrapper.Interfaces[i], true);
}
baseTypeWrapper = baseTypeWrapper.BaseTypeWrapper;
}
if (!wrapper.IsAbstract && wrapper.HasUnsupportedAbstractMethods)
{
AddUnsupportedAbstractMethods();
}
if (!wrapper.GetClassLoader().NoAutomagicSerialization)
{
wrapper.automagicSerializationCtor = Serialization.AddAutomagicSerialization(wrapper, typeBuilder);
}
}
#if STATIC_COMPILER
// If we're an interface that has public/protected fields, we create an inner class
// to expose these fields to C# (which stubbornly refuses to see fields in interfaces).
TypeBuilder tbFields = null;
if (classFile.IsInterface && classFile.IsPublic && !wrapper.IsGhost && classFile.Fields.Length > 0)
{
CompilerClassLoader ccl = wrapper.classLoader;
string name = "__Fields";
while (!ccl.ReserveName(classFile.Name + "$" + name))
{
name += "_";
}
tbFields = typeBuilder.DefineNestedType(name, TypeAttributes.Class | TypeAttributes.NestedPublic | TypeAttributes.Sealed | TypeAttributes.Abstract);
AttributeHelper.HideFromJava(tbFields);
CodeEmitter ilgenClinit = null;
for (int i = 0; i < classFile.Fields.Length; i++)
{
ClassFile.Field f = classFile.Fields[i];
if (f.ConstantValue != null)
{
FieldAttributes attribs = FieldAttributes.Public | FieldAttributes.Static | FieldAttributes.Literal;
FieldBuilder fb = tbFields.DefineField(f.Name, fields[i].FieldTypeWrapper.TypeAsSignatureType, attribs);
fb.SetConstant(f.ConstantValue);
}
else
{
FieldAttributes attribs = FieldAttributes.Public | FieldAttributes.Static | FieldAttributes.InitOnly;
FieldBuilder fb = tbFields.DefineField(f.Name, ToPublicSignatureType(fields[i].FieldTypeWrapper), attribs);
if (ilgenClinit == null)
{
ilgenClinit = CodeEmitter.Create(ReflectUtil.DefineTypeInitializer(tbFields));
}
wrapper.GetFieldWrapper(f.Name, f.Signature).EmitGet(ilgenClinit);
ilgenClinit.Emit(OpCodes.Stsfld, fb);
}
}
if (ilgenClinit != null)
{
ilgenClinit.Emit(OpCodes.Ret);
ilgenClinit.DoEmit();
}
}
// See if there is any additional metadata
wrapper.EmitMapXmlMetadata(typeBuilder, classFile, fields, methods);
// if we inherit public members from non-public base classes or have public members with non-public types in their signature, we need access stubs
if (wrapper.IsPublic)
{
AddAccessStubs();
}
#endif // STATIC_COMPILER
for (int i = 0; i < classFile.Methods.Length; i++)
{
ClassFile.Method m = classFile.Methods[i];
MethodBuilder mb = (MethodBuilder)methods[i].GetMethod();
if (mb == null)
{
continue;
}
ParameterBuilder returnParameter = null;
ParameterBuilder[] parameterBuilders = null;
string[] parameterNames = null;
if (wrapper.GetClassLoader().EmitDebugInfo
#if STATIC_COMPILER
|| (classFile.IsPublic && (m.IsPublic || m.IsProtected))
#endif
)
{
parameterNames = new string[methods[i].GetParameters().Length];
GetParameterNamesFromLVT(m, parameterNames);
GetParameterNamesFromSig(m.Signature, parameterNames);
#if STATIC_COMPILER
wrapper.GetParameterNamesFromXml(m.Name, m.Signature, parameterNames);
#endif
parameterBuilders = GetParameterBuilders(mb, parameterNames.Length,