internal override bool InternalsVisibleToImpl(TypeWrapper wrapper, TypeWrapper friend)
{
ClassLoaderWrapper other = friend.GetClassLoader();
if (this == other)
{
return(true);
}
AssemblyName otherName;
#if STATIC_COMPILER
CompilerClassLoader ccl = other as CompilerClassLoader;
if (ccl == null)
{
return(false);
}
otherName = ccl.GetAssemblyName();
#else
AssemblyClassLoader acl = other as AssemblyClassLoader;
if (acl == null)
{
return(false);
}
otherName = acl.GetAssembly(friend).GetName();
#endif
return(GetLoader(GetAssembly(wrapper)).InternalsVisibleTo(otherName));
}
private static AssemblyClassLoader Create(Assembly assembly)
{
// If the assembly is a part of a multi-assembly shared class loader,
// it will export the __<MainAssembly> type from the main assembly in the group.
Type forwarder = assembly.GetType("__<MainAssembly>");
if (forwarder != null)
{
Assembly mainAssembly = forwarder.Assembly;
if (mainAssembly != assembly)
{
return(FromAssembly(mainAssembly));
}
}
#if STATIC_COMPILER
if (JVM.CoreAssembly == null && CompilerClassLoader.IsCoreAssembly(assembly))
{
JVM.CoreAssembly = assembly;
ClassLoaderWrapper.LoadRemappedTypes();
}
#endif
if (assembly == JVM.CoreAssembly)
{
// This cast is necessary for ikvmc and a no-op for the runtime.
// Note that the cast cannot fail, because ikvmc will only return a non AssemblyClassLoader
// from GetBootstrapClassLoader() when compiling the core assembly and in that case JVM.CoreAssembly
// will be null.
return((AssemblyClassLoader)GetBootstrapClassLoader());
}
return(new AssemblyClassLoader(assembly));
}
private static void CreateNoFail(CompilerClassLoader loader, TypeWrapper[] interfaces, List <ProxyMethod> methods)
{
bool ispublic = true;
Type[] interfaceTypes = new Type[interfaces.Length];
for (int i = 0; i < interfaceTypes.Length; i++)
{
ispublic &= interfaces[i].IsPublic;
interfaceTypes[i] = interfaces[i].TypeAsBaseType;
}
TypeAttributes attr = TypeAttributes.Class | TypeAttributes.Sealed;
attr |= ispublic ? TypeAttributes.NestedPublic : TypeAttributes.NestedAssembly;
DynamicClassLoader factory = (DynamicClassLoader)loader.GetTypeWrapperFactory();
TypeBuilder tb = factory.DefineProxy(TypeNameUtil.GetProxyNestedName(interfaces), attr, proxyClass.TypeAsBaseType, interfaceTypes);
AttributeHelper.SetImplementsAttribute(tb, interfaces);
// we apply an InnerClass attribute to avoid the CompiledTypeWrapper heuristics for figuring out the modifiers
AttributeHelper.SetInnerClass(tb, null, ispublic ? Modifiers.Public | Modifiers.Final : Modifiers.Final);
CreateConstructor(tb);
for (int i = 0; i < methods.Count; i++)
{
methods[i].fb = tb.DefineField("m" + i, javaLangReflectMethod.TypeAsSignatureType, FieldAttributes.Private | FieldAttributes.Static);
}
foreach (ProxyMethod method in methods)
{
CreateMethod(loader, tb, method);
}
CreateStaticInitializer(tb, methods, loader);
}
private static List <ProxyMethod> CheckAndCollect(CompilerClassLoader loader, TypeWrapper[] interfaces)
{
List <MethodWrapper> methods = new List <MethodWrapper>();
// The java.lang.Object methods precede any interface methods.
methods.Add(equalsMethod);
methods.Add(hashCodeMethod);
methods.Add(toStringMethod);
// Add the interfaces methods in order.
foreach (TypeWrapper tw in interfaces)
{
if (!tw.IsInterface)
{
throw new ProxyException(tw.Name + " is not an interface");
}
if (tw.IsRemapped)
{
// TODO handle java.lang.Comparable
throw new ProxyException(tw.Name + " is a remapped interface (not currently supported)");
}
foreach (MethodWrapper mw in GetInterfaceMethods(tw))
{
// Check for duplicates
if (!MethodExists(methods, mw))
{
mw.Link();
methods.Add(mw);
}
}
}
// TODO verify restrictions
// Collect declared exceptions.
Dictionary <string, TypeWrapper[]> exceptions = new Dictionary <string, TypeWrapper[]>();
foreach (MethodWrapper mw in methods)
{
Add(loader, exceptions, mw);
}
// Build the definitive proxy method list.
List <ProxyMethod> proxyMethods = new List <ProxyMethod>();
foreach (MethodWrapper mw in methods)
{
proxyMethods.Add(new ProxyMethod(mw, exceptions[mw.Signature]));
}
return(proxyMethods);
}
private static void Add(CompilerClassLoader loader, Dictionary <string, TypeWrapper[]> exceptions, MethodWrapper mw)
{
string signature = mw.Signature;
TypeWrapper[] newExceptionTypes = LoadTypes(loader, mw.GetDeclaredExceptions());
TypeWrapper[] curExceptionTypes;
if (exceptions.TryGetValue(signature, out curExceptionTypes))
{
exceptions[signature] = Merge(newExceptionTypes, curExceptionTypes);
}
else
{
exceptions.Add(signature, newExceptionTypes);
}
}
private static void CreateNoFail(CompilerClassLoader loader, TypeWrapper[] interfaces, List <ProxyMethod> methods)
{
DynamicClassLoader factory = (DynamicClassLoader)loader.GetTypeWrapperFactory();
TypeBuilder tb = factory.DefineProxy(proxyClass, interfaces);
AttributeHelper.SetImplementsAttribute(tb, interfaces);
CreateConstructor(tb);
for (int i = 0; i < methods.Count; i++)
{
methods[i].fb = tb.DefineField("m" + i, javaLangReflectMethod.TypeAsSignatureType, FieldAttributes.Private | FieldAttributes.Static);
}
foreach (ProxyMethod method in methods)
{
CreateMethod(loader, tb, method);
}
CreateStaticInitializer(tb, methods);
}
private static void EmitClassLiteral(CompilerClassLoader ccl)
{
TypeBuilder tb = ccl.GetTypeWrapperFactory().ModuleBuilder.DefineType("ikvm.internal.ClassLiteral`1", TypeAttributes.Public | TypeAttributes.Sealed | TypeAttributes.Abstract | TypeAttributes.Class | TypeAttributes.BeforeFieldInit);
GenericTypeParameterBuilder typeParam = tb.DefineGenericParameters("T")[0];
Type classType = CoreClasses.java.lang.Class.Wrapper.TypeAsSignatureType;
classLiteralField = tb.DefineField("Value", classType, FieldAttributes.Public | FieldAttributes.Static | FieldAttributes.InitOnly);
CodeEmitter ilgen = CodeEmitter.Create(ReflectUtil.DefineTypeInitializer(tb));
ilgen.Emit(OpCodes.Ldtoken, typeParam);
ilgen.Emit(OpCodes.Call, Types.Type.GetMethod("GetTypeFromHandle", new Type[] { Types.RuntimeTypeHandle }));
MethodWrapper mw = CoreClasses.java.lang.Class.Wrapper.GetMethodWrapper("<init>", "(Lcli.System.Type;)V", false);
mw.Link();
mw.EmitNewobj(ilgen);
ilgen.Emit(OpCodes.Stsfld, classLiteralField);
ilgen.Emit(OpCodes.Ret);
ilgen.DoEmit();
classLiteralType = tb.CreateType();
}
private static void Create(CompilerClassLoader loader, string proxy, TypeWrapper[] interfaces)
{
List <ProxyMethod> methods;
try
{
methods = CheckAndCollect(loader, interfaces);
}
catch (RetargetableJavaException x)
{
StaticCompiler.IssueMessage(Message.UnableToCreateProxy, proxy, x.Message);
return;
}
catch (ProxyException x)
{
StaticCompiler.IssueMessage(Message.UnableToCreateProxy, proxy, x.Message);
return;
}
CreateNoFail(loader, interfaces, methods);
}
internal static void Create(CompilerClassLoader loader, string proxy)
{
string[] interfaces = proxy.Split(',');
TypeWrapper[] wrappers = new TypeWrapper[interfaces.Length];
for (int i = 0; i < interfaces.Length; i++)
{
try
{
wrappers[i] = loader.LoadClassByDottedNameFast(interfaces[i]);
}
catch (RetargetableJavaException)
{
}
if (wrappers[i] == null)
{
StaticCompiler.IssueMessage(Message.UnableToCreateProxy, proxy, "unable to load interface " + interfaces[i]);
return;
}
}
Create(loader, proxy, wrappers);
}
internal static void Create(CompilerClassLoader ccl)
{
EmitClassLiteral(ccl);
}
static int Main(string[] args)
{
DateTime start = DateTime.Now;
System.Threading.Thread.CurrentThread.Name = "compiler";
Tracer.EnableTraceConsoleListener();
Tracer.EnableTraceForDebug();
List <string> argList = GetArgs(args);
if (argList.Count == 0)
{
PrintHelp();
return(1);
}
IkvmcCompiler comp = new IkvmcCompiler();
List <CompilerOptions> targets = new List <CompilerOptions>();
CompilerOptions toplevel = new CompilerOptions();
StaticCompiler.toplevel = toplevel;
int rc = comp.ParseCommandLine(argList.GetEnumerator(), targets, toplevel);
if (rc == 0)
{
resolver.Warning += new AssemblyResolver.WarningEvent(loader_Warning);
resolver.Init(StaticCompiler.Universe, nostdlib, toplevel.unresolvedReferences, libpaths);
}
if (rc == 0)
{
rc = ResolveReferences(targets);
}
if (rc == 0)
{
rc = ResolveStrongNameKeys(targets);
}
if (rc == 0)
{
try
{
if (targets.Count == 0)
{
Console.Error.WriteLine("Error: no target founds");
rc = 1;
}
else
{
try
{
rc = CompilerClassLoader.Compile(runtimeAssembly, targets);
}
catch (FileFormatLimitationExceededException x)
{
Console.Error.WriteLine("Error: {0}", x.Message);
rc = 1;
}
}
}
catch (Exception x)
{
Console.Error.WriteLine(x);
rc = 1;
}
}
if (time)
{
Console.WriteLine("Total cpu time: {0}", System.Diagnostics.Process.GetCurrentProcess().TotalProcessorTime);
Console.WriteLine("User cpu time: {0}", System.Diagnostics.Process.GetCurrentProcess().UserProcessorTime);
Console.WriteLine("Total wall clock time: {0}", DateTime.Now - start);
Console.WriteLine("Peak virtual memory: {0}", System.Diagnostics.Process.GetCurrentProcess().PeakVirtualMemorySize64);
for (int i = 0; i <= GC.MaxGeneration; i++)
{
Console.WriteLine("GC({0}) count: {1}", i, GC.CollectionCount(i));
}
}
return(rc);
}
private static void CreateMethod(CompilerClassLoader loader, TypeBuilder tb, ProxyMethod pm)
{
MethodBuilder mb = pm.mw.GetDefineMethodHelper().DefineMethod(loader.GetTypeWrapperFactory(), tb, pm.mw.Name, MethodAttributes.Public | MethodAttributes.Virtual | MethodAttributes.Final);
List <string> exceptions = new List <string>();
foreach (TypeWrapper tw in pm.exceptions)
{
exceptions.Add(tw.Name);
}
AttributeHelper.SetThrowsAttribute(mb, exceptions.ToArray());
CodeEmitter ilgen = CodeEmitter.Create(mb);
ilgen.BeginExceptionBlock();
ilgen.Emit(OpCodes.Ldarg_0);
invocationHandlerField.EmitGet(ilgen);
ilgen.Emit(OpCodes.Ldarg_0);
ilgen.Emit(OpCodes.Ldsfld, pm.fb);
TypeWrapper[] parameters = pm.mw.GetParameters();
if (parameters.Length == 0)
{
ilgen.Emit(OpCodes.Ldnull);
}
else
{
ilgen.EmitLdc_I4(parameters.Length);
ilgen.Emit(OpCodes.Newarr, Types.Object);
for (int i = 0; i < parameters.Length; i++)
{
ilgen.Emit(OpCodes.Dup);
ilgen.EmitLdc_I4(i);
ilgen.EmitLdarg(i);
if (parameters[i].IsNonPrimitiveValueType)
{
parameters[i].EmitBox(ilgen);
}
else if (parameters[i].IsPrimitive)
{
Boxer.EmitBox(ilgen, parameters[i]);
}
ilgen.Emit(OpCodes.Stelem_Ref);
}
}
invokeMethod.EmitCallvirt(ilgen);
TypeWrapper returnType = pm.mw.ReturnType;
CodeEmitterLocal returnValue = null;
if (returnType != PrimitiveTypeWrapper.VOID)
{
returnValue = ilgen.DeclareLocal(returnType.TypeAsSignatureType);
if (returnType.IsNonPrimitiveValueType)
{
returnType.EmitUnbox(ilgen);
}
else if (returnType.IsPrimitive)
{
Boxer.EmitUnbox(ilgen, returnType);
}
else if (returnType != CoreClasses.java.lang.Object.Wrapper)
{
ilgen.EmitCastclass(returnType.TypeAsSignatureType);
}
ilgen.Emit(OpCodes.Stloc, returnValue);
}
CodeEmitterLabel returnLabel = ilgen.DefineLabel();
ilgen.EmitLeave(returnLabel);
// TODO consider using a filter here (but we would need to add filter support to CodeEmitter)
ilgen.BeginCatchBlock(Types.Exception);
ilgen.EmitLdc_I4(0);
ilgen.Emit(OpCodes.Call, ByteCodeHelperMethods.mapException.MakeGenericMethod(Types.Exception));
CodeEmitterLocal exception = ilgen.DeclareLocal(Types.Exception);
ilgen.Emit(OpCodes.Stloc, exception);
CodeEmitterLabel rethrow = ilgen.DefineLabel();
ilgen.Emit(OpCodes.Ldloc, exception);
errorClass.EmitInstanceOf(ilgen);
ilgen.EmitBrtrue(rethrow);
ilgen.Emit(OpCodes.Ldloc, exception);
runtimeExceptionClass.EmitInstanceOf(ilgen);
ilgen.EmitBrtrue(rethrow);
foreach (TypeWrapper tw in pm.exceptions)
{
ilgen.Emit(OpCodes.Ldloc, exception);
tw.EmitInstanceOf(ilgen);
ilgen.EmitBrtrue(rethrow);
}
ilgen.Emit(OpCodes.Ldloc, exception);
undeclaredThrowableExceptionConstructor.EmitNewobj(ilgen);
ilgen.Emit(OpCodes.Throw);
ilgen.MarkLabel(rethrow);
ilgen.Emit(OpCodes.Rethrow);
ilgen.EndExceptionBlock();
ilgen.MarkLabel(returnLabel);
if (returnValue != null)
{
ilgen.Emit(OpCodes.Ldloc, returnValue);
}
ilgen.Emit(OpCodes.Ret);
ilgen.DoEmit();
}
private static void CreateStaticInitializer(TypeBuilder tb, List <ProxyMethod> methods, CompilerClassLoader loader)
{
CodeEmitter ilgen = CodeEmitter.Create(ReflectUtil.DefineTypeInitializer(tb, loader));
CodeEmitterLocal callerID = ilgen.DeclareLocal([email protected]);
TypeBuilder tbCallerID = DynamicTypeWrapper.FinishContext.EmitCreateCallerID(tb, ilgen);
ilgen.Emit(OpCodes.Stloc, callerID);
// HACK we shouldn't create the nested type here (the outer type must be created first)
tbCallerID.CreateType();
ilgen.BeginExceptionBlock();
foreach (ProxyMethod method in methods)
{
method.mw.DeclaringType.EmitClassLiteral(ilgen);
ilgen.Emit(OpCodes.Ldstr, method.mw.Name);
TypeWrapper[] parameters = method.mw.GetParameters();
ilgen.EmitLdc_I4(parameters.Length);
ilgen.Emit(OpCodes.Newarr, CoreClasses.java.lang.Class.Wrapper.TypeAsArrayType);
for (int i = 0; i < parameters.Length; i++)
{
ilgen.Emit(OpCodes.Dup);
ilgen.EmitLdc_I4(i);
parameters[i].EmitClassLiteral(ilgen);
ilgen.Emit(OpCodes.Stelem_Ref);
}
if (javaLangClass_getMethod.HasCallerID)
{
ilgen.Emit(OpCodes.Ldloc, callerID);
}
javaLangClass_getMethod.EmitCallvirt(ilgen);
ilgen.Emit(OpCodes.Stsfld, method.fb);
}
CodeEmitterLabel label = ilgen.DefineLabel();
ilgen.EmitLeave(label);
ilgen.BeginCatchBlock(javaLangNoSuchMethodException.TypeAsExceptionType);
javaLangThrowable_getMessage.EmitCallvirt(ilgen);
javaLangNoClassDefFoundErrorConstructor.EmitNewobj(ilgen);
ilgen.Emit(OpCodes.Throw);
ilgen.EndExceptionBlock();
ilgen.MarkLabel(label);
ilgen.Emit(OpCodes.Ret);
ilgen.DoEmit();
}
