avatar_admin
/
PeachValley_ET6
1
0
Fork 1
Code Issues Pull Requests Projects Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
32 Commits
1 Branch
0 Tags
231 MiB
 
 
 
 
 
 
Tree: 063bd2e448
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '063bd2e448'
${ noResults }
PeachValley_ET6/Unity/Assets/ThirdParty/ILRuntime/Runtime/Intepreter/ILIntepreter.cs

5912 lines
318 KiB
Raw Blame History

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using ILRuntime.Runtime.Enviorment;
using ILRuntime.Runtime.Stack;
using ILRuntime.CLR.Method;
using ILRuntime.CLR.TypeSystem;
using ILRuntime.Runtime.Intepreter.OpCodes;
using ILRuntime.Runtime.Debugger;
using ILRuntime.CLR.Utils;
using ILRuntime.Other;
namespace ILRuntime.Runtime.Intepreter
{
public unsafe partial class ILIntepreter
{
Enviorment.AppDomain domain;
RuntimeStack stack;
object _lockObj;
bool allowUnboundCLRMethod;
internal RuntimeStack Stack { get { return stack; } }
public bool ShouldBreak { get; set; }
public StepTypes CurrentStepType { get; set; }
public StackObject* LastStepFrameBase { get; set; }
public int LastStepInstructionIndex { get; set; }
StackObject* ValueTypeBasePointer;
#pragma warning disable CS0414
bool mainthreadLock;
public ILIntepreter(Enviorment.AppDomain domain)
{
this.domain = domain;
stack = new RuntimeStack(this);
allowUnboundCLRMethod = domain.AllowUnboundCLRMethod;
#if DEBUG && !DISABLE_ILRUNTIME_DEBUG
_lockObj = new object();
#endif
}
public Enviorment.AppDomain AppDomain { get { return domain; } }
public void Break()
{
//Clear old debug state
ClearDebugState();
#if DEBUG && !NO_PROFILER
if(domain.UnityMainThreadID == Thread.CurrentThread.ManagedThreadId)
{
mainthreadLock = true;
while (mainthreadLock)
{
domain.DebugService.ResolvePendingRequests();
Thread.Sleep(10);
}
return;
}
#endif
lock (_lockObj)
{
Monitor.Wait(_lockObj);
}
}
public void Resume()
{
mainthreadLock = false;
lock (_lockObj)
Monitor.Pulse(_lockObj);
}
public void ClearDebugState()
{
ShouldBreak = false;
CurrentStepType = StepTypes.None;
LastStepFrameBase = (StackObject*)0;
LastStepInstructionIndex = 0;
}
public object Run(ILMethod method, object instance, object[] p)
{
IList<object> mStack = stack.ManagedStack;
int mStackBase = mStack.Count;
StackObject* esp = stack.StackBase;
stack.ResetValueTypePointer();
if (method.HasThis)
{
if (instance is CrossBindingAdaptorType)
instance = ((CrossBindingAdaptorType)instance).ILInstance;
if (instance == null)
throw new NullReferenceException("instance should not be null!");
esp = PushObject(esp, mStack, instance);
}
bool useRegister = method.ShouldUseRegisterVM;
esp = PushParameters(method, esp, p, useRegister);
bool unhandledException;
if (useRegister)
esp = ExecuteR(method, esp, out unhandledException);
else
esp = Execute(method, esp, out unhandledException);
object result = method.ReturnType != domain.VoidType ? method.ReturnType.TypeForCLR.CheckCLRTypes(StackObject.ToObject((esp - 1), domain, mStack)) : null;
//ClearStack
#if DEBUG && !DISABLE_ILRUNTIME_DEBUG
((List<object>)mStack).RemoveRange(mStackBase, mStack.Count - mStackBase);
#else
((UncheckedList<object>)mStack).RemoveRange(mStackBase, mStack.Count - mStackBase);
#endif
return result;
}
internal StackObject* Execute(ILMethod method, StackObject* esp, out bool unhandledException)
{
allowUnboundCLRMethod = domain.AllowUnboundCLRMethod;
#if DEBUG
if (method == null)
throw new NullReferenceException();
#endif
#if DEBUG && !NO_PROFILER
if (System.Threading.Thread.CurrentThread.ManagedThreadId == AppDomain.UnityMainThreadID)
#if UNITY_5_5_OR_NEWER
UnityEngine.Profiling.Profiler.BeginSample(method.ToString());
#else
UnityEngine.Profiler.BeginSample(method.ToString());
#endif
#endif
OpCode[] body = method.Body;
StackFrame frame;
stack.InitializeFrame(method, esp, out frame);
StackObject* v1 = frame.LocalVarPointer;
StackObject* v2 = frame.LocalVarPointer + 1;
StackObject* v3 = frame.LocalVarPointer + 1 + 1;
StackObject* v4 = Add(frame.LocalVarPointer, 3);
Exception lastCaughtEx = null;
int finallyEndAddress = 0;
var ehs = method.ExceptionHandler;
esp = frame.BasePointer;
var arg = Minus(frame.LocalVarPointer, method.ParameterCount);
IList<object> mStack = stack.ManagedStack;
int paramCnt = method.ParameterCount;
if (method.HasThis)//this parameter is always object reference
{
arg--;
paramCnt++;
/// 为确保性能，暂时先确保开发的时候，安全检查完备。
/// 当然手机端运行时可能会出现为空的类对象可正常调用成员函数，导致成员函数里面访问成员变量报错时可能使得根据Log跟踪BUG时方向错误。
#if DEBUG && !DISABLE_ILRUNTIME_DEBUG
var thisObj = RetriveObject(arg, mStack);
if (thisObj == null)
throw new NullReferenceException();
#endif
}
unhandledException = false;
StackObject* objRef, objRef2, dst, val, a, b, arrRef;
object obj = null;
IType type;
Type clrType;
int intVal;
//Managed Stack reserved for arguments(In case of starg)
for (int i = 0; i < paramCnt; i++)
{
a = Add(arg, i);
switch (a->ObjectType)
{
case ObjectTypes.Null:
//Need to reserve place for null, in case of starg
a->ObjectType = ObjectTypes.Object;
a->Value = mStack.Count;
mStack.Add(null);
break;
case ObjectTypes.ValueTypeObjectReference:
//CloneStackValueType(a, a, mStack);
break;
case ObjectTypes.Object:
case ObjectTypes.FieldReference:
case ObjectTypes.ArrayReference:
{
if (i > 0 || !method.HasThis)//this instance should not be cloned
mStack[a->Value] = CheckAndCloneValueType(mStack[a->Value], AppDomain);
}
frame.ManagedStackBase--;
break;
}
}
stack.PushFrame(ref frame);
int locBase = mStack.Count;
//Managed Stack reserved for local variable
for (int i = 0; i < method.LocalVariableCount; i++)
{
mStack.Add(null);
}
for (int i = 0; i < method.LocalVariableCount; i++)
{
var v = method.Variables[i];
bool isEnum = false;
var vt = v.VariableType;
IType t;
if (vt.IsGenericParameter)
{
t = method.FindGenericArgument(vt.Name);
}
else
{
t = AppDomain.GetType(v.VariableType, method.DeclearingType, method);
}
isEnum = t.IsEnum;
if (!t.IsByRef && t.IsValueType && !t.IsPrimitive && !isEnum)
{
if (t is ILType)
{
//var obj = ((ILType)t).Instantiate(false);
var loc = Add(v1, i);
stack.AllocValueType(loc, t);
/*loc->ObjectType = ObjectTypes.Object;
loc->Value = mStack.Count;
mStack.Add(obj);*/
}
else
{
CLRType cT = (CLRType)t;
var loc = Add(v1, i);
if (cT.ValueTypeBinder != null)
{
stack.AllocValueType(loc, t);
}
else
{
obj = ((CLRType)t).CreateDefaultInstance();
loc->ObjectType = ObjectTypes.Object;
loc->Value = locBase + i;
mStack[locBase + i] = obj;
}
}
}
else
{
if (t.IsPrimitive || isEnum)
{
var loc = Add(v1, i);
StackObject.Initialized(loc, t);
}
else
{
var loc = Add(v1, i);
loc->ObjectType = ObjectTypes.Object;
loc->Value = locBase + i;
}
}
}
var bp = stack.ValueTypeStackPointer;
ValueTypeBasePointer = bp;
fixed (OpCode* ptr = body)
{
OpCode* ip = ptr;
OpCodeEnum code = ip->Code;
bool returned = false;
while (!returned)
{
try
{
#if DEBUG && !DISABLE_ILRUNTIME_DEBUG
if (ShouldBreak)
Break();
var insOffset = (int)(ip - ptr);
frame.Address.Value = insOffset;
AppDomain.DebugService.CheckShouldBreak(method, this, insOffset);
#endif
code = ip->Code;
switch (code)
{
#region Arguments and Local Variable
case OpCodeEnum.Ldarg_0:
CopyToStack(esp, arg, mStack);
esp++;
break;
case OpCodeEnum.Ldarg_1:
CopyToStack(esp, arg + 1, mStack);
esp++;
break;
case OpCodeEnum.Ldarg_2:
CopyToStack(esp, arg + 1 + 1, mStack);
esp++;
break;
case OpCodeEnum.Ldarg_3:
CopyToStack(esp, arg + 1 + 1 + 1, mStack);
esp++;
break;
case OpCodeEnum.Ldarg:
case OpCodeEnum.Ldarg_S:
CopyToStack(esp, Add(arg, ip->TokenInteger), mStack);
esp++;
break;
case OpCodeEnum.Ldarga:
case OpCodeEnum.Ldarga_S:
{
a = Add(arg, ip->TokenInteger);
esp->ObjectType = ObjectTypes.StackObjectReference;
*(long*)&esp->Value = (long)a;
esp++;
}
break;
case OpCodeEnum.Starg:
case OpCodeEnum.Starg_S:
{
a = Add(arg, ip->TokenInteger);
val = esp - 1;
int idx = a->Value;
bool isObj = a->ObjectType >= ObjectTypes.Object;
if (val->ObjectType >= ObjectTypes.Object)
{
if (a->ObjectType == ObjectTypes.ValueTypeObjectReference)
{
dst = ILIntepreter.ResolveReference(a);
CopyValueTypeToStack(dst, mStack[val->Value], mStack);
}
else
{
a->ObjectType = val->ObjectType;
mStack[a->Value] = mStack[val->Value];
a->ValueLow = val->ValueLow;
}
}
else
{
if (a->ObjectType == ObjectTypes.ValueTypeObjectReference)
{
if (val->ObjectType == ObjectTypes.ValueTypeObjectReference)
{
CopyStackValueType(val, a, mStack);
FreeStackValueType(val);
}
else
throw new NotSupportedException();
}
else
{
if (val->ObjectType == ObjectTypes.ValueTypeObjectReference)
{
if (isObj)
{
mStack[a->Value] = StackObject.ToObject(val, domain, mStack);
}
else
throw new NotSupportedException();
}
else
{
*a = *val;
if (isObj)
{
a->Value = idx;
if (val->ObjectType == ObjectTypes.Null)
{
mStack[a->Value] = null;
}
}
}
}
}
Free(val);
esp--;
}
break;
case OpCodeEnum.Stloc_0:
{
esp--;
int idx = locBase;
StLocSub(esp, v1, idx, mStack);
}
break;
case OpCodeEnum.Ldloc_0:
CopyToStack(esp, v1, mStack);
esp++;
break;
case OpCodeEnum.Stloc_1:
{
esp--;
int idx = locBase + 1;
StLocSub(esp, v2, idx, mStack);
}
break;
case OpCodeEnum.Ldloc_1:
CopyToStack(esp, v2, mStack);
esp++;
break;
case OpCodeEnum.Stloc_2:
{
esp--;
int idx = locBase + 2;
StLocSub(esp, v3, idx, mStack);
break;
}
case OpCodeEnum.Ldloc_2:
CopyToStack(esp, v3, mStack);
esp++;
break;
case OpCodeEnum.Stloc_3:
{
esp--;
int idx = locBase + 3;
StLocSub(esp, v4, idx, mStack);
}
break;
case OpCodeEnum.Ldloc_3:
CopyToStack(esp, v4, mStack);
esp++;
break;
case OpCodeEnum.Stloc:
case OpCodeEnum.Stloc_S:
{
esp--;
var v = Add(frame.LocalVarPointer, ip->TokenInteger);
int idx = locBase + ip->TokenInteger;
StLocSub(esp, v, idx, mStack);
}
break;
case OpCodeEnum.Ldloc:
case OpCodeEnum.Ldloc_S:
{
var v = Add(frame.LocalVarPointer, ip->TokenInteger);
CopyToStack(esp, v, mStack);
esp++;
}
break;
case OpCodeEnum.Ldloca:
case OpCodeEnum.Ldloca_S:
{
var v = Add(frame.LocalVarPointer, ip->TokenInteger);
esp->ObjectType = ObjectTypes.StackObjectReference;
*(long*)&esp->Value = (long)v;
esp++;
}
break;
case OpCodeEnum.Ldobj:
{
objRef = esp - 1;
switch (objRef->ObjectType)
{
case ObjectTypes.ArrayReference:
{
var t = AppDomain.GetType(ip->TokenInteger);
obj = mStack[objRef->Value];
var idx = objRef->ValueLow;
Free(objRef);
LoadFromArrayReference(obj, idx, objRef, t, mStack);
}
break;
case ObjectTypes.StackObjectReference:
{
CopyToStack(objRef, GetObjectAndResolveReference(objRef), mStack);
}
break;
case ObjectTypes.FieldReference:
{
obj = mStack[objRef->Value];
int idx = objRef->ValueLow;
Free(objRef);
if (obj is ILTypeInstance)
{
((ILTypeInstance)obj).PushToStack(idx, objRef, this, mStack);
}
else
{
var t = AppDomain.GetType(ip->TokenInteger);
if (!((CLRType)t).CopyFieldToStack(idx, obj, this, ref objRef, mStack))
{
obj = ((CLRType)t).GetFieldValue(idx, obj);
PushObject(objRef, mStack, obj);
}
}
}
break;
case ObjectTypes.StaticFieldReference:
{
var t = AppDomain.GetType(objRef->Value);
int idx = objRef->ValueLow;
Free(objRef);
if (t is ILType)
{
((ILType)t).StaticInstance.PushToStack(idx, objRef, this, mStack);
}
else
{
if (!((CLRType)t).CopyFieldToStack(idx, null, this, ref objRef, mStack))
{
obj = ((CLRType)t).GetFieldValue(idx, null);
PushObject(objRef, mStack, obj);
}
}
}
break;
default:
throw new NotImplementedException();
}
}
break;
case OpCodeEnum.Stobj:
{
objRef = esp - 1 - 1;
val = esp - 1;
switch (objRef->ObjectType)
{
case ObjectTypes.ArrayReference:
{
var t = AppDomain.GetType(ip->TokenInteger);
StoreValueToArrayReference(objRef, val, t, mStack);
}
break;
case ObjectTypes.StackObjectReference:
{
objRef = GetObjectAndResolveReference(objRef);
if (objRef->ObjectType == ObjectTypes.ValueTypeObjectReference)
{
switch (val->ObjectType)
{
case ObjectTypes.Object:
dst = ILIntepreter.ResolveReference(objRef);
CopyValueTypeToStack(dst, mStack[val->Value], mStack);
break;
case ObjectTypes.ValueTypeObjectReference:
CopyStackValueType(val, objRef, mStack);
break;
default:
throw new NotImplementedException();
}
}
else
{
if (val->ObjectType >= ObjectTypes.Object)
{
mStack[objRef->Value] = mStack[val->Value];
objRef->ValueLow = val->ValueLow;
}
else
{
*objRef = *val;
}
}
}
break;
case ObjectTypes.FieldReference:
{
obj = mStack[objRef->Value];
int idx = objRef->ValueLow;
if (obj is ILTypeInstance)
{
((ILTypeInstance)obj).AssignFromStack(idx, val, AppDomain, mStack);
}
else
{
var t = AppDomain.GetType(ip->TokenInteger);
if (!((CLRType)t).AssignFieldFromStack(idx, ref obj, this, val, mStack))
((CLRType)t).SetFieldValue(idx, ref obj, t.TypeForCLR.CheckCLRTypes(StackObject.ToObject(val, AppDomain, mStack)));
}
}
break;
case ObjectTypes.StaticFieldReference:
{
var t = AppDomain.GetType(objRef->Value);
if (t is ILType)
{
((ILType)t).StaticInstance.AssignFromStack(objRef->ValueLow, val, AppDomain, mStack);
}
else
{
obj = null;
if (!((CLRType)t).AssignFieldFromStack(objRef->ValueLow, ref obj, this, val, mStack))
((CLRType)t).SetStaticFieldValue(objRef->ValueLow, t.TypeForCLR.CheckCLRTypes(StackObject.ToObject(val, AppDomain, mStack)));
}
}
break;
default:
throw new NotImplementedException();
}
Free(esp - 1);
Free(esp - 1 - 1);
esp = esp - 1 - 1;
}
break;
#endregion
#region Load Constants
case OpCodeEnum.Ldc_I4_M1:
esp->Value = -1;
esp->ObjectType = ObjectTypes.Integer;
esp++;
break;
case OpCodeEnum.Ldc_I4_0:
esp->Value = 0;
esp->ObjectType = ObjectTypes.Integer;
esp++;
break;
case OpCodeEnum.Ldc_I4_1:
esp->Value = 1;
esp->ObjectType = ObjectTypes.Integer;
esp++;
break;
case OpCodeEnum.Ldc_I4_2:
esp->Value = 2;
esp->ObjectType = ObjectTypes.Integer;
esp++;
break;
case OpCodeEnum.Ldc_I4_3:
esp->Value = 3;
esp->ObjectType = ObjectTypes.Integer;
esp++;
break;
case OpCodeEnum.Ldc_I4_4:
esp->Value = 4;
esp->ObjectType = ObjectTypes.Integer;
esp++;
break;
case OpCodeEnum.Ldc_I4_5:
esp->Value = 5;
esp->ObjectType = ObjectTypes.Integer;
esp++;
break;
case OpCodeEnum.Ldc_I4_6:
esp->Value = 6;
esp->ObjectType = ObjectTypes.Integer;
esp++;
break;
case OpCodeEnum.Ldc_I4_7:
esp->Value = 7;
esp->ObjectType = ObjectTypes.Integer;
esp++;
break;
case OpCodeEnum.Ldc_I4_8:
esp->Value = 8;
esp->ObjectType = ObjectTypes.Integer;
esp++;
break;
case OpCodeEnum.Ldc_I4:
case OpCodeEnum.Ldc_I4_S:
esp->Value = ip->TokenInteger;
esp->ObjectType = ObjectTypes.Integer;
esp++;
break;
case OpCodeEnum.Ldc_I8:
{
*(long*)(&esp->Value) = ip->TokenLong;
esp->ObjectType = ObjectTypes.Long;
esp++;
}
break;
case OpCodeEnum.Ldc_R4:
{
*(float*)(&esp->Value) = *(float*)&ip->TokenInteger;
esp->ObjectType = ObjectTypes.Float;
esp++;
}
break;
case OpCodeEnum.Ldc_R8:
{
*(double*)(&esp->Value) = *(double*)&ip->TokenLong;
esp->ObjectType = ObjectTypes.Double;
esp++;
}
break;
case OpCodeEnum.Ldnull:
{
esp = PushNull(esp);
}
break;
case OpCodeEnum.Ldind_I:
case OpCodeEnum.Ldind_I1:
case OpCodeEnum.Ldind_I2:
case OpCodeEnum.Ldind_I4:
case OpCodeEnum.Ldind_U1:
case OpCodeEnum.Ldind_U2:
case OpCodeEnum.Ldind_U4:
{
val = GetObjectAndResolveReference(esp - 1);
dst = esp - 1;
switch (val->ObjectType)
{
case ObjectTypes.FieldReference:
{
var instance = mStack[val->Value];
var idx = val->ValueLow;
Free(dst);
LoadFromFieldReference(instance, idx, dst, mStack);
}
break;
case ObjectTypes.ArrayReference:
{
var instance = mStack[val->Value];
var idx = val->ValueLow;
Free(dst);
LoadFromArrayReference(instance, idx, dst, instance.GetType().GetElementType(), mStack);
}
break;
case ObjectTypes.StaticFieldReference:
{
var t = AppDomain.GetType(val->Value);
int idx = val->ValueLow;
Free(dst);
if (t is ILType)
{
((ILType)t).StaticInstance.PushToStack(idx, dst, this, mStack);
}
else
{
if (!((CLRType)t).CopyFieldToStack(idx, null, this, ref dst, mStack))
{
obj = ((CLRType)t).GetFieldValue(idx, null);
PushObject(dst, mStack, obj);
}
}
}
break;
default:
{
dst->ObjectType = ObjectTypes.Integer;
dst->Value = val->Value;
dst->ValueLow = 0;
}
break;
}
}
break;
case OpCodeEnum.Ldind_I8:
{
val = GetObjectAndResolveReference(esp - 1);
dst = esp - 1;
switch (val->ObjectType)
{
case ObjectTypes.FieldReference:
{
var instance = mStack[val->Value];
var idx = val->ValueLow;
Free(dst);
LoadFromFieldReference(instance, idx, dst, mStack);
}
break;
case ObjectTypes.ArrayReference:
{
var instance = mStack[val->Value];
var idx = val->ValueLow;
Free(dst);
LoadFromArrayReference(instance, idx, dst, instance.GetType().GetElementType(), mStack);
}
break;
case ObjectTypes.StaticFieldReference:
{
var t = AppDomain.GetType(val->Value);
int idx = val->ValueLow;
Free(dst);
if (t is ILType)
{
((ILType)t).StaticInstance.PushToStack(idx, dst, this, mStack);
}
else
{
if (!((CLRType)t).CopyFieldToStack(idx, null, this, ref dst, mStack))
{
obj = ((CLRType)t).GetFieldValue(idx, null);
PushObject(dst, mStack, obj);
}
}
}
break;
default:
{
*dst = *val;
dst->ObjectType = ObjectTypes.Long;
}
break;
}
}
break;
case OpCodeEnum.Ldind_R4:
{
val = GetObjectAndResolveReference(esp - 1);
dst = esp - 1;
switch (val->ObjectType)
{
case ObjectTypes.FieldReference:
{
var instance = mStack[val->Value];
var idx = val->ValueLow;
Free(dst);
LoadFromFieldReference(instance, idx, dst, mStack);
}
break;
case ObjectTypes.ArrayReference:
{
var instance = mStack[val->Value];
var idx = val->ValueLow;
Free(dst);
LoadFromArrayReference(instance, idx, dst, instance.GetType().GetElementType(), mStack);
}
break;
case ObjectTypes.StaticFieldReference:
{
var t = AppDomain.GetType(val->Value);
int idx = val->ValueLow;
Free(dst);
if (t is ILType)
{
((ILType)t).StaticInstance.PushToStack(idx, dst, this, mStack);
}
else
{
if (!((CLRType)t).CopyFieldToStack(idx, null, this, ref dst, mStack))
{
obj = ((CLRType)t).GetFieldValue(idx, null);
PushObject(dst, mStack, obj);
}
}
}
break;
default:
{
dst->ObjectType = ObjectTypes.Float;
dst->Value = val->Value;
dst->ValueLow = 0;
}
break;
}
}
break;
case OpCodeEnum.Ldind_R8:
{
val = GetObjectAndResolveReference(esp - 1);
dst = esp - 1;
switch (val->ObjectType)
{
case ObjectTypes.FieldReference:
{
var instance = mStack[val->Value];
var idx = val->ValueLow;
Free(dst);
LoadFromFieldReference(instance, idx, dst, mStack);
}
break;
case ObjectTypes.ArrayReference:
{
var instance = mStack[val->Value];
var idx = val->ValueLow;
Free(dst);
LoadFromArrayReference(instance, idx, dst, instance.GetType().GetElementType(), mStack);
}
break;
case ObjectTypes.StaticFieldReference:
{
var t = AppDomain.GetType(val->Value);
int idx = val->ValueLow;
Free(dst);
if (t is ILType)
{
((ILType)t).StaticInstance.PushToStack(idx, dst, this, mStack);
}
else
{
if (!((CLRType)t).CopyFieldToStack(idx, null, this, ref dst, mStack))
{
obj = ((CLRType)t).GetFieldValue(idx, null);
PushObject(dst, mStack, obj);
}
}
}
break;
default:
{
*dst = *val;
dst->ObjectType = ObjectTypes.Double;
}
break;
}
}
break;
case OpCodeEnum.Ldind_Ref:
{
val = GetObjectAndResolveReference(esp - 1);
dst = esp - 1;
switch (val->ObjectType)
{
case ObjectTypes.FieldReference:
{
var instance = mStack[val->Value];
var idx = val->ValueLow;
Free(dst);
LoadFromFieldReference(instance, idx, dst, mStack);
}
break;
case ObjectTypes.ArrayReference:
{
var instance = mStack[val->Value];
var idx = val->ValueLow;
Free(dst);
LoadFromArrayReference(instance, idx, dst, instance.GetType().GetElementType(), mStack);
}
break;
case ObjectTypes.StaticFieldReference:
{
var t = AppDomain.GetType(val->Value);
int idx = val->ValueLow;
Free(dst);
if (t is ILType)
{
((ILType)t).StaticInstance.PushToStack(idx, dst, this, mStack);
}
else
{
if (!((CLRType)t).CopyFieldToStack(idx, null, this, ref dst, mStack))
{
obj = ((CLRType)t).GetFieldValue(idx, null);
PushObject(dst, mStack, obj);
}
}
}
break;
default:
{
dst->ObjectType = ObjectTypes.Object;
dst->Value = mStack.Count;
mStack.Add(mStack[val->Value]);
}
break;
}
}
break;
case OpCodeEnum.Stind_I:
case OpCodeEnum.Stind_I1:
case OpCodeEnum.Stind_I2:
case OpCodeEnum.Stind_I4:
case OpCodeEnum.Stind_R4:
{
dst = GetObjectAndResolveReference(esp - 1 - 1);
val = esp - 1;
switch (dst->ObjectType)
{
case ObjectTypes.FieldReference:
{
obj = mStack[dst->Value];
StoreValueToFieldReference(ref obj, dst->ValueLow, val, mStack);
mStack[dst->Value] = obj;
}
break;
case ObjectTypes.ArrayReference:
{
StoreValueToArrayReference(dst, val, mStack[dst->Value].GetType().GetElementType(), mStack);
}
break;
case ObjectTypes.StaticFieldReference:
{
type = AppDomain.GetType(dst->Value);
int idx = dst->ValueLow;
if (type != null)
{
if (type is ILType)
{
ILType t = type as ILType;
t.StaticInstance.AssignFromStack(idx, val, AppDomain, mStack);
}
else
{
CLRType t = type as CLRType;
var f = t.GetField(idx);
obj = null;
if (!((CLRType)t).AssignFieldFromStack(idx, ref obj, this, val, mStack))
t.SetStaticFieldValue(idx, f.FieldType.CheckCLRTypes(CheckAndCloneValueType(StackObject.ToObject(val, domain, mStack), domain)));
}
}
else
throw new TypeLoadException();
}
break;
default:
{
dst->Value = val->Value;
}
break;
}
Free(esp - 1);
Free(esp - 1 - 1);
esp = esp - 1 - 1;
}
break;
case OpCodeEnum.Stind_I8:
{
dst = GetObjectAndResolveReference(esp - 1 - 1);
val = esp - 1;
switch (dst->ObjectType)
{
case ObjectTypes.FieldReference:
{
obj = mStack[dst->Value];
StoreValueToFieldReference(ref obj, dst->ValueLow, val, mStack);
mStack[dst->Value] = obj;
}
break;
case ObjectTypes.ArrayReference:
{
StoreValueToArrayReference(dst, val, typeof(long), mStack);
}
break;
case ObjectTypes.StaticFieldReference:
{
type = AppDomain.GetType(dst->Value);
int idx = dst->ValueLow;
if (type != null)
{
if (type is ILType)
{
ILType t = type as ILType;
t.StaticInstance.AssignFromStack(idx, val, AppDomain, mStack);
}
else
{
CLRType t = type as CLRType;
obj = null;
if (!((CLRType)t).AssignFieldFromStack(idx, ref obj, this, val, mStack))
t.SetStaticFieldValue(idx, typeof(long).CheckCLRTypes(CheckAndCloneValueType(StackObject.ToObject(val, domain, mStack), domain)));
}
}
else
throw new TypeLoadException();
}
break;
default:
{
dst->Value = val->Value;
dst->ValueLow = val->ValueLow;
}
break;
}
Free(esp - 1);
Free(esp - 1 - 1);
esp = esp - 1 - 1;
}
break;
case OpCodeEnum.Stind_R8:
{
dst = GetObjectAndResolveReference(esp - 1 - 1);
val = esp - 1;
switch (dst->ObjectType)
{
case ObjectTypes.FieldReference:
{
obj = mStack[dst->Value];
StoreValueToFieldReference(ref obj, dst->ValueLow, val, mStack);
mStack[dst->Value] = obj;
}
break;
case ObjectTypes.ArrayReference:
{
StoreValueToArrayReference(dst, val, typeof(double), mStack);
}
break;
case ObjectTypes.StaticFieldReference:
{
type = AppDomain.GetType(dst->Value);
int idx = dst->ValueLow;
if (type != null)
{
if (type is ILType)
{
ILType t = type as ILType;
t.StaticInstance.AssignFromStack(idx, val, AppDomain, mStack);
}
else
{
CLRType t = type as CLRType;
obj = null;
if (!((CLRType)t).AssignFieldFromStack(idx, ref obj, this, val, mStack))
t.SetStaticFieldValue(idx, typeof(double).CheckCLRTypes(CheckAndCloneValueType(StackObject.ToObject(val, domain, mStack), domain)));
}
}
else
throw new TypeLoadException();
}
break;
default:
{
dst->Value = val->Value;
dst->ValueLow = val->ValueLow;
}
break;
}
Free(esp - 1);
Free(esp - 1 - 1);
esp = esp - 1 - 1;
}
break;
case OpCodeEnum.Stind_Ref:
{
dst = GetObjectAndResolveReference(esp - 1 - 1);
val = esp - 1;
switch (dst->ObjectType)
{
case ObjectTypes.FieldReference:
{
obj = mStack[dst->Value];
StoreValueToFieldReference(ref obj, dst->ValueLow, val, mStack);
mStack[dst->Value] = obj;
}
break;
case ObjectTypes.ArrayReference:
{
StoreValueToArrayReference(dst, val, typeof(object), mStack);
}
break;
case ObjectTypes.StaticFieldReference:
{
type = AppDomain.GetType(dst->Value);
int idx = dst->ValueLow;
if (type != null)
{
if (type is ILType)
{
ILType t = type as ILType;
t.StaticInstance.AssignFromStack(idx, val, AppDomain, mStack);
}
else
{
CLRType t = type as CLRType;
var f = t.GetField(idx);
obj = null;
if (!((CLRType)t).AssignFieldFromStack(idx, ref obj, this, val, mStack))
t.SetStaticFieldValue(idx, f.FieldType.CheckCLRTypes(CheckAndCloneValueType(StackObject.ToObject(val, domain, mStack), domain)));
}
}
else
throw new TypeLoadException();
}
break;
default:
{
switch (val->ObjectType)
{
case ObjectTypes.Object:
mStack[dst->Value] = mStack[val->Value];
break;
case ObjectTypes.Null:
mStack[dst->Value] = null;
break;
default:
throw new NotImplementedException();
}
}
break;
}
Free(esp - 1);
Free(esp - 1 - 1);
esp = esp - 1 - 1;
}
break;
case OpCodeEnum.Ldstr:
esp = PushObject(esp, mStack, AppDomain.GetString(ip->TokenLong));
break;
#endregion
#region Althemetics
case OpCodeEnum.Add:
{
b = esp - 1;
a = esp - 1 - 1;
esp = a;
switch (a->ObjectType)
{
case ObjectTypes.Long:
*((long*)&esp->Value) = *((long*)&a->Value) + *((long*)&b->Value);
break;
case ObjectTypes.Integer:
esp->Value = a->Value + b->Value;
break;
case ObjectTypes.Float:
*((float*)&esp->Value) = *((float*)&a->Value) + *((float*)&b->Value);
break;
case ObjectTypes.Double:
*((double*)&esp->Value) = *((double*)&a->Value) + *((double*)&b->Value);
break;
default:
throw new NotImplementedException();
}
esp++;
}
break;
case OpCodeEnum.Sub:
{
b = esp - 1;
a = esp - 1 - 1;
esp = a;
switch (a->ObjectType)
{
case ObjectTypes.Long:
*((long*)&esp->Value) = *((long*)&a->Value) - *((long*)&b->Value);
break;
case ObjectTypes.Integer:
esp->Value = a->Value - b->Value;
break;
case ObjectTypes.Float:
*((float*)&esp->Value) = *((float*)&a->Value) - *((float*)&b->Value);
break;
case ObjectTypes.Double:
*((double*)&esp->Value) = *((double*)&a->Value) - *((double*)&b->Value);
break;
default:
throw new NotImplementedException();
}
esp++;
}
break;
case OpCodeEnum.Mul:
{
b = esp - 1;
a = esp - 1 - 1;
esp = a;
switch (a->ObjectType)
{
case ObjectTypes.Long:
*((long*)&esp->Value) = *((long*)&a->Value) * *((long*)&b->Value);
break;
case ObjectTypes.Integer:
esp->Value = a->Value * b->Value;
break;
case ObjectTypes.Float:
*((float*)&esp->Value) = *((float*)&a->Value) * *((float*)&b->Value);
break;
case ObjectTypes.Double:
*((double*)&esp->Value) = *((double*)&a->Value) * *((double*)&b->Value);
break;
default:
throw new NotImplementedException();
}
esp++;
}
break;
case OpCodeEnum.Div:
{
b = esp - 1;
a = esp - 1 - 1;
esp = a;
switch (a->ObjectType)
{
case ObjectTypes.Long:
*((long*)&esp->Value) = *((long*)&a->Value) / *((long*)&b->Value);
break;
case ObjectTypes.Integer:
esp->Value = a->Value / b->Value;
break;
case ObjectTypes.Float:
*((float*)&esp->Value) = *((float*)&a->Value) / *((float*)&b->Value);
break;
case ObjectTypes.Double:
*((double*)&esp->Value) = *((double*)&a->Value) / *((double*)&b->Value);
break;
default:
throw new NotImplementedException();
}
esp++;
}
break;
case OpCodeEnum.Div_Un:
{
b = esp - 1;
a = esp - 1 - 1;
esp = a;
switch (a->ObjectType)
{
case ObjectTypes.Long:
*((ulong*)&esp->Value) = *((ulong*)&a->Value) / *((ulong*)&b->Value);
break;
case ObjectTypes.Integer:
esp->Value = (int)((uint)a->Value / (uint)b->Value);
break;
default:
throw new NotImplementedException();
}
esp++;
}
break;
case OpCodeEnum.Rem:
{
b = esp - 1;
a = esp - 1 - 1;
esp = a;
switch (a->ObjectType)
{
case ObjectTypes.Long:
*((long*)&esp->Value) = *((long*)&a->Value) % *((long*)&b->Value);
break;
case ObjectTypes.Integer:
esp->Value = a->Value % b->Value;
break;
case ObjectTypes.Float:
*(float*)&esp->Value = *(float*)&a->Value % *(float*)&b->Value;
break;
case ObjectTypes.Double:
*(double*)&esp->Value = *(double*)&a->Value % *(double*)&b->Value;
break;
default:
throw new NotImplementedException();
}
esp++;
}
break;
case OpCodeEnum.Rem_Un:
{
b = esp - 1;
a = esp - 1 - 1;
esp = a;
switch (a->ObjectType)
{
case ObjectTypes.Long:
*((ulong*)&esp->Value) = *((ulong*)&a->Value) % *((ulong*)&b->Value);
break;
case ObjectTypes.Integer:
esp->Value = (int)((uint)a->Value % (uint)b->Value);
break;
default:
throw new NotImplementedException();
}
esp++;
}
break;
case OpCodeEnum.Xor:
{
b = esp - 1;
a = esp - 1 - 1;
esp = a;
switch (a->ObjectType)
{
case ObjectTypes.Long:
*((long*)&esp->Value) = *((long*)&a->Value) ^ *((long*)&b->Value);
break;
case ObjectTypes.Integer:
esp->Value = a->Value ^ b->Value;
break;
default:
throw new NotImplementedException();
}
esp++;
}
break;
case OpCodeEnum.And:
{
b = esp - 1;
a = esp - 1 - 1;
esp = a;
switch (a->ObjectType)
{
case ObjectTypes.Long:
*((long*)&esp->Value) = *((long*)&a->Value) & *((long*)&b->Value);
break;
case ObjectTypes.Integer:
esp->Value = a->Value & b->Value;
break;
default:
throw new NotImplementedException();
}
esp++;
}
break;
case OpCodeEnum.Or:
{
b = esp - 1;
a = esp - 1 - 1;
esp = a;
switch (a->ObjectType)
{
case ObjectTypes.Long:
*((long*)&esp->Value) = *((long*)&a->Value) | *((long*)&b->Value);
break;
case ObjectTypes.Integer:
esp->Value = a->Value | b->Value;
break;
default:
throw new NotImplementedException();
}
esp++;
}
break;
case OpCodeEnum.Shl:
{
b = esp - 1;
a = esp - 1 - 1;
esp = a;
int bits = b->Value;
switch (a->ObjectType)
{
case ObjectTypes.Long:
*((long*)&esp->Value) = *((long*)&a->Value) << bits;
break;
case ObjectTypes.Integer:
esp->Value = a->Value << bits;
break;
default:
throw new NotImplementedException();
}
esp++;
}
break;
case OpCodeEnum.Shr:
{
b = esp - 1;
a = esp - 1 - 1;
esp = a;
int bits = b->Value;
switch (a->ObjectType)
{
case ObjectTypes.Long:
*((long*)&esp->Value) = *((long*)&a->Value) >> bits;
break;
case ObjectTypes.Integer:
esp->Value = a->Value >> bits;
break;
default:
throw new NotImplementedException();
}
esp++;
}
break;
case OpCodeEnum.Shr_Un:
{
b = esp - 1;
a = esp - 1 - 1;
esp = a;
int bits = b->Value;
switch (a->ObjectType)
{
case ObjectTypes.Long:
*((ulong*)&esp->Value) = *((ulong*)&a->Value) >> bits;
break;
case ObjectTypes.Integer:
*(uint*)&esp->Value = (uint)a->Value >> bits;
break;
default:
throw new NotImplementedException();
}
esp++;
}
break;
case OpCodeEnum.Not:
{
a = esp - 1;
switch (a->ObjectType)
{
case ObjectTypes.Long:
*((long*)&a->Value) = ~*((long*)&a->Value);
break;
case ObjectTypes.Integer:
a->Value = ~a->Value;
break;
default:
throw new NotImplementedException();
}
}
break;
case OpCodeEnum.Neg:
{
a = esp - 1;
switch (a->ObjectType)
{
case ObjectTypes.Long:
*((long*)&a->Value) = -*((long*)&a->Value);
break;
case ObjectTypes.Integer:
a->Value = -a->Value;
break;
case ObjectTypes.Float:
*((float*)&a->Value) = -*((float*)&a->Value);
break;
case ObjectTypes.Double:
*((double*)&a->Value) = -*((double*)&a->Value);
break;
default:
throw new NotImplementedException();
}
}
break;
#endregion
#region Control Flows
case OpCodeEnum.Ret:
returned = true;
break;
case OpCodeEnum.Brtrue:
case OpCodeEnum.Brtrue_S:
{
esp--;
bool res = false;
switch (esp->ObjectType)
{
case ObjectTypes.Integer:
res = esp->Value != 0;
break;
case ObjectTypes.Long:
res = *(long*)&esp->Value != 0;
break;
case ObjectTypes.Object:
res = mStack[esp->Value] != null;
break;
}
if (res)
{
ip = ptr + ip->TokenInteger;
Free(esp);
continue;
}
else
Free(esp);
}
break;
case OpCodeEnum.Brfalse:
case OpCodeEnum.Brfalse_S:
{
esp--;
bool res = false;
switch (esp->ObjectType)
{
case ObjectTypes.Null:
res = true;
break;
case ObjectTypes.Integer:
res = esp->Value == 0;
break;
case ObjectTypes.Long:
res = *(long*)&esp->Value == 0;
break;
case ObjectTypes.Object:
res = mStack[esp->Value] == null;
Free(esp);
break;
default:
Free(esp);
break;
}
if (res)
{
ip = ptr + ip->TokenInteger;
continue;
}
}
break;
case OpCodeEnum.Beq:
case OpCodeEnum.Beq_S:
{
b = esp - 1;
a = esp - 1 - 1;
bool transfer = false;
if (a->ObjectType == b->ObjectType)
{
switch (a->ObjectType)
{
case ObjectTypes.Null:
transfer = true;
break;
case ObjectTypes.Integer:
transfer = a->Value == b->Value;
break;
case ObjectTypes.Long:
transfer = *(long*)&a->Value == *(long*)&b->Value;
break;
case ObjectTypes.Float:
transfer = *(float*)&a->Value == *(float*)&b->Value;
break;
case ObjectTypes.Double:
transfer = *(double*)&a->Value == *(double*)&b->Value;
break;
case ObjectTypes.Object:
transfer = mStack[a->Value] == mStack[b->Value];
break;
default:
throw new NotImplementedException();
}
}
Free(esp - 1);
Free(esp - 1 - 1);
esp = esp - 1 - 1;
if (transfer)
{
ip = ptr + ip->TokenInteger;
continue;
}
}
break;
case OpCodeEnum.Bne_Un:
case OpCodeEnum.Bne_Un_S:
{
b = esp - 1;
a = esp - 1 - 1;
bool transfer = false;
if (a->ObjectType == b->ObjectType)
{
switch (a->ObjectType)
{
case ObjectTypes.Null:
transfer = false;
break;
case ObjectTypes.Integer:
transfer = (uint)a->Value != (uint)b->Value;
break;
case ObjectTypes.Float:
transfer = *(float*)&a->Value != *(float*)&b->Value;
break;
case ObjectTypes.Long:
transfer = *(long*)&a->Value != *(long*)&b->Value;
break;
case ObjectTypes.Double:
transfer = *(double*)&a->Value != *(double*)&b->Value;
break;
case ObjectTypes.Object:
transfer = mStack[a->Value] != mStack[b->Value];
break;
default:
throw new NotImplementedException();
}
}
else
transfer = true;
Free(esp - 1);
Free(esp - 1 - 1);
esp = esp - 1 - 1;
if (transfer)
{
ip = ptr + ip->TokenInteger;
continue;
}
}
break;
case OpCodeEnum.Bgt:
case OpCodeEnum.Bgt_S:
{
b = esp - 1;
a = esp - 1 - 1;
esp = esp - 1 - 1;
bool transfer = false;
switch (esp->ObjectType)
{
case ObjectTypes.Integer:
transfer = a->Value > b->Value;
break;
case ObjectTypes.Long:
transfer = *(long*)&a->Value > *(long*)&b->Value;
break;
case ObjectTypes.Float:
transfer = *(float*)&a->Value > *(float*)&b->Value;
break;
case ObjectTypes.Double:
transfer = *(double*)&a->Value > *(double*)&b->Value;
break;
default:
throw new NotImplementedException();
}
if (transfer)
{
ip = ptr + ip->TokenInteger;
continue;
}
}
break;
case OpCodeEnum.Bgt_Un:
case OpCodeEnum.Bgt_Un_S:
{
b = esp - 1;
a = esp - 1 - 1;
esp = esp - 1 - 1;
bool transfer = false;
switch (esp->ObjectType)
{
case ObjectTypes.Integer:
transfer = (uint)a->Value > (uint)b->Value;
break;
case ObjectTypes.Long:
transfer = *(ulong*)&a->Value > *(ulong*)&b->Value;
break;
case ObjectTypes.Float:
transfer = *(float*)&a->Value > *(float*)&b->Value;
break;
case ObjectTypes.Double:
transfer = *(double*)&a->Value > *(double*)&b->Value;
break;
default:
throw new NotImplementedException();
}
if (transfer)
{
ip = ptr + ip->TokenInteger;
continue;
}
}
break;
case OpCodeEnum.Bge:
case OpCodeEnum.Bge_S:
{
b = esp - 1;
a = esp - 1 - 1;
esp = esp - 1 - 1;
bool transfer = false;
switch (esp->ObjectType)
{
case ObjectTypes.Integer:
transfer = a->Value >= b->Value;
break;
case ObjectTypes.Long:
transfer = *(long*)&a->Value >= *(long*)&b->Value;
break;
case ObjectTypes.Float:
transfer = *(float*)&a->Value >= *(float*)&b->Value;
break;
case ObjectTypes.Double:
transfer = *(double*)&a->Value >= *(double*)&b->Value;
break;
default:
throw new NotImplementedException();
}
if (transfer)
{
ip = ptr + ip->TokenInteger;
continue;
}
}
break;
case OpCodeEnum.Bge_Un:
case OpCodeEnum.Bge_Un_S:
{
b = esp - 1;
a = esp - 1 - 1;
esp = esp - 1 - 1;
bool transfer = false;
switch (esp->ObjectType)
{
case ObjectTypes.Integer:
transfer = (uint)a->Value >= (uint)b->Value;
break;
case ObjectTypes.Long:
transfer = *(ulong*)&a->Value >= *(ulong*)&b->Value;
break;
case ObjectTypes.Float:
transfer = *(float*)&a->Value >= *(float*)&b->Value;
break;
case ObjectTypes.Double:
transfer = *(double*)&a->Value >= *(double*)&b->Value;
break;
default:
throw new NotImplementedException();
}
if (transfer)
{
ip = ptr + ip->TokenInteger;
continue;
}
}
break;
case OpCodeEnum.Blt:
case OpCodeEnum.Blt_S:
{
b = esp - 1;
a = esp - 1 - 1;
esp = esp - 1 - 1;
bool transfer = false;
switch (esp->ObjectType)
{
case ObjectTypes.Integer:
transfer = a->Value < b->Value;
break;
case ObjectTypes.Long:
transfer = *(long*)&a->Value < *(long*)&b->Value;
break;
case ObjectTypes.Float:
transfer = *(float*)&a->Value < *(float*)&b->Value;
break;
case ObjectTypes.Double:
transfer = *(double*)&a->Value < *(double*)&b->Value;
break;
default:
throw new NotImplementedException();
}
if (transfer)
{
ip = ptr + ip->TokenInteger;
continue;
}
}
break;
case OpCodeEnum.Blt_Un:
case OpCodeEnum.Blt_Un_S:
{
b = esp - 1;
a = esp - 1 - 1;
esp = esp - 1 - 1;
bool transfer = false;
switch (esp->ObjectType)
{
case ObjectTypes.Integer:
transfer = (uint)a->Value < (uint)b->Value;
break;
case ObjectTypes.Long:
transfer = *(ulong*)&a->Value < *(ulong*)&b->Value;
break;
case ObjectTypes.Float:
transfer = *(float*)&a->Value < *(float*)&b->Value;
break;
case ObjectTypes.Double:
transfer = *(double*)&a->Value < *(double*)&b->Value;
break;
default:
throw new NotImplementedException();
}
if (transfer)
{
ip = ptr + ip->TokenInteger;
continue;
}
}
break;
case OpCodeEnum.Ble:
case OpCodeEnum.Ble_S:
{
b = esp - 1;
a = esp - 1 - 1;
esp = esp - 1 - 1;
bool transfer = false;
switch (esp->ObjectType)
{
case ObjectTypes.Integer:
transfer = a->Value <= b->Value;
break;
case ObjectTypes.Long:
transfer = *(long*)&a->Value <= *(long*)&b->Value;
break;
case ObjectTypes.Float:
transfer = *(float*)&a->Value <= *(float*)&b->Value;
break;
case ObjectTypes.Double:
transfer = *(double*)&a->Value <= *(double*)&b->Value;
break;
default:
throw new NotImplementedException();
}
if (transfer)
{
ip = ptr + ip->TokenInteger;
continue;
}
}
break;
case OpCodeEnum.Ble_Un:
case OpCodeEnum.Ble_Un_S:
{
b = esp - 1;
a = esp - 1 - 1;
esp = esp - 1 - 1;
bool transfer = false;
switch (esp->ObjectType)
{
case ObjectTypes.Integer:
transfer = (uint)a->Value <= (uint)b->Value;
break;
case ObjectTypes.Long:
transfer = *(ulong*)&a->Value <= *(ulong*)&b->Value;
break;
case ObjectTypes.Float:
transfer = *(float*)&a->Value <= *(float*)&b->Value;
break;
case ObjectTypes.Double:
transfer = *(double*)&a->Value <= *(double*)&b->Value;
break;
default:
throw new NotImplementedException();
}
if (transfer)
{
ip = ptr + ip->TokenInteger;
continue;
}
}
break;
case OpCodeEnum.Br_S:
case OpCodeEnum.Br:
ip = ptr + ip->TokenInteger;
continue;
case OpCodeEnum.Switch:
{
intVal = (esp - 1)->Value;
Free(esp - 1);
esp--;
var table = method.JumpTables[ip->TokenInteger];
if (intVal >= 0 && intVal < table.Length)
{
ip = ptr + table[intVal];
continue;
}
}
break;
case OpCodeEnum.Leave:
case OpCodeEnum.Leave_S:
{
if (ehs != null)
{
ExceptionHandler eh = null;
int addr = (int)(ip - ptr);
eh = FindExceptionHandlerByBranchTarget(addr, ip->TokenInteger, ehs);
if (eh != null)
{
finallyEndAddress = ip->TokenInteger;
ip = ptr + eh.HandlerStart;
continue;
}
}
ip = ptr + ip->TokenInteger;
continue;
}
case OpCodeEnum.Endfinally:
{
if (finallyEndAddress < 0)
{
unhandledException = true;
finallyEndAddress = 0;
throw lastCaughtEx;
}
else
{
ip = ptr + finallyEndAddress;
finallyEndAddress = 0;
continue;
}
}
case OpCodeEnum.Call:
case OpCodeEnum.Callvirt:
{
IMethod m = domain.GetMethod(ip->TokenInteger);
if (m == null)
{
//Irrelevant method
int cnt = (int)ip->TokenLong;
//Balance the stack
for (int i = 0; i < cnt; i++)
{
Free(esp - 1);
esp--;
}
}
else
{
if (m is ILMethod)
{
ILMethod ilm = (ILMethod)m;
bool processed = false;
if (m.IsDelegateInvoke)
{
var instance = StackObject.ToObject((Minus(esp, m.ParameterCount + 1)), domain, mStack);
if (instance is IDelegateAdapter)
{
esp = ((IDelegateAdapter)instance).ILInvoke(this, esp, mStack);
processed = true;
}
}
if (!processed)
{
if (code == OpCodeEnum.Callvirt)
{
objRef = GetObjectAndResolveReference(Minus(esp, ilm.ParameterCount + 1));
if (objRef->ObjectType == ObjectTypes.Null)
throw new NullReferenceException();
if (objRef->ObjectType == ObjectTypes.ValueTypeObjectReference)
{
dst = ILIntepreter.ResolveReference(objRef);
var ft = domain.GetTypeByIndex(dst->Value) as ILType;
ilm = ft.GetVirtualMethod(ilm) as ILMethod;
}
else
{
obj = mStack[objRef->Value];
if (obj == null)
throw new NullReferenceException();
ilm = ((ILTypeInstance)obj).Type.GetVirtualMethod(ilm) as ILMethod;
}
}
if (ilm.ShouldUseRegisterVM)
{
PrepareRegisterCallStack(esp, mStack, ilm);
esp = ExecuteR(ilm, esp, out unhandledException);
}
else
esp = Execute(ilm, esp, out unhandledException);
ValueTypeBasePointer = bp;
if (unhandledException)
returned = true;
}
}
else
{
CLRMethod cm = (CLRMethod)m;
bool processed = false;
if (cm.IsDelegateInvoke)
{
var instance = StackObject.ToObject((Minus(esp, cm.ParameterCount + 1)), domain, mStack);
if (instance is IDelegateAdapter)
{
if (cm.IsDelegateDynamicInvoke)
{
arrRef = esp - 1;
object[] objArr = StackObject.ToObject(arrRef, domain, mStack) as object[];
Free(arrRef);
if (objArr != null)
{
if (objArr.Length != cm.ParameterCount)
throw new ArgumentException(string.Format("{0}.{1} has {2} arguments, but got {3}", cm.DeclearingType.FullName, cm.Name, cm.ParameterCount, objArr.Length));
esp = arrRef;
for (intVal = 0; intVal < objArr.Length; intVal++)
{
esp = PushObject(esp, mStack, objArr[intVal], cm.Parameters[intVal] == domain.ObjectType);
}
}
}
esp = ((IDelegateAdapter)instance).ILInvoke(this, esp, mStack);
processed = true;
}
}
if (!processed)
{
var redirect = cm.Redirection;
if (redirect != null)
esp = redirect(this, esp, mStack, cm, false);
else
{
#if DEBUG && !DISABLE_ILRUNTIME_DEBUG
if (!allowUnboundCLRMethod)
throw new NotSupportedException(cm.ToString() + " is not bound!");
#endif
#if DEBUG && !NO_PROFILER
if (System.Threading.Thread.CurrentThread.ManagedThreadId == AppDomain.UnityMainThreadID)
#if UNITY_5_5_OR_NEWER
UnityEngine.Profiling.Profiler.BeginSample(cm.ToString());
#else
UnityEngine.Profiler.BeginSample(cm.ToString());
#endif
#endif
object result = cm.Invoke(this, esp, mStack);
#if DEBUG && !NO_PROFILER
if (System.Threading.Thread.CurrentThread.ManagedThreadId == AppDomain.UnityMainThreadID)
#if UNITY_5_5_OR_NEWER
UnityEngine.Profiling.Profiler.EndSample();
#else
UnityEngine.Profiler.EndSample();
#endif
#endif
if (result is CrossBindingAdaptorType)
result = ((CrossBindingAdaptorType)result).ILInstance;
int paramCount = cm.ParameterCount;
for (int i = 1; i <= paramCount; i++)
{
Free(Minus(esp, i));
}
esp = Minus(esp, paramCount);
if (cm.HasThis)
{
Free(esp - 1);
esp--;
}
if (cm.ReturnType != AppDomain.VoidType && !cm.IsConstructor)
{
esp = PushObject(esp, mStack, result, cm.ReturnType.TypeForCLR == typeof(object));
}
}
}
}
}
}
break;
#endregion
#region FieldOperation
case OpCodeEnum.Stfld:
{
objRef = GetObjectAndResolveReference(esp - 1 - 1);
if (objRef->ObjectType == ObjectTypes.ValueTypeObjectReference)
{
dst = ILIntepreter.ResolveReference(objRef);
var ft = domain.GetTypeByIndex(dst->Value);
if (ft is ILType)
CopyToValueTypeField(dst, (int)ip->TokenLong, esp - 1, mStack);
else
CopyToValueTypeField(dst, ((CLRType)ft).FieldIndexMapping[(int)ip->TokenLong], esp - 1, mStack);
}
else
{
obj = RetriveObject(objRef, mStack);
if (obj != null)
{
ILTypeInstance instance = null;
if (obj is ILTypeInstance)
instance = obj as ILTypeInstance;
else if (obj is CrossBindingAdaptorType)
instance = (obj as CrossBindingAdaptorType).ILInstance;
if (instance != null)
{
val = esp - 1;
instance.AssignFromStack((int)ip->TokenLong, val, AppDomain, mStack);
}
else
{
var t = obj.GetType();
type = AppDomain.GetType((int)(ip->TokenLong >> 32));
if (type != null)
{
val = esp - 1;
var fieldToken = (int)ip->TokenLong;
var f = ((CLRType)type).GetField(fieldToken);
if (!((CLRType)type).AssignFieldFromStack(fieldToken, ref obj, this, val, mStack))
((CLRType)type).SetFieldValue(fieldToken, ref obj, f.FieldType.CheckCLRTypes(CheckAndCloneValueType(StackObject.ToObject(val, domain, mStack), domain)));
//Writeback
if (t.IsValueType)
{
switch (objRef->ObjectType)
{
case ObjectTypes.Object:
mStack[objRef->Value] = obj;
break;
case ObjectTypes.FieldReference:
{
var oldObj = mStack[objRef->Value];
int idx = objRef->ValueLow;
if (oldObj is ILTypeInstance)
{
((ILTypeInstance)oldObj)[idx] = obj;
}
else
{
var it = AppDomain.GetType(oldObj.GetType());
((CLRType)it).SetFieldValue(idx, ref oldObj, obj);
}
}
break;
case ObjectTypes.ArrayReference:
{
var arr = mStack[objRef->Value] as Array;
int idx = objRef->ValueLow;
arr.SetValue(obj, idx);
}
break;
case ObjectTypes.StaticFieldReference:
{
var it = AppDomain.GetType(objRef->Value);
int idx = objRef->ValueLow;
if (it is ILType)
{
((ILType)it).StaticInstance[idx] = obj;
}
else
{
((CLRType)it).SetStaticFieldValue(idx, obj);
}
}
break;
case ObjectTypes.ValueTypeObjectReference:
{
dst = ILIntepreter.ResolveReference(objRef);
var ct = domain.GetTypeByIndex(dst->Value) as CLRType;
var binder = ct.ValueTypeBinder;
binder.CopyValueTypeToStack(obj, dst, mStack);
}
break;
default:
throw new NotImplementedException();
}
}
}
else
throw new TypeLoadException();
}
}
else
throw new NullReferenceException();
}
Free(esp - 1);
Free(esp - 1 - 1);
esp = esp - 1 - 1;
}
break;
case OpCodeEnum.Ldfld:
{
var ret = esp - 1;
objRef = GetObjectAndResolveReference(ret);
if (objRef->ObjectType == ObjectTypes.ValueTypeObjectReference)
{
dst = ILIntepreter.ResolveReference(objRef);
var ft = domain.GetTypeByIndex(dst->Value);
if (ft is ILType)
val = Minus(dst, (int)ip->TokenLong + 1);
else
val = Minus(dst, ((CLRType)ft).FieldIndexMapping[(int)ip->TokenLong] + 1);
if (val->ObjectType == ObjectTypes.ValueTypeObjectReference && ret->ObjectType == ObjectTypes.ValueTypeObjectReference)
{
stack.RelocateValueTypeAndFreeAfterDst(val, ret);
}
else
{
StackObject valRef;
if (val->ObjectType == ObjectTypes.ValueTypeObjectReference)
{
Free(ret);
CopyToStack(ret, val, mStack);
}
else
{
valRef = *val;
if (val->ObjectType >= ObjectTypes.Object)
obj = mStack[val->Value];
//CopyToStack(ret, dst, mStack);
Free(ret);
if (valRef.ObjectType >= ObjectTypes.Object)
{
valRef.Value = mStack.Count;
mStack.Add(obj);
}
*ret = valRef;
}
}
}
else
{
obj = RetriveObject(objRef, mStack);
Free(ret);
if (obj != null)
{
ILTypeInstance instance = null;
if (obj is ILTypeInstance)
instance = obj as ILTypeInstance;
else if (obj is CrossBindingAdaptorType)
instance = (obj as CrossBindingAdaptorType).ILInstance;
if (instance != null)
instance.PushToStack((int)ip->TokenLong, ret, this, mStack);
else
{
//var t = obj.GetType();
type = AppDomain.GetType((int)(ip->TokenLong >> 32));
if (type != null)
{
var token = (int)ip->TokenLong;
if (!((CLRType)type).CopyFieldToStack(token, obj, this, ref ret, mStack))
{
var ft = ((CLRType)type).GetField(token);
obj = ((CLRType)type).GetFieldValue(token, obj);
if (obj is CrossBindingAdaptorType)
obj = ((CrossBindingAdaptorType)obj).ILInstance;
PushObject(ret, mStack, obj, ft.FieldType == typeof(object));
}
}
else
throw new TypeLoadException();
}
}
else
throw new NullReferenceException();
}
}
break;
case OpCodeEnum.Ldflda:
{
objRef = GetObjectAndResolveReference(esp - 1);
if (objRef->ObjectType == ObjectTypes.ValueTypeObjectReference)
{
dst = esp - 1;
var ft = domain.GetType((int)(ip->TokenLong >> 32));
StackObject* fieldAddr;
if (ft is ILType)
{
fieldAddr = Minus(ILIntepreter.ResolveReference(objRef), (int)ip->TokenLong + 1);
}
else
{
fieldAddr = Minus(ILIntepreter.ResolveReference(objRef), ((CLRType)ft).FieldIndexMapping[(int)ip->TokenLong] + 1);
}
StackObject valRef = *dst;
dst->ObjectType = ObjectTypes.StackObjectReference;
*(long*)&dst->Value = (long)fieldAddr;
FreeStackValueType(&valRef);
}
else
{
obj = RetriveObject(objRef, mStack);
Free(esp - 1);
if (obj != null)
{
if (obj is ILTypeInstance)
{
ILTypeInstance instance = obj as ILTypeInstance;
instance.PushFieldAddress((int)ip->TokenLong, esp - 1, mStack);
}
else
{
objRef = esp - 1;
objRef->ObjectType = ObjectTypes.FieldReference;
objRef->Value = mStack.Count;
mStack.Add(obj);
objRef->ValueLow = (int)ip->TokenLong;
}
}
else
throw new NullReferenceException();
}
}
break;
case OpCodeEnum.Stsfld:
{
type = AppDomain.GetType((int)(ip->TokenLong >> 32));
if (type != null)
{
if (type is ILType)
{
ILType t = type as ILType;
val = esp - 1;
t.StaticInstance.AssignFromStack((int)ip->TokenLong, val, AppDomain, mStack);
}
else
{
CLRType t = type as CLRType;
int idx = (int)ip->TokenLong;
var f = t.GetField(idx);
val = esp - 1;
obj = null;
if (!((CLRType)t).AssignFieldFromStack(idx, ref obj, this, val, mStack))
t.SetStaticFieldValue(idx, f.FieldType.CheckCLRTypes(CheckAndCloneValueType(StackObject.ToObject(val, domain, mStack), domain)));
}
}
else
throw new TypeLoadException();
Free(esp - 1);
esp -= 1;
}
break;
case OpCodeEnum.Ldsfld:
{
type = AppDomain.GetType((int)(ip->TokenLong >> 32));
if (type != null)
{
if (type is ILType)
{
ILType t = type as ILType;
t.StaticInstance.PushToStack((int)ip->TokenLong, esp, this, mStack);
esp++;
}
else
{
CLRType t = type as CLRType;
int idx = (int)ip->TokenLong;
if (!((CLRType)type).CopyFieldToStack(idx, null, this, ref esp, mStack))
{
var f = t.GetField(idx);
obj = t.GetFieldValue(idx, null);
if (obj is CrossBindingAdaptorType)
obj = ((CrossBindingAdaptorType)obj).ILInstance;
esp = PushObject(esp, mStack, obj, f.FieldType == typeof(object));
}
}
}
else
throw new TypeLoadException();
}
break;
case OpCodeEnum.Ldsflda:
{
int typeId = (int)(ip->TokenLong >> 32);
int fieldIdx = (int)(ip->TokenLong);
esp->ObjectType = ObjectTypes.StaticFieldReference;
esp->Value = typeId;
esp->ValueLow = fieldIdx;
esp++;
}
break;
case OpCodeEnum.Ldtoken:
{
switch (ip->TokenInteger)
{
case 0:
{
type = AppDomain.GetType((int)(ip->TokenLong >> 32));
if (type != null)
{
if (type is ILType)
{
ILType t = type as ILType;
t.StaticInstance.PushToStack((int)ip->TokenLong, esp, this, mStack);
}
else
throw new NotImplementedException();
}
}
esp++;
break;
case 1:
{
type = AppDomain.GetType((int)ip->TokenLong);
if (type != null)
{
esp = PushObject(esp, mStack, type.ReflectionType);
}
else
throw new TypeLoadException();
}
break;
default:
throw new NotImplementedException();
}
}
break;
case OpCodeEnum.Ldftn:
{
IMethod m = domain.GetMethod(ip->TokenInteger);
esp = PushObject(esp, mStack, m);
}
break;
case OpCodeEnum.Ldvirtftn:
{
IMethod m = domain.GetMethod(ip->TokenInteger);
objRef = esp - 1;
if (m is ILMethod)
{
ILMethod ilm = (ILMethod)m;
obj = mStack[objRef->Value];
m = ((ILTypeInstance)obj).Type.GetVirtualMethod(ilm) as ILMethod;
}
else
{
obj = mStack[objRef->Value];
if (obj is ILTypeInstance)
m = ((ILTypeInstance)obj).Type.GetVirtualMethod(m);
else if (obj is CrossBindingAdaptorType)
{
m = ((CrossBindingAdaptorType)obj).ILInstance.Type.BaseType.GetVirtualMethod(m);
}
}
Free(objRef);
esp = PushObject(objRef, mStack, m);
}
break;
#endregion
#region Compare
case OpCodeEnum.Ceq:
{
StackObject* obj1 = esp - 1 - 1;
StackObject* obj2 = esp - 1;
bool res = false;
if (obj1->ObjectType == obj2->ObjectType)
{
switch (obj1->ObjectType)
{
case ObjectTypes.Integer:
case ObjectTypes.Float:
res = obj1->Value == obj2->Value;
break;
case ObjectTypes.Object:
res = mStack[obj1->Value] == mStack[obj2->Value];
break;
case ObjectTypes.FieldReference:
res = mStack[obj1->Value] == mStack[obj2->Value] && obj1->ValueLow == obj2->ValueLow;
break;
case ObjectTypes.Null:
res = true;
break;
default:
res = obj1->Value == obj2->Value && obj1->ValueLow == obj2->ValueLow;
break;
}
}
else
{
switch (obj1->ObjectType)
{
case ObjectTypes.Object:
res = mStack[obj1->Value] == null && obj2->ObjectType == ObjectTypes.Null;
break;
case ObjectTypes.Null:
res = obj2->ObjectType == ObjectTypes.Object && mStack[obj2->Value] == null;
break;
}
}
Free(esp - 1);
Free(esp - 1 - 1);
if (res)
esp = PushOne(esp - 1 - 1);
else
esp = PushZero(esp - 1 - 1);
}
break;
case OpCodeEnum.Clt:
{
StackObject* obj1 = esp - 1 - 1;
StackObject* obj2 = esp - 1;
bool res = false;
switch (obj1->ObjectType)
{
case ObjectTypes.Integer:
res = obj1->Value < obj2->Value;
break;
case ObjectTypes.Long:
res = *(long*)&obj1->Value < *(long*)&obj2->Value;
break;
case ObjectTypes.Float:
res = *(float*)&obj1->Value < *(float*)&obj2->Value;
break;
case ObjectTypes.Double:
res = *(double*)&obj1->Value < *(double*)&obj2->Value;
break;
default:
throw new NotImplementedException();
}
if (res)
esp = PushOne(esp - 1 - 1);
else
esp = PushZero(esp - 1 - 1);
}
break;
case OpCodeEnum.Clt_Un:
{
StackObject* obj1 = esp - 1 - 1;
StackObject* obj2 = esp - 1;
bool res = false;
switch (obj1->ObjectType)
{
case ObjectTypes.Integer:
res = (uint)obj1->Value < (uint)obj2->Value && obj2->ObjectType != ObjectTypes.Null;
break;
case ObjectTypes.Long:
res = (ulong)*(long*)&obj1->Value < (ulong)*(long*)&obj2->Value && obj2->ObjectType != ObjectTypes.Null;
break;
case ObjectTypes.Float:
res = *(float*)&obj1->Value < *(float*)&obj2->Value && obj2->ObjectType != ObjectTypes.Null;
break;
case ObjectTypes.Double:
res = *(double*)&obj1->Value < *(double*)&obj2->Value && obj2->ObjectType != ObjectTypes.Null;
break;
default:
throw new NotImplementedException();
}
if (res)
esp = PushOne(esp - 1 - 1);
else
esp = PushZero(esp - 1 - 1);
}
break;
case OpCodeEnum.Cgt:
{
StackObject* obj1 = esp - 1 - 1;
StackObject* obj2 = esp - 1;
bool res = false;
switch (obj1->ObjectType)
{
case ObjectTypes.Integer:
res = obj1->Value > obj2->Value || obj2->ObjectType == ObjectTypes.Null;
break;
case ObjectTypes.Long:
res = *(long*)&obj1->Value > *(long*)&obj2->Value || obj2->ObjectType == ObjectTypes.Null;
break;
case ObjectTypes.Float:
res = *(float*)&obj1->Value > *(float*)&obj2->Value || obj2->ObjectType == ObjectTypes.Null;
break;
case ObjectTypes.Double:
res = *(double*)&obj1->Value > *(double*)&obj2->Value || obj2->ObjectType == ObjectTypes.Null;
break;
default:
throw new NotImplementedException();
}
if (res)
esp = PushOne(esp - 1 - 1);
else
esp = PushZero(esp - 1 - 1);
}
break;
case OpCodeEnum.Cgt_Un:
{
StackObject* obj1 = esp - 1 - 1;
StackObject* obj2 = esp - 1;
bool res = false;
switch (obj1->ObjectType)
{
case ObjectTypes.Integer:
res = ((uint)obj1->Value > (uint)obj2->Value) || obj2->ObjectType == ObjectTypes.Null;
break;
case ObjectTypes.Long:
res = (ulong)*(long*)&obj1->Value > (ulong)*(long*)&obj2->Value || obj2->ObjectType == ObjectTypes.Null;
break;
case ObjectTypes.Float:
res = *(float*)&obj1->Value > *(float*)&obj2->Value || obj2->ObjectType == ObjectTypes.Null;
break;
case ObjectTypes.Double:
res = *(double*)&obj1->Value > *(double*)&obj2->Value || obj2->ObjectType == ObjectTypes.Null;
break;
case ObjectTypes.Object:
res = mStack[obj1->Value] != null && obj2->ObjectType == ObjectTypes.Null;
break;
case ObjectTypes.Null:
res = false;
break;
default:
throw new NotImplementedException();
}
if (res)
esp = PushOne(esp - 1 - 1);
else
esp = PushZero(esp - 1 - 1);
}
break;
#endregion
#region Initialization & Instantiation
case OpCodeEnum.Newobj:
{
IMethod m = domain.GetMethod(ip->TokenInteger);
if (m is ILMethod)
{
type = m.DeclearingType as ILType;
if (type.IsDelegate)
{
objRef = GetObjectAndResolveReference(esp - 1 - 1);
var mi = (IMethod)mStack[(esp - 1)->Value];
object ins;
if (objRef->ObjectType == ObjectTypes.Null)
ins = null;
else
ins = mStack[objRef->Value];
Free(esp - 1);
Free(esp - 1 - 1);
esp = esp - 1 - 1;
object dele;
var ilMethod = mi as ILMethod;
if (ilMethod != null)
{
if (ins != null)
{
dele = ((ILTypeInstance) ins).GetDelegateAdapter(ilMethod);
if (dele == null)
{
var invokeMethod = type.GetMethod("Invoke", mi.ParameterCount);
if (invokeMethod == null && ilMethod.IsExtend)
{
invokeMethod = type.GetMethod("Invoke", mi.ParameterCount - 1);
}
dele = domain.DelegateManager.FindDelegateAdapter(
(ILTypeInstance) ins, ilMethod, invokeMethod);
}
}
else
{
if (ilMethod.DelegateAdapter == null)
{
var invokeMethod = type.GetMethod("Invoke", mi.ParameterCount);
ilMethod.DelegateAdapter = domain.DelegateManager.FindDelegateAdapter(null, ilMethod, invokeMethod);
}
dele = ilMethod.DelegateAdapter;
}
}
else
{
throw new NotImplementedException();
}
esp = PushObject(esp, mStack, dele);
}
else
{
intVal = m.ParameterCount;
a = esp - intVal;
obj = null;
bool isValueType = type.IsValueType;
ILIntepreter tmpIntp;
IList<object> tmStack;
if (isValueType && intVal > 0)
{
tmpIntp = domain.RequestILIntepreter();
tmpIntp.stack.ResetValueTypePointer();
esp = tmpIntp.stack.StackBase;
tmStack = tmpIntp.stack.ManagedStack;
}
else
{
tmpIntp = this;
tmStack = mStack;
}
if (isValueType)
{
tmpIntp.stack.AllocValueType(esp, type);
objRef = esp + 1;
objRef->ObjectType = ObjectTypes.StackObjectReference;
*(long*)&objRef->Value = (long)esp;
objRef++;
}
else
{
obj = ((ILType)type).Instantiate(false);
objRef = PushObject(esp, tmStack, obj);//this parameter for constructor
}
esp = objRef;
for (int i = 0; i < intVal; i++)
{
tmpIntp.CopyToStack(esp, a + i, mStack, tmStack);
esp++;
}
if (((ILMethod)m).ShouldUseRegisterVM)
{
PrepareRegisterCallStack(esp, tmStack, (ILMethod)m);
esp = tmpIntp.ExecuteR((ILMethod)m, esp, out unhandledException);
}
else
esp = tmpIntp.Execute((ILMethod)m, esp, out unhandledException);
ValueTypeBasePointer = bp;
for (int i = intVal - 1; i >= 0; i--)
{
Free(Add(a, i));
}
if (isValueType)
{
if (intVal > 0)
{
stack.AllocValueType(a, type);
CopyStackValueType(esp - 1, a, tmpIntp.stack.ManagedStack, mStack);
domain.FreeILIntepreter(tmpIntp);
}
else
{
var ins = objRef - 1 - 1;
*a = *ins;
}
esp = a + 1;
}
else
esp = PushObject(a, mStack, obj);//new constructedObj
}
if (unhandledException)
returned = true;
}
else
{
CLRMethod cm = (CLRMethod)m;
//Means new object();
if (cm == null)
{
esp = PushObject(esp, mStack, new object());
}
else
{
if (cm.DeclearingType.IsDelegate)
{
objRef = GetObjectAndResolveReference(esp - 1 - 1);
var mi = (IMethod)mStack[(esp - 1)->Value];
object ins;
if (objRef->ObjectType == ObjectTypes.Null)
ins = null;
else
ins = mStack[objRef->Value];
Free(esp - 1);
Free(esp - 1 - 1);
esp = esp - 1 - 1;
object dele;
var ilMethod = mi as ILMethod;
if (ilMethod != null)
{
dele = domain.DelegateManager.FindDelegateAdapter((CLRType)cm.DeclearingType, (ILTypeInstance)ins, ilMethod);
}
else
{
if (ins is ILTypeInstance)
ins = ((ILTypeInstance)ins).CLRInstance;
dele = Delegate.CreateDelegate(cm.DeclearingType.TypeForCLR, ins, ((CLRMethod)mi).MethodInfo);
}
esp = PushObject(esp, mStack, dele);
}
else
{
var redirect = cm.Redirection;
if (redirect != null)
esp = redirect(this, esp, mStack, cm, true);
else
{
#if DEBUG && !DISABLE_ILRUNTIME_DEBUG
if (!allowUnboundCLRMethod)
throw new NotSupportedException(cm.ToString() + " is not bound!");
#endif
object result = cm.Invoke(this, esp, mStack, true);
int paramCount = cm.ParameterCount;
for (int i = 1; i <= paramCount; i++)
{
Free(esp - i);
}
esp = Minus(esp, paramCount);
esp = PushObject(esp, mStack, result);//new constructedObj
}
}
}
}
}
break;
case OpCodeEnum.Constrained:
{
type = domain.GetType(ip->TokenInteger);
var m = domain.GetMethod((int)ip->TokenLong);
var pCnt = m.ParameterCount;
objRef = Minus(esp, pCnt + 1);
var insIdx = mStack.Count;
if (objRef->ObjectType < ObjectTypes.Object)
{
bool moved = false;
//move parameters
for (int i = 0; i < pCnt; i++)
{
var pPtr = Minus(esp, i + 1);
if (pPtr->ObjectType >= ObjectTypes.Object)
{
var oldVal = pPtr->Value;
insIdx--;
if (!moved)
{
pPtr->Value = mStack.Count;
mStack.Add(mStack[oldVal]);
mStack[oldVal] = null;
moved = true;
}
else
{
mStack[oldVal + 1] = mStack[oldVal];
mStack[oldVal] = null;
pPtr->Value = oldVal + 1;
}
}
}
if (!moved)
{
mStack.Add(null);
}
}
else
insIdx = objRef->Value;
objRef2 = GetObjectAndResolveReference(objRef);
if (type != null)
{
if (type is ILType)
{
var t = (ILType)type;
if (t.IsEnum)
{
ILEnumTypeInstance ins = new ILEnumTypeInstance(t);
switch (objRef2->ObjectType)
{
case ObjectTypes.FieldReference:
{
var owner = mStack[objRef2->Value] as ILTypeInstance;
int idx = objRef2->ValueLow;
//Free(objRef);
owner.PushToStack(idx, objRef, this, mStack);
ins.AssignFromStack(0, objRef, AppDomain, mStack);
ins.Boxed = true;
}
break;
case ObjectTypes.StaticFieldReference:
{
var st = AppDomain.GetType(objRef2->Value) as ILType;
int idx = objRef2->ValueLow;
//Free(objRef);
st.StaticInstance.PushToStack(idx, objRef, this, mStack);
ins.AssignFromStack(0, objRef, AppDomain, mStack);
ins.Boxed = true;
}
break;
case ObjectTypes.ArrayReference:
{
var arr = mStack[objRef2->Value];
var idx = objRef2->ValueLow;
//Free(objRef);
LoadFromArrayReference(arr, idx, objRef, t, mStack);
ins.AssignFromStack(0, objRef, AppDomain, mStack);
ins.Boxed = true;
}
break;
default:
ins.AssignFromStack(0, objRef2, AppDomain, mStack);
ins.Boxed = true;
break;
}
objRef->ObjectType = ObjectTypes.Object;
objRef->Value = insIdx;
mStack[insIdx] = ins;
//esp = PushObject(esp - 1, mStack, ins);
}
else if(objRef2->ObjectType != ObjectTypes.ValueTypeObjectReference)
{
object res = RetriveObject(objRef2, mStack);
//Free(objRef);
objRef->ObjectType = ObjectTypes.Object;
objRef->Value = insIdx;
mStack[insIdx] = res;
//esp = PushObject(objRef, mStack, res, true);
}
}
else
{
var tt = type.TypeForCLR;
if (tt.IsEnum)
{
mStack[insIdx] = Enum.ToObject(tt, StackObject.ToObject(objRef2, AppDomain, mStack));
objRef->ObjectType = ObjectTypes.Object;
objRef->Value = insIdx;
//esp = PushObject(esp - 1, mStack, Enum.ToObject(tt, StackObject.ToObject(obj, AppDomain, mStack)), true);
}
else if (tt.IsPrimitive)
{
mStack[insIdx] = tt.CheckCLRTypes(StackObject.ToObject(objRef2, AppDomain, mStack));
objRef->ObjectType = ObjectTypes.Object;
objRef->Value = insIdx;
//esp = PushObject(esp - 1, mStack, tt.CheckCLRTypes(StackObject.ToObject(obj, AppDomain, mStack)));
}
else if (objRef2->ObjectType != ObjectTypes.ValueTypeObjectReference)
{
object res = RetriveObject(objRef2, mStack);
//Free(objRef);
objRef->ObjectType = ObjectTypes.Object;
objRef->Value = insIdx;
mStack[insIdx] = res;
//esp = PushObject(objRef, mStack, res, true);
}
}
}
else
throw new NullReferenceException();
}
break;
case OpCodeEnum.Box:
{
objRef = esp - 1;
type = domain.GetType(ip->TokenInteger);
if (type != null)
{
if (type is ILType)
{
if (((ILType)type).IsEnum)
{
ILEnumTypeInstance ins = new Intepreter.ILEnumTypeInstance((ILType)type);
ins.AssignFromStack(0, objRef, AppDomain, mStack);
ins.Boxed = true;
esp = PushObject(objRef, mStack, ins, true);
}
else
{
switch (objRef->ObjectType)
{
case ObjectTypes.Null:
break;
case ObjectTypes.ValueTypeObjectReference:
{
ILTypeInstance ins = ((ILType)type).Instantiate(false);
ins.AssignFromStack(objRef, domain, mStack);
FreeStackValueType(objRef);
esp = PushObject(objRef, mStack, ins, true);
}
break;
default:
{
obj = mStack[objRef->Value];
Free(objRef);
if (type.IsArray)
{
esp = PushObject(objRef, mStack, obj, true);
}
else
{
ILTypeInstance ins = (ILTypeInstance)obj;
if (ins != null)
{
if (ins.IsValueType)
{
ins.Boxed = true;
}
esp = PushObject(objRef, mStack, ins, true);
}
else
{
esp = PushNull(objRef);
}
}
}
break;
}
}
}
else
{
if (type.TypeForCLR.IsPrimitive)
{
var t = type.TypeForCLR;
if (t == typeof(int))
{
switch (objRef->ObjectType)
{
case ObjectTypes.Integer:
esp = PushObject(objRef, mStack, objRef->Value, true);
break;
case ObjectTypes.Null:
esp = PushObject(objRef, mStack, 0, true);
break;
case ObjectTypes.Object:
break;
default:
throw new NotImplementedException();
}
}
else if (t == typeof(bool))
{
switch (objRef->ObjectType)
{
case ObjectTypes.Integer:
esp = PushObject(objRef, mStack, (objRef->Value == 1), true);
break;
case ObjectTypes.Null:
esp = PushObject(objRef, mStack, false, true);
break;
case ObjectTypes.Object:
break;
default:
throw new NotImplementedException();
}
}
else if (t == typeof(byte))
{
switch (objRef->ObjectType)
{
case ObjectTypes.Integer:
esp = PushObject(objRef, mStack, (byte)objRef->Value, true);
break;
case ObjectTypes.Null:
esp = PushObject(objRef, mStack, 0L, true);
break;
case ObjectTypes.Object:
break;
default:
throw new NotImplementedException();
}
}
else if (t == typeof(short))
{
switch (objRef->ObjectType)
{
case ObjectTypes.Integer:
esp = PushObject(objRef, mStack, (short)objRef->Value, true);
break;
case ObjectTypes.Null:
esp = PushObject(objRef, mStack, (short)0, true);
break;
case ObjectTypes.Object:
break;
default:
throw new NotImplementedException();
}
}
else if (t == typeof(long))
{
switch (objRef->ObjectType)
{
case ObjectTypes.Long:
esp = PushObject(objRef, mStack, *(long*)&objRef->Value, true);
break;
case ObjectTypes.Null:
esp = PushObject(objRef, mStack, 0L, true);
break;
case ObjectTypes.Object:
break;
default:
throw new NotImplementedException();
}
}
else if (t == typeof(float))
{
switch (objRef->ObjectType)
{
case ObjectTypes.Float:
esp = PushObject(objRef, mStack, *(float*)&objRef->Value, true);
break;
case ObjectTypes.Null:
esp = PushObject(objRef, mStack, 0f, true);
break;
case ObjectTypes.Object:
break;
default:
throw new NotImplementedException();
}
}
else if (t == typeof(double))
{
switch (objRef->ObjectType)
{
case ObjectTypes.Double:
esp = PushObject(objRef, mStack, *(double*)&objRef->Value, true);
break;
case ObjectTypes.Null:
esp = PushObject(objRef, mStack, 0.0, true);
break;
case ObjectTypes.Object:
break;
default:
throw new NotImplementedException();
}
}
else if (t == typeof(char))
{
switch (objRef->ObjectType)
{
case ObjectTypes.Integer:
esp = PushObject(objRef, mStack, (char)objRef->Value, true);
break;
case ObjectTypes.Object:
break;
default:
throw new NotImplementedException();
}
}
else if (t == typeof(uint))
{
switch (objRef->ObjectType)
{
case ObjectTypes.Integer:
esp = PushObject(objRef, mStack, (uint)objRef->Value, true);
break;
case ObjectTypes.Null:
esp = PushObject(objRef, mStack, (uint)0, true);
break;
case ObjectTypes.Object:
break;
default:
throw new NotImplementedException();
}
}
else if (t == typeof(ushort))
{
switch (objRef->ObjectType)
{
case ObjectTypes.Integer:
esp = PushObject(objRef, mStack, (ushort)objRef->Value, true);
break;
case ObjectTypes.Null:
esp = PushObject(objRef, mStack, (ushort)0, true);
break;
case ObjectTypes.Object:
break;
default:
throw new NotImplementedException();
}
}
else if (t == typeof(ulong))
{
switch (objRef->ObjectType)
{
case ObjectTypes.Long:
esp = PushObject(objRef, mStack, *(ulong*)&objRef->Value, true);
break;
case ObjectTypes.Null:
esp = PushObject(objRef, mStack, (ulong)0, true);
break;
case ObjectTypes.Object:
break;
default:
throw new NotImplementedException();
}
}
else if (t == typeof(sbyte))
{
switch (objRef->ObjectType)
{
case ObjectTypes.Integer:
esp = PushObject(objRef, mStack, (sbyte)objRef->Value, true);
break;
case ObjectTypes.Null:
esp = PushObject(objRef, mStack, (sbyte)0, true);
break;
case ObjectTypes.Object:
break;
default:
throw new NotImplementedException();
}
}
else
throw new NotImplementedException();
}
else if (type.TypeForCLR.IsEnum)
{
esp = PushObject(objRef, mStack, Enum.ToObject(type.TypeForCLR, StackObject.ToObject(objRef, AppDomain, mStack)), true);
}
else
{
if (objRef->ObjectType == ObjectTypes.ValueTypeObjectReference)
{
dst = ILIntepreter.ResolveReference(objRef);
var vt = domain.GetTypeByIndex(dst->Value);
if (vt != type)
throw new InvalidCastException();
object ins = ((CLRType)vt).ValueTypeBinder.ToObject(dst, mStack);
FreeStackValueType(objRef);
esp = PushObject(objRef, mStack, ins, true);
}
//nothing to do for CLR type boxing
}
}
}
else
throw new NullReferenceException();
}
break;
case OpCodeEnum.Unbox:
case OpCodeEnum.Unbox_Any:
{
objRef = esp - 1;
if (objRef->ObjectType == ObjectTypes.Object)
{
obj = mStack[objRef->Value];
Free(objRef);
if (obj != null)
{
var t = domain.GetType(ip->TokenInteger);
if (t != null)
{
clrType = t.TypeForCLR;
bool isEnumObj = obj is ILEnumTypeInstance;
if ((t is CLRType) && clrType.IsPrimitive && !isEnumObj)
{
if (clrType == typeof(int))
{
int value = obj.ToInt32();
objRef->ObjectType = ObjectTypes.Integer;
objRef->Value = value;
}
else if (clrType == typeof(bool))
{
bool value = (bool)obj;
objRef->ObjectType = ObjectTypes.Integer;
objRef->Value = value ? 1 : 0;
}
else if (clrType == typeof(short))
{
short value = obj.ToInt16();
objRef->ObjectType = ObjectTypes.Integer;
objRef->Value = value;
}
else if (clrType == typeof(long))
{
long value = obj.ToInt64();
objRef->ObjectType = ObjectTypes.Long;
*(long*)&objRef->Value = value;
}
else if (clrType == typeof(float))
{
float value = obj.ToFloat();
objRef->ObjectType = ObjectTypes.Float;
*(float*)&objRef->Value = value;
}
else if (clrType == typeof(byte))
{
byte value = (byte)obj;
objRef->ObjectType = ObjectTypes.Integer;
objRef->Value = value;
}
else if (clrType == typeof(double))
{
double value = obj.ToDouble();
objRef->ObjectType = ObjectTypes.Double;
*(double*)&objRef->Value = value;
}
else if (clrType == typeof(char))
{
char value = (char)obj;
objRef->ObjectType = ObjectTypes.Integer;
*(&objRef->Value) = value;
}
else if (clrType == typeof(uint))
{
uint value = (uint)obj;
objRef->ObjectType = ObjectTypes.Integer;
objRef->Value = (int)value;
}
else if (clrType == typeof(ushort))
{
ushort value = (ushort)obj;
objRef->ObjectType = ObjectTypes.Integer;
objRef->Value = value;
}
else if (clrType == typeof(ulong))
{
ulong value = (ulong)obj;
objRef->ObjectType = ObjectTypes.Long;
*(ulong*)&objRef->Value = value;
}
else if (clrType == typeof(sbyte))
{
sbyte value = (sbyte)obj;
objRef->ObjectType = ObjectTypes.Integer;
objRef->Value = value;
}
else
throw new NotImplementedException();
}
else if (t.IsValueType)
{
if (obj is ILTypeInstance)
{
var res = ((ILTypeInstance)obj);
if (res is ILEnumTypeInstance)
{
res.PushToStack(0, objRef, this, mStack);
}
else
{
if (res.Boxed)
{
res = res.Clone();
res.Boxed = false;
}
PushObject(objRef, mStack, res);
}
}
else
PushObject(objRef, mStack, obj);
}
else
{
PushObject(objRef, mStack, obj);
}
}
else
throw new TypeLoadException();
}
else
{
//Nothing to do with null
}
}
else if (objRef->ObjectType < ObjectTypes.StackObjectReference)
{
//Nothing to do with primitive types
}
else if (objRef->ObjectType == ObjectTypes.ValueTypeObjectReference)
{
//Nothing to do with ValueTypeReference
}
else
throw new InvalidCastException();
}
break;
case OpCodeEnum.Initobj:
{
objRef = GetObjectAndResolveReference(esp - 1);
type = domain.GetType(ip->TokenInteger);
if (type is ILType)
{
ILType it = (ILType)type;
if (it.IsValueType)
{
switch (objRef->ObjectType)
{
case ObjectTypes.Null:
throw new NullReferenceException();
case ObjectTypes.Integer:
case ObjectTypes.Float:
objRef->Value = 0;
break;
case ObjectTypes.Long:
case ObjectTypes.Double:
*(long*)&objRef->Value = 0;
break;
case ObjectTypes.ValueTypeObjectReference:
stack.ClearValueTypeObject(type, ILIntepreter.ResolveReference(objRef));
break;
case ObjectTypes.Object:
{
obj = mStack[objRef->Value];
if (obj != null)
{
if (obj is ILTypeInstance)
{
ILTypeInstance instance = obj as ILTypeInstance;
instance.Clear();
}
else
throw new NotSupportedException();
}
else
throw new NullReferenceException();
}
break;
case ObjectTypes.ArrayReference:
{
var arr = mStack[objRef->Value] as Array;
var idx = objRef->ValueLow;
obj = arr.GetValue(idx);
if (obj == null)
arr.SetValue(it.Instantiate(), idx);
else
{
if (obj is ILTypeInstance)
{
ILTypeInstance instance = obj as ILTypeInstance;
instance.Clear();
}
else
throw new NotImplementedException();
}
}
break;
case ObjectTypes.FieldReference:
{
obj = mStack[objRef->Value];
if (obj != null)
{
if (obj is ILTypeInstance)
{
ILTypeInstance instance = obj as ILTypeInstance;
var tar = instance[objRef->ValueLow] as ILTypeInstance;
if (tar != null)
tar.Clear();
else
throw new NotSupportedException();
}
else
throw new NotSupportedException();
}
else
throw new NullReferenceException();
}
break;
case ObjectTypes.StaticFieldReference:
{
var t = AppDomain.GetType(objRef->Value);
int idx = objRef->ValueLow;
if (t is ILType)
{
var tar = ((ILType)t).StaticInstance[idx] as ILTypeInstance;
if (tar != null)
tar.Clear();
else
throw new NotSupportedException();
}
else
throw new NotSupportedException();
}
break;
default:
throw new NotImplementedException();
}
}
else
{
PushNull(esp);
switch (objRef->ObjectType)
{
case ObjectTypes.StaticFieldReference:
{
var t = AppDomain.GetType(objRef->Value) as ILType;
t.StaticInstance.AssignFromStack(objRef->ValueLow, esp, AppDomain, mStack);
}
break;
case ObjectTypes.FieldReference:
{
var instance = mStack[objRef->Value] as ILTypeInstance;
instance.AssignFromStack(objRef->ValueLow, esp, AppDomain, mStack);
}
break;
default:
{
if (objRef->ObjectType >= ObjectTypes.Object)
mStack[objRef->Value] = null;
else
PushNull(objRef);
}
break;
}
}
}
else
{
if (objRef->ObjectType == ObjectTypes.ValueTypeObjectReference)
{
stack.ClearValueTypeObject(type, ILIntepreter.ResolveReference(objRef));
}
else if (objRef->ObjectType == ObjectTypes.FieldReference)
{
var instance = mStack[objRef->Value] as ILTypeInstance;
if (instance != null)
{
instance.InitializeField(objRef->ValueLow);
}
else
throw new NotImplementedException();
}
else if (type.IsPrimitive)
StackObject.Initialized(objRef, type);
else
{
if (!type.IsValueType)
{
if (objRef->ObjectType >= ObjectTypes.Object)
mStack[objRef->Value] = null;
else
PushNull(objRef);
}
}
}
Free(esp - 1);
esp--;
}
break;
case OpCodeEnum.Castclass:
{
objRef = esp - 1;
var oriRef = objRef;
type = domain.GetType(ip->TokenInteger);
if (type != null)
{
objRef = GetObjectAndResolveReference(objRef);
if (objRef->ObjectType <= ObjectTypes.Double)
{
if (objRef->ObjectType != ObjectTypes.Null)
throw new NotImplementedException();
else
{
//Nothing to do with null
}
}
else
{
obj = RetriveObject(objRef, mStack);
Free(oriRef);
if (obj != null)
{
if (obj is ILTypeInstance)
{
if (((ILTypeInstance)obj).CanAssignTo(type))
{
esp = PushObject(oriRef, mStack, obj);
}
else
{
throw new InvalidCastException(string.Format("Cannot Cast {0} to {1}", ((ILTypeInstance)obj).Type.FullName, type.FullName));
}
}
else
{
if (type.TypeForCLR.IsAssignableFrom(obj.GetType()))
{
esp = PushObject(oriRef, mStack, obj, true);
}
else
{
throw new InvalidCastException(string.Format("Cannot Cast {0} to {1}", obj.GetType().FullName, type.FullName));
}
}
}
else
{
#if !DEBUG || DISABLE_ILRUNTIME_DEBUG
oriRef->ObjectType = ObjectTypes.Null;
oriRef->Value = -1;
oriRef->ValueLow = 0;
#endif
}
}
}
else
throw new NullReferenceException();
}
break;
case OpCodeEnum.Isinst:
{
objRef = esp - 1;
var oriRef = objRef;
type = domain.GetType(ip->TokenInteger);
if (type != null)
{
objRef = GetObjectAndResolveReference(objRef);
if (objRef->ObjectType <= ObjectTypes.Double)
{
var tclr = type.TypeForCLR;
switch (objRef->ObjectType)
{
case ObjectTypes.Integer:
{
if (tclr != typeof(int) && tclr != typeof(bool) && tclr != typeof(short) && tclr != typeof(byte) && tclr != typeof(ushort) && tclr != typeof(uint))
{
oriRef->ObjectType = ObjectTypes.Null;
oriRef->Value = -1;
oriRef->ValueLow = 0;
}
}
break;
case ObjectTypes.Long:
{
if (tclr != typeof(long) && tclr != typeof(ulong))
{
oriRef->ObjectType = ObjectTypes.Null;
oriRef->Value = -1;
oriRef->ValueLow = 0;
}
}
break;
case ObjectTypes.Float:
{
if (tclr != typeof(float))
{
oriRef->ObjectType = ObjectTypes.Null;
oriRef->Value = -1;
oriRef->ValueLow = 0;
}
}
break;
case ObjectTypes.Double:
{
if (tclr != typeof(double))
{
oriRef->ObjectType = ObjectTypes.Null;
oriRef->Value = -1;
oriRef->ValueLow = 0;
}
}
break;
case ObjectTypes.Null:
oriRef->ObjectType = ObjectTypes.Null;
oriRef->Value = -1;
oriRef->ValueLow = 0;
break;
}
}
else
{
obj = RetriveObject(objRef, mStack);
Free(oriRef);
if (obj != null)
{
if (obj is ILTypeInstance)
{
if (((ILTypeInstance)obj).CanAssignTo(type))
{
esp = PushObject(oriRef, mStack, obj);
}
else
{
#if !DEBUG || DISABLE_ILRUNTIME_DEBUG
oriRef->ObjectType = ObjectTypes.Null;
oriRef->Value = -1;
oriRef->ValueLow = 0;
#endif
}
}
else
{
if (type.TypeForCLR.IsAssignableFrom(obj.GetType()))
{
esp = PushObject(oriRef, mStack, obj, true);
}
else
{
#if !DEBUG || DISABLE_ILRUNTIME_DEBUG
oriRef->ObjectType = ObjectTypes.Null;
oriRef->Value = -1;
oriRef->ValueLow = 0;
#endif
}
}
}
else
{
#if !DEBUG || DISABLE_ILRUNTIME_DEBUG
oriRef->ObjectType = ObjectTypes.Null;
oriRef->Value = -1;
oriRef->ValueLow = 0;
#endif
}
}
}
else
throw new NullReferenceException();
}
break;
#endregion
#region Array
case OpCodeEnum.Newarr:
{
var cnt = (esp - 1);
type = domain.GetType(ip->TokenInteger);
object arr = null;
if (type != null)
{
if (type.TypeForCLR != typeof(ILTypeInstance))
{
if (type is CLRType)
{
arr = ((CLRType)type).CreateArrayInstance(cnt->Value);
}
else
{
arr = Array.CreateInstance(type.TypeForCLR, cnt->Value);
}
//Register Type
AppDomain.GetType(arr.GetType());
}
else
{
arr = new ILTypeInstance[cnt->Value];
ILTypeInstance[] ilArr = (ILTypeInstance[])arr;
if (type.IsValueType)
{
for (int i = 0; i < cnt->Value; i++)
{
ilArr[i] = ((ILType)type).Instantiate(true);
}
}
}
}
cnt->ObjectType = ObjectTypes.Object;
cnt->Value = mStack.Count;
mStack.Add(arr);
}
break;
case OpCodeEnum.Stelem_Ref:
case OpCodeEnum.Stelem_Any:
{
val = GetObjectAndResolveReference(esp - 1);
var idx = esp - 1 - 1;
arrRef = esp - 1 - 1 - 1;
Array arr = mStack[arrRef->Value] as Array;
if (arr is object[])
{
switch (val->ObjectType)
{
case ObjectTypes.Null:
arr.SetValue(null, idx->Value);
break;
case ObjectTypes.Object:
ArraySetValue(arr, mStack[val->Value], idx->Value);
break;
case ObjectTypes.Integer:
arr.SetValue(val->Value, idx->Value);
break;
case ObjectTypes.Long:
arr.SetValue(*(long*)&val->Value, idx->Value);
break;
case ObjectTypes.Float:
arr.SetValue(*(float*)&val->Value, idx->Value);
break;
case ObjectTypes.Double:
arr.SetValue(*(double*)&val->Value, idx->Value);
break;
case ObjectTypes.ValueTypeObjectReference:
ArraySetValue(arr, StackObject.ToObject(val, domain, mStack), idx->Value);
FreeStackValueType(esp - 1);
break;
default:
throw new NotImplementedException();
}
}
else
{
switch (val->ObjectType)
{
case ObjectTypes.Object:
ArraySetValue(arr, mStack[val->Value], idx->Value);
break;
case ObjectTypes.Integer:
{
StoreIntValueToArray(arr, val, idx);
}
break;
case ObjectTypes.Long:
{
if (arr is long[])
{
((long[])arr)[idx->Value] = *(long*)&val->Value;
}
else
{
((ulong[])arr)[idx->Value] = *(ulong*)&val->Value;
}
}
break;
case ObjectTypes.Float:
{
((float[])arr)[idx->Value] = *(float*)&val->Value;
}
break;
case ObjectTypes.Double:
{
((double[])arr)[idx->Value] = *(double*)&val->Value;
}
break;
case ObjectTypes.ValueTypeObjectReference:
ArraySetValue(arr, StackObject.ToObject(val, domain, mStack), idx->Value);
FreeStackValueType(esp - 1);
break;
default:
throw new NotImplementedException();
}
}
Free(esp - 1);
Free(esp - 1 - 1);
Free(esp - 1 - 1 - 1);
esp = esp - 1 - 1 - 1;
}
break;
case OpCodeEnum.Ldelem_Ref:
case OpCodeEnum.Ldelem_Any:
{
var idx = esp - 1;
arrRef = esp - 1 - 1;
Array arr = mStack[arrRef->Value] as Array;
obj = arr.GetValue(idx->Value);
if (obj is CrossBindingAdaptorType)
obj = ((CrossBindingAdaptorType)obj).ILInstance;
Free(esp - 1);
Free(esp - 1 - 1);
if (obj is ILTypeInstance)
{
ILTypeInstance ins = (ILTypeInstance)obj;
if (!(ins is DelegateAdapter) && ins.Type.IsValueType && !ins.Boxed)
{
AllocValueType(arrRef, ins.Type);
dst = ILIntepreter.ResolveReference(arrRef);
ins.CopyValueTypeToStack(dst, mStack);
esp = idx;
}
else
esp = PushObject(esp - 1 - 1, mStack, obj, true);
}
else
esp = PushObject(esp - 1 - 1, mStack, obj, !arr.GetType().GetElementType().IsPrimitive);
}
break;
case OpCodeEnum.Stelem_I1:
{
val = esp - 1;
var idx = esp - 1 - 1;
arrRef = esp - 1 - 1 - 1;
byte[] arr = mStack[arrRef->Value] as byte[];
if (arr != null)
{
arr[idx->Value] = (byte)val->Value;
}
else
{
bool[] arr2 = mStack[arrRef->Value] as bool[];
if (arr2 != null)
{
arr2[idx->Value] = val->Value == 1;
}
else
{
sbyte[] arr3 = mStack[arrRef->Value] as sbyte[];
arr3[idx->Value] = (sbyte)val->Value;
}
}
Free(esp - 1);
Free(esp - 1 - 1);
Free(esp - 1 - 1 - 1);
esp = esp - 1 - 1 - 1;
}
break;
case OpCodeEnum.Ldelem_I1:
{
var idx = esp - 1;
arrRef = esp - 1 - 1;
bool[] arr = mStack[arrRef->Value] as bool[];
if (arr != null)
intVal = arr[idx->Value] ? 1 : 0;
else
{
sbyte[] arr2 = mStack[arrRef->Value] as sbyte[];
intVal = arr2[idx->Value];
}
Free(esp - 1);
Free(esp - 1 - 1);
arrRef->ObjectType = ObjectTypes.Integer;
arrRef->Value = intVal;
esp -= 1;
}
break;
case OpCodeEnum.Ldelem_U1:
{
var idx = (esp - 1);
arrRef = esp - 1 - 1;
byte[] arr = mStack[arrRef->Value] as byte[];
if (arr != null)
intVal = arr[idx->Value];
else
{
bool[] arr2 = mStack[arrRef->Value] as bool[];
intVal = arr2[idx->Value] ? 1 : 0;
}
Free(esp - 1);
Free(esp - 1 - 1);
arrRef->ObjectType = ObjectTypes.Integer;
arrRef->Value = intVal;
esp -= 1;
}
break;
case OpCodeEnum.Stelem_I2:
{
val = esp - 1;
var idx = esp - 1 - 1;
arrRef = esp - 1 - 1 - 1;
short[] arr = mStack[arrRef->Value] as short[];
if (arr != null)
{
arr[idx->Value] = (short)val->Value;
}
else
{
ushort[] arr2 = mStack[arrRef->Value] as ushort[];
if (arr2 != null)
{
arr2[idx->Value] = (ushort)val->Value;
}
else
{
char[] arr3 = mStack[arrRef->Value] as char[];
arr3[idx->Value] = (char)val->Value;
}
}
Free(esp - 1);
Free(esp - 1 - 1);
Free(esp - 1 - 1 - 1);
esp = esp - 1 - 1 - 1;
}
break;
case OpCodeEnum.Ldelem_I2:
{
var idx = (esp - 1)->Value;
arrRef = esp - 1 - 1;
short[] arr = mStack[arrRef->Value] as short[];
if (arr != null)
{
intVal = arr[idx];
}
else
{
char[] arr2 = mStack[arrRef->Value] as char[];
intVal = arr2[idx];
}
Free(esp - 1);
Free(esp - 1 - 1);
arrRef->ObjectType = ObjectTypes.Integer;
arrRef->Value = intVal;
esp -= 1;
}
break;
case OpCodeEnum.Ldelem_U2:
{
var idx = (esp - 1)->Value;
arrRef = esp - 1 - 1;
ushort[] arr = mStack[arrRef->Value] as ushort[];
if (arr != null)
{
intVal = arr[idx];
}
else
{
char[] arr2 = mStack[arrRef->Value] as char[];
intVal = arr2[idx];
}
Free(esp - 1);
Free(esp - 1 - 1);
arrRef->ObjectType = ObjectTypes.Integer;
arrRef->Value = intVal;
esp -= 1;
}
break;
case OpCodeEnum.Stelem_I4:
{
val = esp - 1;
var idx = esp - 1 - 1;
arrRef = esp - 1 - 1 - 1;
int[] arr = mStack[arrRef->Value] as int[];
if (arr != null)
{
arr[idx->Value] = val->Value;
}
else
{
uint[] arr2 = mStack[arrRef->Value] as uint[];
arr2[idx->Value] = (uint)val->Value;
}
Free(esp - 1);
Free(esp - 1 - 1);
Free(esp - 1 - 1 - 1);
esp = esp - 1 - 1 - 1;
}
break;
case OpCodeEnum.Ldelem_I4:
{
var idx = (esp - 1)->Value;
arrRef = esp - 1 - 1;
int[] arr = mStack[arrRef->Value] as int[];
Free(esp - 1);
Free(esp - 1 - 1);
arrRef->ObjectType = ObjectTypes.Integer;
arrRef->Value = arr[idx];
esp -= 1;
}
break;
case OpCodeEnum.Ldelem_U4:
{
var idx = (esp - 1)->Value;
arrRef = esp - 1 - 1;
uint[] arr = mStack[arrRef->Value] as uint[];
Free(esp - 1);
Free(esp - 1 - 1);
arrRef->ObjectType = ObjectTypes.Integer;
arrRef->Value = (int)arr[idx];
esp -= 1;
}
break;
case OpCodeEnum.Stelem_I8:
{
val = esp - 1;
var idx = esp - 1 - 1;
arrRef = esp - 1 - 1 - 1;
long[] arr = mStack[arrRef->Value] as long[];
if (arr != null)
{
arr[idx->Value] = *(long*)&val->Value;
}
else
{
ulong[] arr2 = mStack[arrRef->Value] as ulong[];
arr2[idx->Value] = *(ulong*)&val->Value;
}
Free(esp - 1);
Free(esp - 1 - 1);
Free(esp - 1 - 1 - 1);
esp = esp - 1 - 1 - 1;
}
break;
case OpCodeEnum.Ldelem_I8:
{
var idx = esp - 1;
arrRef = esp - 1 - 1;
long[] arr = mStack[arrRef->Value] as long[];
long longVal;
if (arr != null)
longVal = arr[idx->Value];
else
{
ulong[] arr2 = mStack[arrRef->Value] as ulong[];
longVal = (long)arr2[idx->Value];
}
Free(esp - 1);
Free(esp - 1 - 1);
arrRef->ObjectType = ObjectTypes.Long;
*(long*)&arrRef->Value = longVal;
esp -= 1;
}
break;
case OpCodeEnum.Stelem_R4:
{
val = esp - 1;
var idx = esp - 1 - 1;
arrRef = esp - 1 - 1 - 1;
float[] arr = mStack[arrRef->Value] as float[];
arr[idx->Value] = *(float*)&val->Value;
Free(esp - 1);
Free(esp - 1 - 1);
Free(esp - 1 - 1 - 1);
esp = esp - 1 - 1 - 1;
}
break;
case OpCodeEnum.Ldelem_R4:
{
var idx = (esp - 1)->Value;
arrRef = esp - 1 - 1;
float[] arr = mStack[arrRef->Value] as float[];
Free(esp - 1);
Free(esp - 1 - 1);
arrRef->ObjectType = ObjectTypes.Float;
*(float*)&arrRef->Value = arr[idx];
esp -= 1;
}
break;
case OpCodeEnum.Stelem_R8:
{
val = esp - 1;
var idx = esp - 1 - 1;
arrRef = esp - 1 - 1 - 1;
double[] arr = mStack[arrRef->Value] as double[];
arr[idx->Value] = *(double*)&val->Value;
Free(esp - 1);
Free(esp - 1 - 1);
Free(esp - 1 - 1 - 1);
esp = esp - 1 - 1 - 1;
}
break;
case OpCodeEnum.Ldelem_R8:
{
var idx = (esp - 1)->Value;
arrRef = esp - 1 - 1;
double[] arr = mStack[arrRef->Value] as double[];
Free(esp - 1);
Free(esp - 1 - 1);
arrRef->ObjectType = ObjectTypes.Double;
*(double*)&arrRef->Value = arr[idx];
esp -= 1;
}
break;
case OpCodeEnum.Ldlen:
{
arrRef = esp - 1;
Array arr = mStack[arrRef->Value] as Array;
Free(esp - 1);
arrRef->ObjectType = ObjectTypes.Integer;
arrRef->Value = arr.Length;
}
break;
case OpCodeEnum.Ldelema:
{
arrRef = esp - 1 - 1;
var idx = (esp - 1)->Value;
Array arr = mStack[arrRef->Value] as Array;
Free(esp - 1);
Free(esp - 1 - 1);
arrRef->ObjectType = ObjectTypes.ArrayReference;
arrRef->Value = mStack.Count;
mStack.Add(arr);
arrRef->ValueLow = idx;
esp--;
}
break;
#endregion
#region Conversion
case OpCodeEnum.Conv_U1:
case OpCodeEnum.Conv_Ovf_U1:
case OpCodeEnum.Conv_Ovf_U1_Un:
{
objRef = esp - 1;
switch (objRef->ObjectType)
{
case ObjectTypes.Long:
case ObjectTypes.Integer:
intVal = (byte)objRef->Value;
break;
case ObjectTypes.Float:
intVal = (byte)*(float*)&objRef->Value;
break;
case ObjectTypes.Double:
intVal = (byte)*(double*)&objRef->Value;
break;
default:
throw new NotImplementedException();
}
objRef->ObjectType = ObjectTypes.Integer;
objRef->Value = intVal;
objRef->ValueLow = 0;
}
break;
case OpCodeEnum.Conv_I1:
case OpCodeEnum.Conv_Ovf_I1:
case OpCodeEnum.Conv_Ovf_I1_Un:
{
objRef = esp - 1;
switch (objRef->ObjectType)
{
case ObjectTypes.Long:
case ObjectTypes.Integer:
intVal = (sbyte)objRef->Value;
break;
case ObjectTypes.Float:
intVal = (sbyte)*(float*)&objRef->Value;
break;
case ObjectTypes.Double:
intVal = (sbyte)*(double*)&objRef->Value;
break;
default:
throw new NotImplementedException();
}
objRef->ObjectType = ObjectTypes.Integer;
objRef->Value = intVal;
objRef->ValueLow = 0;
}
break;
case OpCodeEnum.Conv_U2:
case OpCodeEnum.Conv_Ovf_U2:
case OpCodeEnum.Conv_Ovf_U2_Un:
{
objRef = esp - 1;
switch (objRef->ObjectType)
{
case ObjectTypes.Long:
case ObjectTypes.Integer:
intVal = (ushort)objRef->Value;
break;
case ObjectTypes.Float:
intVal = (ushort)*(float*)&objRef->Value;
break;
case ObjectTypes.Double:
intVal = (ushort)*(double*)&objRef->Value;
break;
default:
throw new NotImplementedException();
}
objRef->ObjectType = ObjectTypes.Integer;
objRef->Value = intVal;
objRef->ValueLow = 0;
}
break;
case OpCodeEnum.Conv_I2:
case OpCodeEnum.Conv_Ovf_I2:
case OpCodeEnum.Conv_Ovf_I2_Un:
{
objRef = esp - 1;
switch (objRef->ObjectType)
{
case ObjectTypes.Long:
case ObjectTypes.Integer:
intVal = (short)(objRef->Value);
break;
case ObjectTypes.Float:
intVal = (short)*(float*)&objRef->Value;
break;
case ObjectTypes.Double:
intVal = (short)*(double*)&objRef->Value;
break;
default:
throw new NotImplementedException();
}
objRef->ObjectType = ObjectTypes.Integer;
objRef->Value = intVal;
objRef->ValueLow = 0;
}
break;
case OpCodeEnum.Conv_U4:
case OpCodeEnum.Conv_U:
case OpCodeEnum.Conv_Ovf_U4:
case OpCodeEnum.Conv_Ovf_U4_Un:
{
objRef = esp - 1;
uint uintVal;
switch (objRef->ObjectType)
{
case ObjectTypes.Long:
uintVal = (uint)*(long*)&objRef->Value;
break;
case ObjectTypes.Integer:
uintVal = (uint)objRef->Value;
break;
case ObjectTypes.Float:
uintVal = (uint)*(float*)&objRef->Value;
break;
case ObjectTypes.Double:
uintVal = (uint)*(double*)&objRef->Value;
break;
default:
throw new NotImplementedException();
}
objRef->ObjectType = ObjectTypes.Integer;
objRef->Value = (int)uintVal;
objRef->ValueLow = 0;
}
break;
case OpCodeEnum.Conv_I4:
case OpCodeEnum.Conv_I:
case OpCodeEnum.Conv_Ovf_I:
case OpCodeEnum.Conv_Ovf_I_Un:
case OpCodeEnum.Conv_Ovf_I4:
case OpCodeEnum.Conv_Ovf_I4_Un:
{
objRef = esp - 1;
switch (objRef->ObjectType)
{
case ObjectTypes.Long:
intVal = (int)*(long*)&objRef->Value;
break;
case ObjectTypes.Float:
intVal = (int)*(float*)&objRef->Value;
break;
case ObjectTypes.Double:
intVal = (int)*(double*)&objRef->Value;
break;
case ObjectTypes.Integer:
intVal = objRef->Value;
break;
default:
throw new NotImplementedException();
}
objRef->ObjectType = ObjectTypes.Integer;
objRef->Value = intVal;
}
break;
case OpCodeEnum.Conv_I8:
case OpCodeEnum.Conv_Ovf_I8:
case OpCodeEnum.Conv_Ovf_I8_Un:
{
objRef = esp - 1;
long longVal;
switch (objRef->ObjectType)
{
case ObjectTypes.Integer:
longVal = objRef->Value;
break;
case ObjectTypes.Long:
ip++;
continue;
case ObjectTypes.Float:
longVal = (long)*(float*)&objRef->Value;
break;
case ObjectTypes.Double:
longVal = (long)*(double*)&objRef->Value;
break;
default:
throw new NotImplementedException();
}
objRef->ObjectType = ObjectTypes.Long;
*(long*)(&objRef->Value) = longVal;
}
break;
case OpCodeEnum.Conv_U8:
case OpCodeEnum.Conv_Ovf_U8:
case OpCodeEnum.Conv_Ovf_U8_Un:
{
objRef = esp - 1;
ulong ulongVal;
switch (objRef->ObjectType)
{
case ObjectTypes.Integer:
ulongVal = (uint)objRef->Value;
break;
case ObjectTypes.Long:
ip++;
continue;
case ObjectTypes.Float:
ulongVal = (ulong)*(float*)&objRef->Value;
break;
case ObjectTypes.Double:
ulongVal = (ulong)*(double*)&objRef->Value;
break;
default:
throw new NotImplementedException();
}
objRef->ObjectType = ObjectTypes.Long;
*(ulong*)(&objRef->Value) = ulongVal;
}
break;
case OpCodeEnum.Conv_R4:
{
objRef = esp - 1;
float floatVal;
switch (objRef->ObjectType)
{
case ObjectTypes.Long:
floatVal = (float)*(long*)&objRef->Value;
break;
case ObjectTypes.Float:
ip++;
continue;
case ObjectTypes.Double:
floatVal = (float)*(double*)&objRef->Value;
break;
case ObjectTypes.Integer:
floatVal = objRef->Value;
break;
default:
throw new NotImplementedException();
}
objRef->ObjectType = ObjectTypes.Float;
*(float*)&objRef->Value = floatVal;
}
break;
case OpCodeEnum.Conv_R8:
{
objRef = esp - 1;
double doubleVal;
switch (objRef->ObjectType)
{
case ObjectTypes.Long:
doubleVal = (double)*(long*)&objRef->Value;
break;
case ObjectTypes.Float:
doubleVal = *(float*)&objRef->Value;
break;
case ObjectTypes.Integer:
doubleVal = objRef->Value;
break;
case ObjectTypes.Double:
ip++;
continue;
default:
throw new NotImplementedException();
}
objRef->ObjectType = ObjectTypes.Double;
*(double*)&objRef->Value = doubleVal;
}
break;
case OpCodeEnum.Conv_R_Un:
{
objRef = esp - 1;
bool isDouble = false;
float floatVal = 0;
double val2 = 0;
switch (objRef->ObjectType)
{
case ObjectTypes.Long:
val2 = (double)*(ulong*)&objRef->Value;
isDouble = true;
break;
case ObjectTypes.Float:
ip++;
continue;
case ObjectTypes.Integer:
floatVal = (uint)objRef->Value;
break;
case ObjectTypes.Double:
ip++;
continue;
default:
throw new NotImplementedException();
}
if (isDouble)
{
objRef->ObjectType = ObjectTypes.Double;
*(double*)&objRef->Value = val2;
}
else
{
objRef->ObjectType = ObjectTypes.Float;
*(float*)&objRef->Value = floatVal;
}
}
break;
#endregion
#region Stack operation
case OpCodeEnum.Pop:
{
Free(esp - 1);
esp--;
}
break;
case OpCodeEnum.Dup:
{
objRef = esp - 1;
if (objRef->ObjectType == ObjectTypes.ValueTypeObjectReference)
{
CloneStackValueType(objRef, esp, mStack);
}
else
{
*esp = *objRef;
if (esp->ObjectType >= ObjectTypes.Object)
{
esp->Value = mStack.Count;
mStack.Add(mStack[objRef->Value]);
}
}
esp++;
}
break;
#endregion
case OpCodeEnum.Throw:
{
objRef = GetObjectAndResolveReference(esp - 1);
var ex = mStack[objRef->Value] as Exception;
Free(objRef);
esp--;
throw ex;
}
case OpCodeEnum.Rethrow:
{
throw lastCaughtEx;
}
case OpCodeEnum.Nop:
case OpCodeEnum.Volatile:
case OpCodeEnum.Readonly:
break;
default:
throw new NotSupportedException("Not supported opcode " + code);
}
ip++;
}
catch (Exception ex)
{
if (ehs != null)
{
int addr = (int)(ip - ptr);
var eh = GetCorrespondingExceptionHandler(ehs, ex, addr, ExceptionHandlerType.Catch, true);
if (eh == null)
{
eh = GetCorrespondingExceptionHandler(ehs, ex, addr, ExceptionHandlerType.Catch, false);
}
if (eh != null)
{
if (ex is ILRuntimeException)
{
ILRuntimeException ire = (ILRuntimeException)ex;
var inner = ire.InnerException;
inner.Data["ThisInfo"] = ire.ThisInfo;
inner.Data["StackTrace"] = inner.Data.Contains("StackTrace") ? string.Format("{0}\n--- End of stack trace from previous location ---\n{1}", ire.StackTrace, inner.Data["StackTrace"]) : ire.StackTrace;
inner.Data["LocalInfo"] = ire.LocalInfo;
ex = inner;
}
else
{
var debugger = AppDomain.DebugService;
if (method.HasThis)
ex.Data["ThisInfo"] = debugger.GetThisInfo(this);
else
ex.Data["ThisInfo"] = "";
ex.Data["StackTrace"] = ex.Data.Contains("StackTrace") ? string.Format("{0}\n--- End of stack trace from previous location ---\n{1}", debugger.GetStackTrace(this), ex.Data["StackTrace"]) : debugger.GetStackTrace(this);
ex.Data["LocalInfo"] = debugger.GetLocalVariableInfo(this);
}
//Clear call stack
while (stack.Frames.Peek().BasePointer != frame.BasePointer)
{
var f = stack.Frames.Peek();
esp = stack.PopFrame(ref f, esp);
if (f.Method.ReturnType != AppDomain.VoidType)
{
Free(esp - 1);
esp--;
}
}
lastCaughtEx = ex;
esp = PushObject(esp, mStack, ex);
unhandledException = false;
var eh2 = FindExceptionHandlerByBranchTarget(addr, eh.HandlerStart, ehs);
if (eh2 != null)
{
finallyEndAddress = eh.HandlerStart;
ip = ptr + eh2.HandlerStart;
continue;
}
ip = ptr + eh.HandlerStart;
continue;
}
eh = GetCorrespondingExceptionHandler(ehs, null, addr, ExceptionHandlerType.Fault, false);
if(eh == null)
eh = GetCorrespondingExceptionHandler(ehs, null, addr, ExceptionHandlerType.Finally, false);
if(eh != null)
{
unhandledException = false;
finallyEndAddress = -1;
lastCaughtEx = ex is ILRuntimeException ? ex : new ILRuntimeException(ex.Message, this, method, ex);
ip = ptr + eh.HandlerStart;
continue;
}
}
if (unhandledException)
{
throw ex;
}
unhandledException = true;
returned = true;
#if DEBUG && !DISABLE_ILRUNTIME_DEBUG
if (!AppDomain.DebugService.Break(this, ex))
#endif
{
var newEx = new ILRuntimeException(ex.Message, this, method, ex);
throw newEx;
}
}
}
}
#if DEBUG && !NO_PROFILER
if (System.Threading.Thread.CurrentThread.ManagedThreadId == AppDomain.UnityMainThreadID)
#if UNITY_5_5_OR_NEWER
UnityEngine.Profiling.Profiler.EndSample();
#else
UnityEngine.Profiler.EndSample();
#endif
#endif
//ClearStack
return stack.PopFrame(ref frame, esp);
}
ExceptionHandler FindExceptionHandlerByBranchTarget(int addr, int branchTarget, ExceptionHandler[] ehs)
{
ExceptionHandler eh = null;
for (int i = 0; i < ehs.Length; i++)
{
var e = ehs[i];
if (addr >= e.TryStart && addr <= e.TryEnd && (branchTarget < e.TryStart || branchTarget > e.TryEnd) && e.HandlerType == ExceptionHandlerType.Finally)
{
eh = e;
break;
}
}
return eh;
}
void PrepareRegisterCallStack(StackObject* esp, IList<object> mStack, ILMethod method)
{
var pCnt = method.HasThis ? method.ParameterCount + 1 : method.ParameterCount;
StackObject* basePointer = esp - pCnt;
int mBase = mStack.Count;
int existing = 0;
for (int i = 0; i < pCnt; i++)
{
StackObject* cur = basePointer + i;
if (cur->ObjectType < ObjectTypes.Object)
{
mStack.Add(null);
}
else
existing++;
}
if (existing > 0)
{
mBase = mBase - existing;
for (int i = pCnt - 1; i >= 0; i--)
{
StackObject* cur = basePointer + i;
if (cur->ObjectType >= ObjectTypes.Object)
{
mStack[mBase + i] = mStack[cur->Value];
cur->Value = mBase + i;
}
else
{
if (cur->ObjectType == ObjectTypes.Null)
{
cur->ObjectType = ObjectTypes.Object;
cur->Value = mBase + i;
}
mStack[mBase + i] = null;
}
}
}
}
void DumpStack(StackObject* esp)
{
AppDomain.DebugService.DumpStack(esp, stack);
}
void CloneStackValueType(StackObject* src, StackObject* dst, IList<object> mStack)
{
StackObject* descriptor = ILIntepreter.ResolveReference(src);
stack.AllocValueType(dst, AppDomain.GetTypeByIndex(descriptor->Value));
StackObject* dstDescriptor = ILIntepreter.ResolveReference(dst);
int cnt = descriptor->ValueLow;
for (int i = 0; i < cnt; i++)
{
StackObject* val = Minus(descriptor, i + 1);
CopyToValueTypeField(dstDescriptor, i, val, mStack);
}
}
bool CanCastTo(StackObject* src, StackObject* dst)
{
var sType = AppDomain.GetTypeByIndex(src->Value);
var dType = AppDomain.GetTypeByIndex(dst->Value);
return sType.CanAssignTo(dType);
}
bool CanCopyStackValueType(StackObject* src, StackObject* dst)
{
if (src->ObjectType == ObjectTypes.ValueTypeObjectReference && dst->ObjectType == ObjectTypes.ValueTypeObjectReference)
{
StackObject* descriptor = ILIntepreter.ResolveReference(src);
StackObject* dstDescriptor = ILIntepreter.ResolveReference(dst);
return CanCastTo(descriptor, dstDescriptor);
}
else
return false;
}
#if DEBUG
public void CopyStackValueType(StackObject* src, StackObject* dst, IList<object> mStack, bool noCheck = false)
#else
public void CopyStackValueType(StackObject* src, StackObject* dst, IList<object> mStack)
#endif
{
#if DEBUG
CopyStackValueType(src, dst, mStack, mStack, noCheck);
#else
CopyStackValueType(src, dst, mStack, mStack);
#endif
}
#if DEBUG
public void CopyStackValueType(StackObject* src, StackObject* dst, IList<object> mStack, IList<object> dstmStack, bool noCheck = false)
#else
public void CopyStackValueType(StackObject* src, StackObject* dst, IList<object> mStack, IList<object> dstmStack)
#endif
{
StackObject* descriptor = ILIntepreter.ResolveReference(src);
StackObject* dstDescriptor = ILIntepreter.ResolveReference(dst);
#if DEBUG
if (!CanCastTo(descriptor, dstDescriptor))
throw new InvalidCastException();
#endif
int cnt = descriptor->ValueLow;
for (int i = 0; i < cnt; i++)
{
StackObject* srcVal = Minus(descriptor, i + 1);
StackObject* dstVal = Minus(dstDescriptor, i + 1);
#if DEBUG
if (!noCheck && srcVal->ObjectType != dstVal->ObjectType)
throw new NotSupportedException();
#endif
switch (srcVal->ObjectType)
{
case ObjectTypes.Object:
case ObjectTypes.ArrayReference:
case ObjectTypes.FieldReference:
dstmStack[dstVal->Value] = mStack[srcVal->Value];
break;
case ObjectTypes.ValueTypeObjectReference:
CopyStackValueType(srcVal, dstVal, mStack, dstmStack);
break;
default:
*dstVal = *srcVal;
break;
}
}
}
void CopyValueTypeToStack(StackObject* dst, object ins, IList<object> mStack)
{
if (ins is ILTypeInstance)
{
((ILTypeInstance)ins).CopyValueTypeToStack(dst, mStack);
}
else
{
if (ins is CrossBindingAdaptorType)
{
((CrossBindingAdaptorType)ins).ILInstance.CopyValueTypeToStack(dst, mStack);
}
else
{
var vb = ((CLRType)domain.GetTypeByIndex(dst->Value)).ValueTypeBinder;
vb.CopyValueTypeToStack(ins, dst, mStack);
}
}
}
void CopyToValueTypeField(StackObject* obj, int idx, StackObject* val, IList<object> mStack)
{
StackObject* dst = Minus(obj, idx + 1);
switch (val->ObjectType)
{
case ObjectTypes.Null:
{
mStack[dst->Value] = null;
}
break;
case ObjectTypes.Object:
case ObjectTypes.FieldReference:
case ObjectTypes.ArrayReference:
{
if (dst->ObjectType == ObjectTypes.ValueTypeObjectReference)
{
var ins = mStack[val->Value];
dst = ILIntepreter.ResolveReference(dst);
CopyValueTypeToStack(dst, ins, mStack);
}
else
{
mStack[dst->Value] = CheckAndCloneValueType(mStack[val->Value], domain);
}
}
break;
case ObjectTypes.ValueTypeObjectReference:
{
if (dst->ObjectType == ObjectTypes.ValueTypeObjectReference)
{
CopyStackValueType(val, dst, mStack);
}
else
throw new NotImplementedException();
}
break;
default:
*dst = *val;
break;
}
}
void StLocSub(StackObject* esp, StackObject* v, int idx, IList<object> mStack)
{
switch (esp->ObjectType)
{
case ObjectTypes.Null:
v->ObjectType = ObjectTypes.Object;
v->Value = idx;
mStack[idx] = null;
break;
case ObjectTypes.Object:
case ObjectTypes.FieldReference:
case ObjectTypes.ArrayReference:
if (v->ObjectType == ObjectTypes.ValueTypeObjectReference)
{
var obj = mStack[esp->Value];
if (obj is ILTypeInstance)
{
var dst = ILIntepreter.ResolveReference(v);
((ILTypeInstance)obj).CopyValueTypeToStack(dst, mStack);
}
else
{
var dst = ILIntepreter.ResolveReference(v);
var ct = domain.GetTypeByIndex(dst->Value) as CLRType;
var binder = ct.ValueTypeBinder;
binder.CopyValueTypeToStack(obj, dst, mStack);
}
}
else
{
*v = *esp;
mStack[idx] = CheckAndCloneValueType(mStack[v->Value], domain);
v->Value = idx;
}
Free(esp);
break;
case ObjectTypes.ValueTypeObjectReference:
if (v->ObjectType == ObjectTypes.ValueTypeObjectReference)
{
CopyStackValueType(esp, v, mStack);
}
else
throw new NotImplementedException();
FreeStackValueType(esp);
break;
default:
*v = *esp;
mStack[idx] = null;
break;
}
}
public object RetriveObject(StackObject* esp, IList<object> mStack)
{
StackObject* objRef = GetObjectAndResolveReference(esp);
if (objRef->ObjectType == ObjectTypes.Null)
return null;
object obj = null;
switch (objRef->ObjectType)
{
case ObjectTypes.Object:
obj = mStack[objRef->Value];
break;
case ObjectTypes.FieldReference:
{
obj = mStack[objRef->Value];
int idx = objRef->ValueLow;
if (obj is ILTypeInstance)
{
obj = ((ILTypeInstance)obj)[idx];
}
else
{
var t = AppDomain.GetType(obj.GetType());
obj = ((CLRType)t).GetFieldValue(idx, obj);
}
}
break;
case ObjectTypes.ArrayReference:
{
Array arr = mStack[objRef->Value] as Array;
int idx = objRef->ValueLow;
obj = arr.GetValue(idx);
}
break;
case ObjectTypes.StaticFieldReference:
{
var t = AppDomain.GetType(objRef->Value);
int idx = objRef->ValueLow;
if (t is ILType)
{
obj = ((ILType)t).StaticInstance[idx];
}
else
{
obj = ((CLRType)t).GetFieldValue(idx, null);
}
}
break;
case ObjectTypes.ValueTypeObjectReference:
obj = StackObject.ToObject(objRef, domain, mStack);
break;
default:
throw new NotImplementedException();
}
return obj;
}
public int RetriveInt32(StackObject* esp, IList<object> mStack)
{
StackObject* objRef = GetObjectAndResolveReference(esp);
if (objRef->ObjectType == ObjectTypes.Null)
return 0;
object obj = null;
int res = 0;
switch (objRef->ObjectType)
{
case ObjectTypes.Object:
res = (int)mStack[objRef->Value];
break;
case ObjectTypes.Integer:
res = objRef->Value;
break;
case ObjectTypes.FieldReference:
{
obj = mStack[objRef->Value];
int idx = objRef->ValueLow;
if (obj is ILTypeInstance)
{
res = ((ILTypeInstance)obj).Fields[idx].Value;
}
else
{
var t = AppDomain.GetType(obj.GetType());
StackObject so;
var sop = &so;
if (!((CLRType)t).CopyFieldToStack(idx, obj, this, ref sop, mStack))
res = (int)((CLRType)t).GetFieldValue(idx, obj);
else
{
res = so.Value;
}
}
}
break;
case ObjectTypes.ArrayReference:
{
Array arr = mStack[objRef->Value] as Array;
int idx = objRef->ValueLow;
if (arr is int[])
res = ((int[])arr)[idx];
else
{
res = (int)Convert.ToInt32(arr.GetValue(idx));
}
}
break;
case ObjectTypes.StaticFieldReference:
{
var t = AppDomain.GetType(objRef->Value);
int idx = objRef->ValueLow;
if (t is ILType)
{
res = ((ILType)t).StaticInstance.Fields[idx].Value;
}
else
{
StackObject so;
var sop = &so;
if (!((CLRType)t).CopyFieldToStack(idx, null, this, ref sop, mStack))
res = (int)((CLRType)t).GetFieldValue(idx, null);
else
{
res = so.Value;
}
}
}
break;
default:
throw new NotImplementedException();
}
return res;
}
public long RetriveInt64(StackObject* esp, IList<object> mStack)
{
StackObject* objRef = GetObjectAndResolveReference(esp);
if (objRef->ObjectType == ObjectTypes.Null)
return 0;
object obj = null;
long res = 0;
switch (objRef->ObjectType)
{
case ObjectTypes.Object:
res = (long)mStack[objRef->Value];
break;
case ObjectTypes.Long:
res = *(long*)&objRef->Value;
break;
case ObjectTypes.FieldReference:
{
obj = mStack[objRef->Value];
int idx = objRef->ValueLow;
StackObject so;
if (obj is ILTypeInstance)
{
so = ((ILTypeInstance)obj).Fields[idx];
res = *(long*)&so.Value;
}
else
{
var t = AppDomain.GetType(obj.GetType());
var sop = &so;
if (!((CLRType)t).CopyFieldToStack(idx, obj, this, ref sop, mStack))
res = (long)((CLRType)t).GetFieldValue(idx, obj);
else
{
res = *(long*)&so.Value;
}
}
}
break;
case ObjectTypes.ArrayReference:
{
Array arr = mStack[objRef->Value] as Array;
int idx = objRef->ValueLow;
if (arr is long[])
res = ((long[])arr)[idx];
else
{
res = (long)arr.GetValue(idx);
}
}
break;
case ObjectTypes.StaticFieldReference:
{
var t = AppDomain.GetType(objRef->Value);
int idx = objRef->ValueLow;
StackObject so;
if (t is ILType)
{
so = ((ILType)t).StaticInstance.Fields[idx];
res = *(long*)&so.Value;
}
else
{
var sop = &so;
if (!((CLRType)t).CopyFieldToStack(idx, null, this, ref sop, mStack))
res = (long)((CLRType)t).GetFieldValue(idx, null);
else
{
res = *(long*)&so.Value;
}
}
}
break;
default:
throw new NotImplementedException();
}
return res;
}
public float RetriveFloat(StackObject* esp, IList<object> mStack)
{
StackObject* objRef = GetObjectAndResolveReference(esp);
if (objRef->ObjectType == ObjectTypes.Null)
return 0;
object obj = null;
float res = 0;
switch (objRef->ObjectType)
{
case ObjectTypes.Object:
res = (float)mStack[objRef->Value];
break;
case ObjectTypes.Float:
res = *(float*)&objRef->Value;
break;
case ObjectTypes.FieldReference:
{
obj = mStack[objRef->Value];
int idx = objRef->ValueLow;
StackObject so;
if (obj is ILTypeInstance)
{
so = ((ILTypeInstance)obj).Fields[idx];
res = *(float*)&so.Value;
}
else
{
var t = AppDomain.GetType(obj.GetType());
var sop = &so;
if (!((CLRType)t).CopyFieldToStack(idx, obj, this, ref sop, mStack))
res = (float)((CLRType)t).GetFieldValue(idx, obj);
else
{
res = *(float*)&so.Value;
}
}
}
break;
case ObjectTypes.ArrayReference:
{
Array arr = mStack[objRef->Value] as Array;
int idx = objRef->ValueLow;
if (arr is float[])
res = ((float[])arr)[idx];
else
{
res = (float)arr.GetValue(idx);
}
}
break;
case ObjectTypes.StaticFieldReference:
{
var t = AppDomain.GetType(objRef->Value);
int idx = objRef->ValueLow;
StackObject so;
if (t is ILType)
{
so = ((ILType)t).StaticInstance.Fields[idx];
res = *(float*)&so.Value;
}
else
{
var sop = &so;
if (!((CLRType)t).CopyFieldToStack(idx, null, this, ref sop, mStack))
res = (float)((CLRType)t).GetFieldValue(idx, null);
else
{
res = *(float*)&so.Value;
}
}
}
break;
default:
throw new NotImplementedException();
}
return res;
}
public double RetriveDouble(StackObject* esp, IList<object> mStack)
{
StackObject* objRef = GetObjectAndResolveReference(esp);
if (objRef->ObjectType == ObjectTypes.Null)
return 0;
object obj = null;
double res = 0;
switch (objRef->ObjectType)
{
case ObjectTypes.Object:
res = (double)mStack[objRef->Value];
break;
case ObjectTypes.Double:
res = *(double*)&objRef->Value;
break;
case ObjectTypes.FieldReference:
{
obj = mStack[objRef->Value];
int idx = objRef->ValueLow;
StackObject so;
if (obj is ILTypeInstance)
{
so = ((ILTypeInstance)obj).Fields[idx];
res = *(double*)&so.Value;
}
else
{
var t = AppDomain.GetType(obj.GetType());
var sop = &so;
if (!((CLRType)t).CopyFieldToStack(idx, obj, this, ref sop, mStack))
res = (double)((CLRType)t).GetFieldValue(idx, obj);
else
{
res = *(double*)&so.Value;
}
}
}
break;
case ObjectTypes.ArrayReference:
{
Array arr = mStack[objRef->Value] as Array;
int idx = objRef->ValueLow;
if (arr is double[])
res = ((double[])arr)[idx];
else
{
res = (double)arr.GetValue(idx);
}
}
break;
case ObjectTypes.StaticFieldReference:
{
var t = AppDomain.GetType(objRef->Value);
int idx = objRef->ValueLow;
StackObject so;
if (t is ILType)
{
so = ((ILType)t).StaticInstance.Fields[idx];
res = *(double*)&so.Value;
}
else
{
var sop = &so;
if (!((CLRType)t).CopyFieldToStack(idx, null, this, ref sop, mStack))
res = (double)((CLRType)t).GetFieldValue(idx, null);
else
{
res = *(double*)&so.Value;
}
}
}
break;
default:
throw new NotImplementedException();
}
return res;
}
void ArraySetValue(Array arr, object obj, int idx)
{
if (obj == null)
arr.SetValue(null, idx);
else
{
arr.SetValue(arr.GetType().GetElementType().CheckCLRTypes(obj), idx);
}
}
void StoreIntValueToArray(Array arr, StackObject* val, StackObject* idx)
{
{
int[] tmp = arr as int[];
if (tmp != null)
{
tmp[idx->Value] = val->Value;
return;
}
}
{
short[] tmp = arr as short[];
if (tmp != null)
{
tmp[idx->Value] = (short)val->Value;
return;
}
}
{
byte[] tmp = arr as byte[];
if (tmp != null)
{
tmp[idx->Value] = (byte)val->Value;
return;
}
}
{
bool[] tmp = arr as bool[];
if (tmp != null)
{
tmp[idx->Value] = val->Value == 1;
return;
}
}
{
uint[] tmp = arr as uint[];
if (tmp != null)
{
tmp[idx->Value] = (uint)val->Value;
return;
}
}
{
ushort[] tmp = arr as ushort[];
if (tmp != null)
{
tmp[idx->Value] = (ushort)val->Value;
return;
}
}
{
char[] tmp = arr as char[];
if (tmp != null)
{
tmp[idx->Value] = (char)val->Value;
return;
}
}
{
sbyte[] tmp = arr as sbyte[];
if (tmp != null)
{
tmp[idx->Value] = (sbyte)val->Value;
return;
}
}
throw new NotImplementedException();
}
ExceptionHandler GetCorrespondingExceptionHandler(ExceptionHandler[] eh, object obj, int addr, ExceptionHandlerType type, bool explicitMatch)
{
ExceptionHandler res = null;
int distance = int.MaxValue;
Exception ex = obj is ILRuntimeException ? ((ILRuntimeException)obj).InnerException : obj as Exception;
foreach (var i in eh)
{
if (i.HandlerType == type)
{
if (addr >= i.TryStart && addr <= i.TryEnd)
{
if (CheckExceptionType(i.CatchType, ex, explicitMatch))
{
int d = addr - i.TryStart;
if (d < distance)
{
distance = d;
res = i;
}
}
}
}
}
return res;
}
void LoadFromFieldReference(object obj, int idx, StackObject* dst, IList<object> mStack)
{
if (obj is ILTypeInstance)
{
((ILTypeInstance)obj).PushToStack(idx, dst, this, mStack);
}
else
{
CLRType t = AppDomain.GetType(obj.GetType()) as CLRType;
if (!t.CopyFieldToStack(idx, obj, this, ref dst, mStack))
ILIntepreter.PushObject(dst, mStack, t.GetFieldValue(idx, obj));
}
}
void StoreValueToFieldReference(ref object obj, int idx, StackObject* val, IList<object> mStack)
{
if (obj is ILTypeInstance)
{
((ILTypeInstance)obj).AssignFromStack(idx, val, AppDomain, mStack);
}
else
{
CLRType t = AppDomain.GetType(obj.GetType()) as CLRType;
//It's impossible to garantee this field reference is a direct reference, it'll cause problem if it's not
//if (!t.AssignFieldFromStack(idx, ref obj, this, val, mStack))
{
var v = obj.GetType().CheckCLRTypes(CheckAndCloneValueType(StackObject.ToObject(val, AppDomain, mStack), AppDomain));
t.SetFieldValue(idx, ref obj, v, true);
}
}
}
void LoadFromArrayReference(object obj, int idx, StackObject* objRef, IType t, IList<object> mStack, int managedIdx = -1)
{
var nT = t.TypeForCLR;
LoadFromArrayReference(obj, idx, objRef, nT, mStack, managedIdx);
}
void LoadFromArrayReference(object obj, int idx, StackObject* objRef, Type nT, IList<object> mStack, int managedIdx = -1)
{
if (nT.IsPrimitive)
{
if (nT == typeof(int))
{
int[] arr = obj as int[];
objRef->ObjectType = ObjectTypes.Integer;
objRef->Value = arr[idx];
objRef->ValueLow = 0;
}
else if (nT == typeof(short))
{
short[] arr = obj as short[];
objRef->ObjectType = ObjectTypes.Integer;
objRef->Value = arr[idx];
objRef->ValueLow = 0;
}
else if (nT == typeof(long))
{
long[] arr = obj as long[];
objRef->ObjectType = ObjectTypes.Long;
*(long*)&objRef->Value = arr[idx];
}
else if (nT == typeof(float))
{
float[] arr = obj as float[];
objRef->ObjectType = ObjectTypes.Float;
*(float*)&objRef->Value = arr[idx];
objRef->ValueLow = 0;
}
else if (nT == typeof(double))
{
double[] arr = obj as double[];
objRef->ObjectType = ObjectTypes.Double;
*(double*)&objRef->Value = arr[idx];
}
else if (nT == typeof(byte))
{
byte[] arr = obj as byte[];
objRef->ObjectType = ObjectTypes.Integer;
objRef->Value = arr[idx];
objRef->ValueLow = 0;
}
else if (nT == typeof(char))
{
char[] arr = obj as char[];
objRef->ObjectType = ObjectTypes.Integer;
objRef->Value = arr[idx];
objRef->ValueLow = 0;
}
else if (nT == typeof(uint))
{
uint[] arr = obj as uint[];
objRef->ObjectType = ObjectTypes.Integer;
*(uint*)&objRef->Value = arr[idx];
objRef->ValueLow = 0;
}
else if (nT == typeof(sbyte))
{
sbyte[] arr = obj as sbyte[];
objRef->ObjectType = ObjectTypes.Integer;
objRef->Value = arr[idx];
objRef->ValueLow = 0;
}
else if (nT == typeof(ulong))
{
ulong[] arr = obj as ulong[];
objRef->ObjectType = ObjectTypes.Long;
*(ulong*)&objRef->Value = arr[idx];
}
else
throw new NotImplementedException();
}
else
{
Array arr = obj as Array;
objRef->ObjectType = ObjectTypes.Object;
if (managedIdx >= 0)
{
objRef->Value = managedIdx;
mStack[managedIdx] = arr.GetValue(idx);
}
else
{
objRef->Value = mStack.Count;
mStack.Add(arr.GetValue(idx));
}
objRef->ValueLow = 0;
}
}
void StoreValueToArrayReference(StackObject* objRef, StackObject* val, IType t, IList<object> mStack)
{
var nT = t.TypeForCLR;
StoreValueToArrayReference(objRef, val, nT, mStack);
}
void StoreValueToArrayReference(StackObject* objRef, StackObject* val, Type nT, IList<object> mStack)
{
if (nT.IsPrimitive)
{
if (nT == typeof(int))
{
int[] arr = mStack[objRef->Value] as int[];
arr[objRef->ValueLow] = val->Value;
}
else if (nT == typeof(short))
{
short[] arr = mStack[objRef->Value] as short[];
arr[objRef->ValueLow] = (short)val->Value;
}
else if (nT == typeof(long))
{
long[] arr = mStack[objRef->Value] as long[];
arr[objRef->ValueLow] = *(long*)&val->Value;
}
else if (nT == typeof(float))
{
float[] arr = mStack[objRef->Value] as float[];
arr[objRef->ValueLow] = *(float*)&val->Value;
}
else if (nT == typeof(double))
{
double[] arr = mStack[objRef->Value] as double[];
arr[objRef->ValueLow] = *(double*)&val->Value;
}
else if (nT == typeof(byte))
{
byte[] arr = mStack[objRef->Value] as byte[];
arr[objRef->ValueLow] = (byte)val->Value;
}
else if (nT == typeof(char))
{
char[] arr = mStack[objRef->Value] as char[];
arr[objRef->ValueLow] = (char)val->Value;
}
else if (nT == typeof(uint))
{
uint[] arr = mStack[objRef->Value] as uint[];
arr[objRef->ValueLow] = (uint)val->Value;
}
else if (nT == typeof(sbyte))
{
sbyte[] arr = mStack[objRef->Value] as sbyte[];
arr[objRef->ValueLow] = (sbyte)val->Value;
}
else
throw new NotImplementedException();
}
else
{
Array arr = mStack[objRef->Value] as Array;
arr.SetValue(StackObject.ToObject(val, domain, mStack), objRef->ValueLow);
}
}
bool CheckExceptionType(IType catchType, object exception, bool explicitMatch)
{
if (catchType == null)
return true;
if (catchType is CLRType)
{
if (explicitMatch)
return exception.GetType() == catchType.TypeForCLR;
else
return catchType.TypeForCLR.IsAssignableFrom(exception.GetType());
}
else
throw new NotImplementedException();
}
#if NET_4_6 || NET_STANDARD_2_0
[System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
#endif
public static StackObject* ResolveReference(StackObject* esp)
{
var addr = *(long*)&esp->Value;
return (StackObject*)addr;
}
#if NET_4_6 || NET_STANDARD_2_0
[System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
#endif
public static StackObject* GetObjectAndResolveReference(StackObject* esp)
{
if (esp->ObjectType == ObjectTypes.StackObjectReference)
{
return ResolveReference(esp);
}
else
return esp;
}
StackObject* PushParameters(IMethod method, StackObject* esp, object[] p, bool useRegister)
{
IList<object> mStack = stack.ManagedStack;
var plist = method.Parameters;
int pCnt = plist != null ? plist.Count : 0;
int pCnt2 = p != null ? p.Length : 0;
if (pCnt != pCnt2)
throw new ArgumentOutOfRangeException("Parameter mismatch");
if (pCnt2 > 0)
{
for (int i = 0; i < p.Length; i++)
{
bool isBox = false;
if (plist != null && i < plist.Count)
isBox = plist[i] == AppDomain.ObjectType;
object obj = p[i];
if (obj is CrossBindingAdaptorType)
obj = ((CrossBindingAdaptorType)obj).ILInstance;
var res = ILIntepreter.PushObject(esp, mStack, obj, isBox);
if (esp->ObjectType < ObjectTypes.Object && useRegister)
mStack.Add(null);
esp = res;
}
}
return esp;
}
public void CopyToStack(StackObject* dst, StackObject* src, IList<object> mStack)
{
CopyToStack(dst, src, mStack, mStack);
}
void CopyToStack(StackObject* dst, StackObject* src, IList<object> mStack, IList<object> dstmStack)
{
if (src->ObjectType == ObjectTypes.ValueTypeObjectReference)
{
var descriptor = ResolveReference(src);
var t = domain.GetTypeByIndex(descriptor->Value);
AllocValueType(dst, t);
CopyStackValueType(src, dst, mStack, dstmStack);
}
else
{
*dst = *src;
if (dst->ObjectType >= ObjectTypes.Object)
{
dst->Value = dstmStack.Count;
var obj = mStack[src->Value];
dstmStack.Add(obj);
}
}
}
internal static object CheckAndCloneValueType(object obj, Enviorment.AppDomain domain)
{
if (obj != null)
{
if (obj is ILTypeInstance)
{
ILTypeInstance ins = obj as ILTypeInstance;
if (ins.IsValueType)
{
return ins.Clone();
}
}
else
{
var type = obj.GetType();
var typeFlags = type.GetTypeFlags();
var isPrimitive = (typeFlags & CLR.Utils.Extensions.TypeFlags.IsPrimitive) != 0;
var isValueType = (typeFlags & CLR.Utils.Extensions.TypeFlags.IsValueType) != 0;
if (!isPrimitive && isValueType)
{
var t = domain.GetType(type);
return ((CLRType)t).PerformMemberwiseClone(obj);
}
}
}
return obj;
}
#if NET_4_6 || NET_STANDARD_2_0
[System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
#endif
public static StackObject* PushOne(StackObject* esp)
{
esp->ObjectType = ObjectTypes.Integer;
esp->Value = 1;
return esp + 1;
}
#if NET_4_6 || NET_STANDARD_2_0
[System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
#endif
public static StackObject* PushZero(StackObject* esp)
{
esp->ObjectType = ObjectTypes.Integer;
esp->Value = 0;
return esp + 1;
}
#if NET_4_6 || NET_STANDARD_2_0
[System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
#endif
public static StackObject* PushNull(StackObject* esp)
{
esp->ObjectType = ObjectTypes.Null;
esp->Value = -1;
esp->ValueLow = 0;
return esp + 1;
}
public static void UnboxObject(StackObject* esp, object obj, IList<object> mStack = null, Enviorment.AppDomain domain = null)
{
if (esp->ObjectType == ObjectTypes.ValueTypeObjectReference && domain != null)
{
var dst = ILIntepreter.ResolveReference(esp);
var vt = domain.GetTypeByIndex(dst->Value);
if (obj == null)//Nothing to do
return;
if (obj is ILTypeInstance)
{
var ins = (ILTypeInstance)obj;
ins.CopyValueTypeToStack(dst, mStack);
}
else if (obj is CrossBindingAdaptorType)
{
var ins = ((CrossBindingAdaptorType)obj).ILInstance;
ins.CopyValueTypeToStack(dst, mStack);
}
else
{
((CLRType)vt).ValueTypeBinder.CopyValueTypeToStack(obj, dst, mStack);
}
}
else if(obj == null)
{
return;
}
else if (obj is int)
{
esp->ObjectType = ObjectTypes.Integer;
esp->Value = (int)obj;
}
else if (obj is bool)
{
esp->ObjectType = ObjectTypes.Integer;
esp->Value = (bool)(obj) ? 1 : 0;
}
else if (obj is short)
{
esp->ObjectType = ObjectTypes.Integer;
esp->Value = (short)obj;
}
else if (obj is long)
{
esp->ObjectType = ObjectTypes.Long;
*(long*)(&esp->Value) = (long)obj;
}
else if (obj is float)
{
esp->ObjectType = ObjectTypes.Float;
*(float*)(&esp->Value) = (float)obj;
}
else if (obj is byte)
{
esp->ObjectType = ObjectTypes.Integer;
esp->Value = (byte)obj;
}
else if (obj is uint)
{
esp->ObjectType = ObjectTypes.Integer;
esp->Value = (int)(uint)obj;
}
else if (obj is ushort)
{
esp->ObjectType = ObjectTypes.Integer;
esp->Value = (int)(ushort)obj;
}
else if (obj is char)
{
esp->ObjectType = ObjectTypes.Integer;
esp->Value = (int)(char)obj;
}
else if (obj is double)
{
esp->ObjectType = ObjectTypes.Double;
*(double*)(&esp->Value) = (double)obj;
}
else if (obj is ulong)
{
esp->ObjectType = ObjectTypes.Long;
*(ulong*)(&esp->Value) = (ulong)obj;
}
else if (obj is sbyte)
{
esp->ObjectType = ObjectTypes.Integer;
esp->Value = (sbyte)obj;
}
else if (obj is Enum)
{
esp->ObjectType = ObjectTypes.Integer;
esp->Value = Convert.ToInt32(obj);
}
else
throw new NotImplementedException();
}
public static StackObject* PushObject(StackObject* esp, IList<object> mStack, object obj, bool isBox = false)
{
if (obj != null)
{
if (!isBox)
{
var typeFlags = obj.GetType().GetTypeFlags();
if ((typeFlags & CLR.Utils.Extensions.TypeFlags.IsPrimitive) != 0)
{
UnboxObject(esp, obj, mStack);
}
else if ((typeFlags & CLR.Utils.Extensions.TypeFlags.IsEnum) != 0)
{
esp->ObjectType = ObjectTypes.Integer;
esp->Value = Convert.ToInt32(obj);
}
else
{
esp->ObjectType = ObjectTypes.Object;
esp->Value = mStack.Count;
mStack.Add(obj);
}
}
else
{
esp->ObjectType = ObjectTypes.Object;
esp->Value = mStack.Count;
mStack.Add(obj);
}
}
else
{
if (isBox)
{
esp->ObjectType = ObjectTypes.Object;
esp->Value = mStack.Count;
mStack.Add(obj);
}
else
return PushNull(esp);
}
return esp + 1;
}
//Don't ask me why add this funky method for this, otherwise Unity won't calculate the right value
#if NET_4_6 || NET_STANDARD_2_0
[System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
#endif
public static StackObject* Add(StackObject* a, int b)
{
return (StackObject*)((long)a + sizeof(StackObject) * b);
}
#if NET_4_6 || NET_STANDARD_2_0
[System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
#endif
public static StackObject* Minus(StackObject* a, int b)
{
return (StackObject*)((long)a - sizeof(StackObject) * b);
}
#if NET_4_6 || NET_STANDARD_2_0
[System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
#endif
public void Free(StackObject* esp)
{
switch (esp->ObjectType)
{
case ObjectTypes.Object:
case ObjectTypes.FieldReference:
case ObjectTypes.ArrayReference:
var mStack = stack.ManagedStack;
if (esp->Value == mStack.Count - 1)
mStack.RemoveAt(esp->Value);
break;
case ObjectTypes.ValueTypeObjectReference:
FreeStackValueType(esp);
break;
}
#if DEBUG && !DISABLE_ILRUNTIME_DEBUG
esp->ObjectType = ObjectTypes.Null;
esp->Value = -1;
esp->ValueLow = 0;
#endif
}
public void FreeStackValueType(StackObject* esp)
{
if (esp->ObjectType == ObjectTypes.ValueTypeObjectReference)
{
var addr = ILIntepreter.ResolveReference(esp);
if (addr <= ValueTypeBasePointer)//Only Stack allocation after base pointer should be freed, local variable are freed automatically
stack.FreeValueTypeObject(esp);
esp->ObjectType = ObjectTypes.Null;
}
}
public void AllocValueType(StackObject* ptr, IType type)
{
stack.AllocValueType(ptr, type);
}
}
}