942 lines
26 KiB
C#
Executable File
942 lines
26 KiB
C#
Executable File
using System.Collections.Concurrent;
|
|
using System.Diagnostics;
|
|
using System.Reflection;
|
|
using System.Reflection.Emit;
|
|
using System.Runtime.CompilerServices;
|
|
using JCIL.CLI.Types;
|
|
using JCIL.CLI.Types.java.lang;
|
|
using JCIL.Java.Class;
|
|
using Array = System.Array;
|
|
using OpCode = JCIL.Java.Class.OpCode;
|
|
|
|
namespace JCIL.CLI;
|
|
|
|
public sealed class AssemblyBuilder
|
|
{
|
|
public readonly System.Reflection.Emit.AssemblyBuilder Assembly;
|
|
private readonly ModuleBuilder _module;
|
|
private readonly ConcurrentDictionary<Class, TypeSurrogate> _classes = [];
|
|
private readonly ConcurrentDictionary<Field, FieldInfo> _fields = [];
|
|
private readonly ConcurrentDictionary<Method, LazyMethod> _methods = [];
|
|
|
|
public int CompiledMethods { get; private set; }
|
|
public int TotalMethods => _methods.Count;
|
|
|
|
public AssemblyBuilder(AssemblyName name, bool runnable)
|
|
{
|
|
Assembly = runnable
|
|
? System.Reflection.Emit.AssemblyBuilder.DefineDynamicAssembly(name, AssemblyBuilderAccess.RunAndCollect)
|
|
: new PersistedAssemblyBuilder(name, typeof(int).Assembly);
|
|
|
|
_module = Assembly.DefineDynamicModule("JCIL_Output");
|
|
}
|
|
|
|
public TypeSurrogate MakeType(Class javaClass)
|
|
{
|
|
if (_classes.TryGetValue(javaClass, out var type))
|
|
return type;
|
|
|
|
switch (javaClass.SpecialClassMetadata)
|
|
{
|
|
case IntrinsicMetadata intrinsic:
|
|
{
|
|
switch (intrinsic.Type)
|
|
{
|
|
case IntrinsicType.Byte:
|
|
return _classes.GetOrAdd(javaClass, c => new JCIL.CLI.Types.Java.Lang.Byte(c));
|
|
case IntrinsicType.Char:
|
|
return _classes.GetOrAdd(javaClass, c => new JCIL.CLI.Types.Java.Lang.Char(c));
|
|
case IntrinsicType.Int:
|
|
return _classes.GetOrAdd(javaClass, c => new JCIL.CLI.Types.Java.Lang.Integer(c));
|
|
case IntrinsicType.Short:
|
|
return _classes.GetOrAdd(javaClass, c => new JCIL.CLI.Types.Java.Lang.Short(c));
|
|
case IntrinsicType.Long:
|
|
return _classes.GetOrAdd(javaClass, c => new JCIL.CLI.Types.Java.Lang.Long(c));
|
|
case IntrinsicType.Boolean:
|
|
return _classes.GetOrAdd(javaClass, c => new JCIL.CLI.Types.Java.Lang.Boolean(c));
|
|
case IntrinsicType.Float:
|
|
return _classes.GetOrAdd(javaClass, c => new JCIL.CLI.Types.Java.Lang.Float(c));
|
|
case IntrinsicType.Double:
|
|
return _classes.GetOrAdd(javaClass, c => new JCIL.CLI.Types.Java.Lang.Double(c));
|
|
case IntrinsicType.Void:
|
|
return _classes.GetOrAdd(javaClass, c => new JCIL.CLI.Types.Java.Lang.Void(c));
|
|
default: throw new NotImplementedException($"Unimplemented Intrinsic {intrinsic.Type}");
|
|
}
|
|
}
|
|
case ArrayMetadata array:
|
|
return _classes.GetOrAdd(javaClass, c => new ArrayOf(MakeType(array.ElementClass), c));
|
|
}
|
|
|
|
if(javaClass is {Namespace.Span: "java/lang", Name.Span: "String" })
|
|
return _classes.GetOrAdd(javaClass, c => new JCIL.CLI.Types.Java.Lang.String(c));
|
|
|
|
var newClass = (NewClass)_classes.GetOrAdd(javaClass, _ =>
|
|
{
|
|
TypeAttributes flags = default;
|
|
if ((javaClass.AccessFlags & ClassAccessFlags.Public) != 0) flags |= TypeAttributes.Public;
|
|
if ((javaClass.AccessFlags & ClassAccessFlags.Abstract) != 0) flags |= TypeAttributes.Abstract;
|
|
if ((javaClass.AccessFlags & ClassAccessFlags.Final) != 0) flags |= TypeAttributes.Sealed;
|
|
if ((javaClass.AccessFlags & ClassAccessFlags.Interface) != 0) flags |= TypeAttributes.Interface;
|
|
var name = javaClass.Namespace.IsEmpty
|
|
? javaClass.Name.ToString()
|
|
: $"{javaClass.Namespace.ToString().Replace('/', '.')}.{javaClass.Name}";
|
|
var builder = _module.DefineType(name, flags);
|
|
return new NewClass(this, builder, javaClass);
|
|
});
|
|
|
|
if (javaClass.SuperClass is {} super)
|
|
newClass.Type.SetParent(MakeType(super).Type);
|
|
|
|
newClass.CreateFields();
|
|
return newClass;
|
|
}
|
|
|
|
internal void CompileOpCodes(Class javaClass, MethodBase methodBase, ILGenerator il, Code code,
|
|
OpCodeReader opcodes)
|
|
{
|
|
var thisType = methodBase.DeclaringType!;
|
|
if (methodBase is MethodBuilder methodBuilder)
|
|
{
|
|
var ret = methodBuilder.ReturnType;
|
|
var par = methodBuilder.GetParameters().Select(v => v.ParameterType.Name);
|
|
var stc = methodBase.IsStatic ? "static " : string.Empty;
|
|
Debug.Writer.WriteLine($"Compiling `{stc}{ret.Name} {thisType.FullName}.{methodBase.Name}({string.Join(", ", par)})`");
|
|
}
|
|
else
|
|
{
|
|
var par = methodBase.GetParameters().Select(v => v.ParameterType.Name);
|
|
Debug.Writer.WriteLine($"Compiling `{thisType.FullName}({string.Join(", ", par)})`");
|
|
}
|
|
Debug.Writer.Indent++;
|
|
|
|
var labels = CreateLabels(il, opcodes);
|
|
var position = opcodes.Reader.Stream.Position;
|
|
var stack = new Stack<Value>(code.MaxStack);
|
|
var locals = new Value[code.MaxLocals];
|
|
var localCount = 0;
|
|
|
|
int AssignLocal(int idx, Value value)
|
|
{
|
|
if (value.Type == typeof(long) || value.Type == typeof(double))
|
|
{
|
|
locals[idx] = value;
|
|
locals[idx + 1] = value;
|
|
return 2;
|
|
}
|
|
locals[idx] = value;
|
|
return 1;
|
|
}
|
|
|
|
{
|
|
var idx = 0;
|
|
if (!methodBase.IsStatic)
|
|
idx += AssignLocal(idx, Value.Parameter(thisType, idx));
|
|
|
|
foreach (var parameter in methodBase.GetParameters())
|
|
idx += AssignLocal(idx, Value.Parameter(parameter.ParameterType, idx));
|
|
}
|
|
|
|
void CompileOpCode(long position, OpCode opcode)
|
|
{
|
|
Debug.Writer.WriteLine($"IL_{position:X04}: {opcode.ToString(javaClass)}");
|
|
|
|
Label JmpLabel()
|
|
{
|
|
return labels[position + (short)opcode.P0.UShort];
|
|
}
|
|
|
|
void AssertCast(Value value, Type type)
|
|
{
|
|
if(value.Type == type) return;
|
|
|
|
if (type == typeof(int))
|
|
{
|
|
if (value.Type == typeof(byte) || value.Type == typeof(short) || value.Type == typeof(char) || value.Type == typeof(bool))
|
|
{
|
|
il.Emit(OpCodes.Conv_I4);
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (type == typeof(byte))
|
|
{
|
|
if (value.Type == typeof(int) || value.Type == typeof(short) || value.Type == typeof(char))
|
|
{
|
|
il.Emit(OpCodes.Conv_I1);
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (value.Type.IsAssignableTo(type))
|
|
return;
|
|
|
|
if(type == typeof(object) && value.Type.IsArray)
|
|
return;
|
|
|
|
|
|
throw new InvalidOperationException($"Value of type `{value.Type}` cannot be assigned to one of type `{type}`.");
|
|
}
|
|
|
|
switch (opcode.Mnemonic)
|
|
{
|
|
case OpCodeMnemonic.AConstNull:
|
|
stack.Push(new Value(typeof(object)));
|
|
il.Emit(OpCodes.Ldnull);
|
|
break;
|
|
|
|
case OpCodeMnemonic.IConst0:
|
|
case OpCodeMnemonic.IConst1:
|
|
case OpCodeMnemonic.IConst2:
|
|
case OpCodeMnemonic.IConst3:
|
|
case OpCodeMnemonic.IConst4:
|
|
case OpCodeMnemonic.IConst5:
|
|
stack.Push(new Value(opcode.Mnemonic - OpCodeMnemonic.IConst0));
|
|
break;
|
|
|
|
case OpCodeMnemonic.LConst0:
|
|
stack.Push(new Value(typeof(long)));
|
|
il.Emit(OpCodes.Ldc_I8, 0L);
|
|
break;
|
|
|
|
case OpCodeMnemonic.LConst1:
|
|
stack.Push(new Value(typeof(long)));
|
|
il.Emit(OpCodes.Ldc_I8, 1L);
|
|
break;
|
|
|
|
case OpCodeMnemonic.PushByte: stack.Push(new Value(opcode.P0.Byte).Load(il)); break;
|
|
case OpCodeMnemonic.PushShort: stack.Push(new Value((short)opcode.P0.UShort).Load(il)); break;
|
|
|
|
case OpCodeMnemonic.Ldc:
|
|
case OpCodeMnemonic.LdcW:
|
|
{
|
|
var constant = javaClass.GetConstant<object>(opcode.P0.UShort);
|
|
switch (constant)
|
|
{
|
|
case int val: stack.Push(new Value(val).Load(il)); break;
|
|
case string val: stack.Push(new Value(val).Load(il)); break;
|
|
case Class val: stack.Push(Value.TypeRef(MakeType(val).Type).Load(il)); break;
|
|
default:
|
|
{
|
|
throw new NotImplementedException(
|
|
$"Unknown opcode: {opcode.Mnemonic} {constant.GetType()}");
|
|
}
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
case OpCodeMnemonic.ILoad:
|
|
case OpCodeMnemonic.ILoad0:
|
|
case OpCodeMnemonic.ILoad1:
|
|
case OpCodeMnemonic.ILoad2:
|
|
case OpCodeMnemonic.ILoad3:
|
|
{
|
|
var idx = opcode.Mnemonic switch
|
|
{
|
|
OpCodeMnemonic.ILoad0 => 0,
|
|
OpCodeMnemonic.ILoad1 => 1,
|
|
OpCodeMnemonic.ILoad2 => 2,
|
|
OpCodeMnemonic.ILoad3 => 3,
|
|
OpCodeMnemonic.ILoad => opcode.P0.UShort,
|
|
_ => -1,
|
|
};
|
|
|
|
ref var loc = ref locals[idx];
|
|
AssertCast(loc, typeof(int));
|
|
stack.Push(loc.Load(il));
|
|
break;
|
|
}
|
|
|
|
case OpCodeMnemonic.LLoad:
|
|
case OpCodeMnemonic.LLoad0:
|
|
case OpCodeMnemonic.LLoad1:
|
|
case OpCodeMnemonic.LLoad2:
|
|
case OpCodeMnemonic.LLoad3:
|
|
{
|
|
var idx = opcode.Mnemonic switch
|
|
{
|
|
OpCodeMnemonic.LLoad0 => 0,
|
|
OpCodeMnemonic.LLoad1 => 1,
|
|
OpCodeMnemonic.LLoad2 => 2,
|
|
OpCodeMnemonic.LLoad3 => 3,
|
|
OpCodeMnemonic.LLoad => opcode.P0.UShort,
|
|
_ => -1,
|
|
};
|
|
|
|
ref var loc = ref locals[idx];
|
|
AssertCast(loc, typeof(long));
|
|
stack.Push(loc.Load(il));
|
|
break;
|
|
}
|
|
|
|
case OpCodeMnemonic.ALoad:
|
|
case OpCodeMnemonic.ALoad0:
|
|
case OpCodeMnemonic.ALoad1:
|
|
case OpCodeMnemonic.ALoad2:
|
|
case OpCodeMnemonic.ALoad3:
|
|
{
|
|
var idx = opcode.Mnemonic switch
|
|
{
|
|
OpCodeMnemonic.ALoad0 => 0,
|
|
OpCodeMnemonic.ALoad1 => 1,
|
|
OpCodeMnemonic.ALoad2 => 2,
|
|
OpCodeMnemonic.ALoad3 => 3,
|
|
OpCodeMnemonic.ALoad => opcode.P0.UShort,
|
|
_ => -1,
|
|
};
|
|
|
|
if (locals[idx].Type is { IsClass: false, IsInterface: false })
|
|
throw new InvalidOperationException($"Local {idx} ({locals[idx].Type}) is not a class.");
|
|
|
|
stack.Push(locals[idx].Load(il));
|
|
break;
|
|
}
|
|
|
|
case OpCodeMnemonic.AALoad:
|
|
{
|
|
var idx = stack.Pop();
|
|
var array = stack.Pop();
|
|
|
|
AssertIntCompatible(idx);
|
|
AssertArray(array.Type);
|
|
|
|
if (array.Type.GetElementType() is not { IsClass: true } elementType)
|
|
throw new InvalidOperationException("Array element is not an object.");
|
|
|
|
il.Emit(OpCodes.Ldelem_Ref, elementType);
|
|
stack.Push(new Value(elementType));
|
|
break;
|
|
}
|
|
|
|
case OpCodeMnemonic.IStore:
|
|
case OpCodeMnemonic.IStore0:
|
|
case OpCodeMnemonic.IStore1:
|
|
case OpCodeMnemonic.IStore2:
|
|
case OpCodeMnemonic.IStore3:
|
|
{
|
|
var value = stack.Pop();
|
|
AssertCast(value, typeof(int));
|
|
var idx = opcode.Mnemonic switch
|
|
{
|
|
OpCodeMnemonic.IStore => opcode.P0.UShort,
|
|
_ => opcode.Mnemonic - OpCodeMnemonic.IStore0,
|
|
};
|
|
ref var loc = ref locals[idx];
|
|
if (loc.Type != typeof(int))
|
|
{
|
|
il.DeclareLocal(typeof(int));
|
|
AssignLocal(idx, Value.Local(typeof(int), localCount++));
|
|
}
|
|
loc.Store(il);
|
|
break;
|
|
}
|
|
|
|
case OpCodeMnemonic.LStore:
|
|
case OpCodeMnemonic.LStore0:
|
|
case OpCodeMnemonic.LStore1:
|
|
case OpCodeMnemonic.LStore2:
|
|
case OpCodeMnemonic.LStore3:
|
|
{
|
|
var value = stack.Pop();
|
|
AssertCast(value, typeof(long));
|
|
var idx = opcode.Mnemonic switch
|
|
{
|
|
OpCodeMnemonic.LStore => opcode.P0.UShort,
|
|
_ => opcode.Mnemonic - OpCodeMnemonic.LStore0,
|
|
};
|
|
ref var loc = ref locals[idx];
|
|
if (loc.Type != typeof(long))
|
|
{
|
|
il.DeclareLocal(typeof(long));
|
|
AssignLocal(idx, Value.Local(typeof(long), localCount++));
|
|
}
|
|
loc.Store(il);
|
|
break;
|
|
}
|
|
|
|
case OpCodeMnemonic.AStore:
|
|
case OpCodeMnemonic.AStore0:
|
|
case OpCodeMnemonic.AStore1:
|
|
case OpCodeMnemonic.AStore2:
|
|
case OpCodeMnemonic.AStore3:
|
|
{
|
|
var value = stack.Pop();
|
|
AssertCast(value, typeof(object));
|
|
var idx = opcode.Mnemonic switch
|
|
{
|
|
OpCodeMnemonic.AStore => opcode.P0.UShort,
|
|
_ => opcode.Mnemonic - OpCodeMnemonic.AStore0,
|
|
};
|
|
ref var loc = ref locals[idx];
|
|
if (!value.Type.IsAssignableTo(loc.Type))
|
|
{
|
|
il.DeclareLocal(value.Type);
|
|
AssignLocal(idx, Value.Local(value.Type, localCount++));
|
|
}
|
|
loc.Store(il);
|
|
break;
|
|
}
|
|
|
|
case OpCodeMnemonic.AAStore:
|
|
{
|
|
var value = stack.Pop();
|
|
var idx = stack.Pop();
|
|
var array = stack.Pop();
|
|
AssertArray(array);
|
|
AssertIntCompatible(idx);
|
|
|
|
var eType = array.Type.GetElementType()!;
|
|
AssertCast(value, eType);
|
|
il.Emit(OpCodes.Stelem_Ref);
|
|
break;
|
|
}
|
|
|
|
case OpCodeMnemonic.Pop:
|
|
{
|
|
stack.Pop();
|
|
il.Emit(OpCodes.Pop);
|
|
break;
|
|
}
|
|
|
|
case OpCodeMnemonic.Dup:
|
|
{
|
|
var value = stack.Pop();
|
|
stack.Push(value);
|
|
stack.Push(value);
|
|
il.Emit(OpCodes.Dup);
|
|
break;
|
|
}
|
|
|
|
case OpCodeMnemonic.IAdd:
|
|
case OpCodeMnemonic.ISub:
|
|
case OpCodeMnemonic.IMul:
|
|
case OpCodeMnemonic.IDiv:
|
|
case OpCodeMnemonic.IRem:
|
|
case OpCodeMnemonic.IOr:
|
|
case OpCodeMnemonic.IAnd:
|
|
case OpCodeMnemonic.IShr:
|
|
case OpCodeMnemonic.IShl:
|
|
case OpCodeMnemonic.IUShr:
|
|
{
|
|
var a = stack.Pop();
|
|
var b = stack.Pop();
|
|
AssertIntCompatible(a.Type);
|
|
AssertIntCompatible(b.Type);
|
|
il.Emit(opcode.Mnemonic switch
|
|
{
|
|
OpCodeMnemonic.IAdd => OpCodes.Add,
|
|
OpCodeMnemonic.ISub => OpCodes.Sub,
|
|
OpCodeMnemonic.IMul => OpCodes.Mul,
|
|
OpCodeMnemonic.IDiv => OpCodes.Div,
|
|
OpCodeMnemonic.IRem => OpCodes.Rem,
|
|
OpCodeMnemonic.IOr => OpCodes.Or,
|
|
OpCodeMnemonic.IAnd => OpCodes.And,
|
|
OpCodeMnemonic.IShr => OpCodes.Shr,
|
|
OpCodeMnemonic.IShl => OpCodes.Shl,
|
|
OpCodeMnemonic.IUShr => OpCodes.Shr_Un,
|
|
_ => throw new UnreachableException(),
|
|
});
|
|
stack.Push(new Value(typeof(int)));
|
|
break;
|
|
}
|
|
|
|
case OpCodeMnemonic.LAdd:
|
|
case OpCodeMnemonic.LSub:
|
|
case OpCodeMnemonic.LMul:
|
|
case OpCodeMnemonic.LDiv:
|
|
case OpCodeMnemonic.LRem:
|
|
case OpCodeMnemonic.LOr:
|
|
case OpCodeMnemonic.LAnd:
|
|
{
|
|
var a = stack.Pop();
|
|
var b = stack.Pop();
|
|
AssertLongCompatible(a.Type);
|
|
AssertLongCompatible(b.Type);
|
|
il.Emit(opcode.Mnemonic switch
|
|
{
|
|
OpCodeMnemonic.LAdd => OpCodes.Add,
|
|
OpCodeMnemonic.LSub => OpCodes.Sub,
|
|
OpCodeMnemonic.LMul => OpCodes.Mul,
|
|
OpCodeMnemonic.LDiv => OpCodes.Div,
|
|
OpCodeMnemonic.LRem => OpCodes.Rem,
|
|
OpCodeMnemonic.LOr => OpCodes.Or,
|
|
OpCodeMnemonic.LAnd => OpCodes.And,
|
|
_ => throw new UnreachableException(),
|
|
});
|
|
stack.Push(new Value(typeof(long)));
|
|
break;
|
|
}
|
|
|
|
|
|
case OpCodeMnemonic.IfEq:
|
|
{
|
|
var value = stack.Pop();
|
|
AssertLongCompatible(value.Type);
|
|
il.Emit(OpCodes.Brfalse, JmpLabel());
|
|
break;
|
|
}
|
|
|
|
case OpCodeMnemonic.IfNe:
|
|
{
|
|
var value = stack.Pop();
|
|
AssertLongCompatible(value.Type);
|
|
il.Emit(OpCodes.Brtrue, JmpLabel());
|
|
break;
|
|
}
|
|
|
|
case OpCodeMnemonic.IfLt:
|
|
{
|
|
var value = stack.Pop();
|
|
AssertLongCompatible(value.Type);
|
|
il.Emit(OpCodes.Ldc_I4_0);
|
|
il.Emit(OpCodes.Clt);
|
|
il.Emit(OpCodes.Brtrue, JmpLabel());
|
|
break;
|
|
}
|
|
|
|
case OpCodeMnemonic.IfGe:
|
|
{
|
|
var value = stack.Pop();
|
|
AssertLongCompatible(value.Type);
|
|
il.Emit(OpCodes.Dup);
|
|
il.Emit(OpCodes.Ldc_I4_0);
|
|
il.Emit(OpCodes.Cgt);
|
|
il.Emit(OpCodes.Brtrue, JmpLabel());
|
|
il.Emit(OpCodes.Brfalse, JmpLabel());
|
|
break;
|
|
}
|
|
|
|
case OpCodeMnemonic.IfACmpNe:
|
|
{
|
|
if (!stack.Pop().Type.IsClass || !stack.Pop().Type.IsClass)
|
|
throw new InvalidOperationException("Value is not an object.");
|
|
|
|
il.Emit(OpCodes.Ceq);
|
|
il.Emit(OpCodes.Brfalse, JmpLabel());
|
|
break;
|
|
}
|
|
|
|
case OpCodeMnemonic.Goto:
|
|
{
|
|
il.Emit(OpCodes.Br, JmpLabel());
|
|
break;
|
|
}
|
|
|
|
case OpCodeMnemonic.IReturn:
|
|
case OpCodeMnemonic.LReturn:
|
|
case OpCodeMnemonic.FReturn:
|
|
case OpCodeMnemonic.DReturn:
|
|
case OpCodeMnemonic.AReturn:
|
|
{
|
|
var value = stack.Pop();
|
|
il.Emit(OpCodes.Ret);
|
|
break;
|
|
}
|
|
|
|
case OpCodeMnemonic.Return:
|
|
{
|
|
il.Emit(OpCodes.Ret);
|
|
break;
|
|
}
|
|
|
|
case OpCodeMnemonic.GetStaticField:
|
|
{
|
|
var fieldRef = javaClass.GetConstant<FieldRef>(opcode.P0.UShort);
|
|
var parent = MakeType(fieldRef.Class);
|
|
var field = parent.GetField(fieldRef.Field.Name);
|
|
stack.Push(new Value(field).Load(il));
|
|
break;
|
|
}
|
|
|
|
case OpCodeMnemonic.GetField:
|
|
{
|
|
var fieldRef = javaClass.GetConstant<FieldRef>(opcode.P0.UShort);
|
|
var parent = MakeType(fieldRef.Class);
|
|
var field = parent.GetField(fieldRef.Field.Name);
|
|
|
|
var value = stack.Pop();
|
|
if (!value.Type.IsAssignableTo(parent.Type))
|
|
throw new InvalidOperationException($"Value is not compatible with type {parent}.");
|
|
|
|
stack.Push(new Value(field).Load(il));
|
|
break;
|
|
}
|
|
|
|
case OpCodeMnemonic.SetField:
|
|
{
|
|
var fieldRef = javaClass.GetConstant<FieldRef>(opcode.P0.UShort);
|
|
var parent = MakeType(fieldRef.Class);
|
|
var field = parent.GetField(fieldRef.Field.Name);
|
|
var value = stack.Pop();
|
|
|
|
AssertCast(value, field.FieldType);
|
|
il.Emit(OpCodes.Stfld, field);
|
|
break;
|
|
}
|
|
|
|
case OpCodeMnemonic.InvokeVirtual:
|
|
case OpCodeMnemonic.InvokeSpecial:
|
|
case OpCodeMnemonic.InvokeStatic:
|
|
{
|
|
var methodRef = javaClass.GetConstant<MethodRef>(opcode.P0.UShort);
|
|
var parent = MakeType(methodRef.Class);
|
|
|
|
var signature = (MethodSignature)javaClass.Loader.GetClass(methodRef.Method.Descriptor.AsMemory())
|
|
.SpecialClassMetadata!;
|
|
|
|
for (var i = 0; i < signature.ParamTypes.Count; i++) stack.Pop();
|
|
stack.Push(new Value(parent.CallMethod(methodRef.Method.Name, signature, il)));
|
|
break;
|
|
}
|
|
|
|
case OpCodeMnemonic.New:
|
|
{
|
|
var type = MakeType(javaClass.GetConstant<Class>(opcode.P0.UShort));
|
|
var posBackup = opcodes.Reader.Stream.Position;
|
|
var stackBackup = new Stack<Value>(stack);
|
|
opcodes.MoveNext();
|
|
if (opcodes.Current.Mnemonic == OpCodeMnemonic.Dup)
|
|
{
|
|
opcodes.MoveNext();
|
|
position = opcodes.Reader.Stream.Position;
|
|
while (opcodes.Current.Mnemonic != OpCodeMnemonic.InvokeSpecial)
|
|
{
|
|
CompileOpCode(position, opcodes.Current);
|
|
opcodes.MoveNext();
|
|
position = opcodes.Reader.Stream.Position;
|
|
}
|
|
|
|
var methodRef = javaClass.GetConstant<MethodRef>(opcodes.Current.P0.UShort);
|
|
var parent = MakeType(methodRef.Class);
|
|
|
|
var signature = (MethodSignature)javaClass.Loader
|
|
.GetClass(methodRef.Method.Descriptor.AsMemory())
|
|
.SpecialClassMetadata!;
|
|
|
|
var ctor = (ConstructorInfo)parent.GetMethod(methodRef.Method.Name, signature);
|
|
while (stack.Count > stackBackup.Count) stack.Pop();
|
|
il.Emit(OpCodes.Newobj, ctor);
|
|
stack.Push(new Value(parent.Type));
|
|
break;
|
|
}
|
|
|
|
opcodes.Reader.Stream.Position = posBackup;
|
|
stack = stackBackup;
|
|
var func = RuntimeHelpers.GetUninitializedObject;
|
|
il.Emit(OpCodes.Ldtoken, type.Type);
|
|
il.Emit(OpCodes.Call, func.Method);
|
|
stack.Push(new Value(type.Type));
|
|
break;
|
|
}
|
|
|
|
case OpCodeMnemonic.ANewArray:
|
|
{
|
|
var len = stack.Pop();
|
|
AssertIntCompatible(len.Type);
|
|
var type = MakeType(javaClass.GetConstant<Class>(opcode.P0.UShort));
|
|
il.Emit(OpCodes.Newarr, type.Type);
|
|
stack.Push(new Value(type.Type.MakeArrayType()));
|
|
break;
|
|
}
|
|
|
|
case OpCodeMnemonic.NewArray:
|
|
{
|
|
var elementType = opcode.P0.Byte switch
|
|
{
|
|
4 => typeof(bool),
|
|
5 => typeof(char),
|
|
6 => typeof(float),
|
|
7 => typeof(double),
|
|
8 => typeof(byte),
|
|
9 => typeof(short),
|
|
10 => typeof(int),
|
|
11 => typeof(long),
|
|
_ => typeof(void),
|
|
};
|
|
il.Emit(OpCodes.Newarr, elementType);
|
|
stack.Push(new Value(elementType.MakeArrayType()));
|
|
break;
|
|
}
|
|
|
|
case OpCodeMnemonic.ArrayLen:
|
|
{
|
|
var value = stack.Pop();
|
|
AssertArray(value.Type);
|
|
il.Emit(OpCodes.Ldlen);
|
|
stack.Push(new Value(typeof(int)));
|
|
break;
|
|
}
|
|
|
|
case OpCodeMnemonic.IfNull:
|
|
{
|
|
AssertClass(stack.Pop().Type);
|
|
il.Emit(OpCodes.Brfalse, JmpLabel());
|
|
break;
|
|
}
|
|
|
|
case OpCodeMnemonic.IfNonNull:
|
|
{
|
|
AssertClass(stack.Pop().Type);
|
|
il.Emit(OpCodes.Brtrue, JmpLabel());
|
|
break;
|
|
}
|
|
|
|
default:
|
|
{
|
|
Console.ForegroundColor = ConsoleColor.Red;
|
|
Console.WriteLine($"Unknown opcode: {opcode.Mnemonic}");
|
|
Console.ResetColor();
|
|
il.Emit(OpCodes.Nop);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
for (; opcodes.MoveNext();)
|
|
{
|
|
il.MarkLabel(labels[position]);
|
|
var opcode = opcodes.Current;
|
|
CompileOpCode(position, opcode);
|
|
position = opcodes.Reader.Stream.Position;
|
|
}
|
|
|
|
Debug.Writer.Indent--;
|
|
CompiledMethods += 1;
|
|
}
|
|
|
|
private static Dictionary<long, Label> CreateLabels(ILGenerator il, OpCodeReader opcodes)
|
|
{
|
|
var start = opcodes.Reader.Stream.Position;
|
|
var position = start;
|
|
var labels = new Dictionary<long, Label>();
|
|
while (opcodes.MoveNext())
|
|
{
|
|
labels.Add(position, il.DefineLabel());
|
|
position = opcodes.Reader.Stream.Position;
|
|
}
|
|
|
|
opcodes.Reader.Stream.Position = start;
|
|
return labels;
|
|
}
|
|
|
|
private static void AssertClass(Type type)
|
|
{
|
|
if (type is { IsClass: false, IsInterface: false })
|
|
throw new InvalidOperationException($"Value of type `{type}` is not an object.");
|
|
}
|
|
|
|
private static void AssertArray(Type type)
|
|
{
|
|
if (!type.IsArray && type != typeof(Array))
|
|
throw new InvalidOperationException($"Value of type `{type}` is not an array.");
|
|
}
|
|
|
|
private static void AssertIntCompatible(Type type)
|
|
{
|
|
if(type == typeof(int)) return;
|
|
if(type == typeof(byte)) return;
|
|
if(type == typeof(char)) return;
|
|
if(type == typeof(short)) return;
|
|
if(type == typeof(bool)) return;
|
|
throw new InvalidOperationException($"Value of type `{type}` is not an integer.");
|
|
}
|
|
|
|
private static void AssertLongCompatible(Type type)
|
|
{
|
|
if(type == typeof(long)) return;
|
|
if(type == typeof(int)) return;
|
|
if(type == typeof(byte)) return;
|
|
if(type == typeof(char)) return;
|
|
if(type == typeof(short)) return;
|
|
if(type == typeof(bool)) return;
|
|
throw new InvalidOperationException($"Value of type `{type}` is not an integer.");
|
|
}
|
|
}
|
|
|
|
internal class LazyMethod(MethodBase method, Action compile)
|
|
{
|
|
public bool Compiled { get; private set; }
|
|
|
|
public MethodBase Method
|
|
{
|
|
get
|
|
{
|
|
if (!Compiled)
|
|
{
|
|
Compiled = true;
|
|
compile();
|
|
}
|
|
|
|
return method;
|
|
}
|
|
}
|
|
}
|
|
|
|
internal readonly struct Value
|
|
{
|
|
public delegate Value LoadDelegate(ILGenerator il, OpCodeParameter data);
|
|
|
|
public delegate void StoreDelegate(ILGenerator il, OpCodeParameter data);
|
|
|
|
public readonly Type Type;
|
|
private LoadDelegate? _load { get; init; }
|
|
private StoreDelegate? _store { get; init; }
|
|
private OpCodeParameter _data { get; init; }
|
|
public static implicit operator Type(Value v) => v.Type;
|
|
|
|
public Value Load(ILGenerator il)
|
|
{
|
|
return _load is { } load ? load(il, _data) : throw new InvalidOperationException("Value cannot be loaded.");
|
|
}
|
|
|
|
public void Store(ILGenerator il)
|
|
{
|
|
if (_store is not {} store) throw new InvalidOperationException("Value cannot be stored.");
|
|
store(il, _data);
|
|
}
|
|
|
|
public Value(Type type)
|
|
{
|
|
Type = type;
|
|
}
|
|
|
|
public Value(int value)
|
|
{
|
|
Type = typeof(int);
|
|
_data = new OpCodeParameter { UInt = (uint)value };
|
|
_load = (il, data) =>
|
|
{
|
|
var val = (int)data.UInt;
|
|
switch (val)
|
|
{
|
|
case 0: il.Emit(OpCodes.Ldc_I4_0); break;
|
|
case 1: il.Emit(OpCodes.Ldc_I4_1); break;
|
|
case 2: il.Emit(OpCodes.Ldc_I4_2); break;
|
|
case 3: il.Emit(OpCodes.Ldc_I4_3); break;
|
|
case 4: il.Emit(OpCodes.Ldc_I4_4); break;
|
|
case 5: il.Emit(OpCodes.Ldc_I4_5); break;
|
|
case 6: il.Emit(OpCodes.Ldc_I4_6); break;
|
|
case 7: il.Emit(OpCodes.Ldc_I4_7); break;
|
|
case 8: il.Emit(OpCodes.Ldc_I4_8); break;
|
|
case -1: il.Emit(OpCodes.Ldc_I4_M1); break;
|
|
case <= 255: il.Emit(OpCodes.Ldc_I4_S, (sbyte)val); break;
|
|
default: il.Emit(OpCodes.Ldc_I4, val); break;
|
|
}
|
|
|
|
return new Value(val);
|
|
};
|
|
}
|
|
|
|
public Value(string value)
|
|
{
|
|
Type = typeof(string);
|
|
_data = new OpCodeParameter { Object = value };
|
|
_load = (il, data) =>
|
|
{
|
|
var val = Unsafe.As<string>(data.Object)!;
|
|
il.Emit(OpCodes.Ldstr, val);
|
|
return new Value(val);
|
|
};
|
|
}
|
|
|
|
public Value(FieldInfo field)
|
|
{
|
|
Type = field.FieldType;
|
|
_data = new OpCodeParameter { Object = field };
|
|
_load = (il, data) =>
|
|
{
|
|
var val = Unsafe.As<FieldInfo>(data.Object)!;
|
|
il.Emit(val.IsStatic ? OpCodes.Ldsfld : OpCodes.Ldfld, val);
|
|
return new Value(val);
|
|
};
|
|
}
|
|
|
|
public static Value TypeRef(Type type)
|
|
{
|
|
return new Value(typeof(Type))
|
|
{
|
|
_data = new OpCodeParameter { Object = type },
|
|
_load = (il, data) =>
|
|
{
|
|
var val = Unsafe.As<Type>(data.Object)!;
|
|
il.Emit(OpCodes.Ldtoken, val);
|
|
return new Value(val);
|
|
},
|
|
};
|
|
}
|
|
|
|
public static Value Parameter(Type type, int idx)
|
|
{
|
|
return new Value(type)
|
|
{
|
|
_data = new OpCodeParameter { UInt = (uint)idx, Object = type },
|
|
_load = (il, data) =>
|
|
{
|
|
var idx = (int)data.UInt;
|
|
var type = Unsafe.As<Type>(data.Object);
|
|
switch (idx)
|
|
{
|
|
case 0: il.Emit(OpCodes.Ldarg_0); break;
|
|
case 1: il.Emit(OpCodes.Ldarg_1); break;
|
|
case 2: il.Emit(OpCodes.Ldarg_2); break;
|
|
case 3: il.Emit(OpCodes.Ldarg_3); break;
|
|
case <= 255: il.Emit(OpCodes.Ldarg_S, (byte)idx); break;
|
|
default: il.Emit(OpCodes.Ldarg, (short)idx); break;
|
|
}
|
|
|
|
return Value.Parameter(type, idx);
|
|
},
|
|
_store = (il, data) =>
|
|
{
|
|
var idx = (int)data.UInt;
|
|
switch (idx)
|
|
{
|
|
case <= 255: il.Emit(OpCodes.Starg_S, (byte)idx); break;
|
|
default: il.Emit(OpCodes.Starg, (short)idx); break;
|
|
}
|
|
},
|
|
};
|
|
}
|
|
|
|
public static Value Local(Type type, int idx)
|
|
{
|
|
return new Value(type)
|
|
{
|
|
_data = new OpCodeParameter { UInt = (uint)idx, Object = type },
|
|
_load = (il, data) =>
|
|
{
|
|
var idx = (int)data.UInt;
|
|
var type = Unsafe.As<Type>(data.Object);
|
|
switch (idx)
|
|
{
|
|
case 0: il.Emit(OpCodes.Ldloc_0); break;
|
|
case 1: il.Emit(OpCodes.Ldloc_1); break;
|
|
case 2: il.Emit(OpCodes.Ldloc_2); break;
|
|
case 3: il.Emit(OpCodes.Ldloc_3); break;
|
|
case <= 255: il.Emit(OpCodes.Ldloc_S, (byte)idx); break;
|
|
default: il.Emit(OpCodes.Ldloc, (short)idx); break;
|
|
}
|
|
|
|
return Local(type, idx);
|
|
},
|
|
_store = (il, data) =>
|
|
{
|
|
var idx = (int)data.UInt;
|
|
switch (idx)
|
|
{
|
|
case 0: il.Emit(OpCodes.Stloc_0); break;
|
|
case 1: il.Emit(OpCodes.Stloc_1); break;
|
|
case 2: il.Emit(OpCodes.Stloc_2); break;
|
|
case 3: il.Emit(OpCodes.Stloc_3); break;
|
|
case <= 255: il.Emit(OpCodes.Stloc_S, (byte)idx); break;
|
|
default: il.Emit(OpCodes.Stloc, (short)idx); break;
|
|
}
|
|
},
|
|
};
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
return $"{Type.Name} {_data}";
|
|
}
|
|
} |